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 {
557 // struct LDKCVec_u8Z TxOut_get_script_pubkey (struct LDKTxOut* thing)
559 export function TxOut_get_script_pubkey(thing: number): number {
560 if(!isWasmInitialized) {
561 throw new Error("initializeWasm() must be awaited first!");
563 const nativeResponseValue = wasm.TS_TxOut_get_script_pubkey(thing);
564 return nativeResponseValue;
566 // uint64_t TxOut_get_value (struct LDKTxOut* thing)
568 export function TxOut_get_value(thing: number): bigint {
569 if(!isWasmInitialized) {
570 throw new Error("initializeWasm() must be awaited first!");
572 const nativeResponseValue = wasm.TS_TxOut_get_value(thing);
573 return nativeResponseValue;
575 // void CResult_NoneNoneZ_get_ok(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
577 export function CResult_NoneNoneZ_get_ok(owner: number): void {
578 if(!isWasmInitialized) {
579 throw new Error("initializeWasm() must be awaited first!");
581 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_ok(owner);
582 // debug statements here
584 // void CResult_NoneNoneZ_get_err(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
586 export function CResult_NoneNoneZ_get_err(owner: number): void {
587 if(!isWasmInitialized) {
588 throw new Error("initializeWasm() must be awaited first!");
590 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_err(owner);
591 // debug statements here
593 // struct LDKCounterpartyCommitmentSecrets CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
595 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner: number): number {
596 if(!isWasmInitialized) {
597 throw new Error("initializeWasm() must be awaited first!");
599 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner);
600 return nativeResponseValue;
602 // struct LDKDecodeError CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
604 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner: number): number {
605 if(!isWasmInitialized) {
606 throw new Error("initializeWasm() must be awaited first!");
608 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner);
609 return nativeResponseValue;
611 // struct LDKSecretKey CResult_SecretKeyErrorZ_get_ok(LDKCResult_SecretKeyErrorZ *NONNULL_PTR owner);
613 export function CResult_SecretKeyErrorZ_get_ok(owner: number): number {
614 if(!isWasmInitialized) {
615 throw new Error("initializeWasm() must be awaited first!");
617 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_get_ok(owner);
618 return nativeResponseValue;
620 // enum LDKSecp256k1Error CResult_SecretKeyErrorZ_get_err(LDKCResult_SecretKeyErrorZ *NONNULL_PTR owner);
622 export function CResult_SecretKeyErrorZ_get_err(owner: number): Secp256k1Error {
623 if(!isWasmInitialized) {
624 throw new Error("initializeWasm() must be awaited first!");
626 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_get_err(owner);
627 return nativeResponseValue;
629 // struct LDKPublicKey CResult_PublicKeyErrorZ_get_ok(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
631 export function CResult_PublicKeyErrorZ_get_ok(owner: number): number {
632 if(!isWasmInitialized) {
633 throw new Error("initializeWasm() must be awaited first!");
635 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_ok(owner);
636 return nativeResponseValue;
638 // enum LDKSecp256k1Error CResult_PublicKeyErrorZ_get_err(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
640 export function CResult_PublicKeyErrorZ_get_err(owner: number): Secp256k1Error {
641 if(!isWasmInitialized) {
642 throw new Error("initializeWasm() must be awaited first!");
644 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_err(owner);
645 return nativeResponseValue;
647 // struct LDKTxCreationKeys CResult_TxCreationKeysDecodeErrorZ_get_ok(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
649 export function CResult_TxCreationKeysDecodeErrorZ_get_ok(owner: number): number {
650 if(!isWasmInitialized) {
651 throw new Error("initializeWasm() must be awaited first!");
653 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_ok(owner);
654 return nativeResponseValue;
656 // struct LDKDecodeError CResult_TxCreationKeysDecodeErrorZ_get_err(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
658 export function CResult_TxCreationKeysDecodeErrorZ_get_err(owner: number): number {
659 if(!isWasmInitialized) {
660 throw new Error("initializeWasm() must be awaited first!");
662 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_err(owner);
663 return nativeResponseValue;
665 // struct LDKChannelPublicKeys CResult_ChannelPublicKeysDecodeErrorZ_get_ok(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
667 export function CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner: number): number {
668 if(!isWasmInitialized) {
669 throw new Error("initializeWasm() must be awaited first!");
671 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner);
672 return nativeResponseValue;
674 // struct LDKDecodeError CResult_ChannelPublicKeysDecodeErrorZ_get_err(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
676 export function CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner: number): number {
677 if(!isWasmInitialized) {
678 throw new Error("initializeWasm() must be awaited first!");
680 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner);
681 return nativeResponseValue;
683 // struct LDKTxCreationKeys CResult_TxCreationKeysErrorZ_get_ok(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR owner);
685 export function CResult_TxCreationKeysErrorZ_get_ok(owner: number): number {
686 if(!isWasmInitialized) {
687 throw new Error("initializeWasm() must be awaited first!");
689 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_get_ok(owner);
690 return nativeResponseValue;
692 // enum LDKSecp256k1Error CResult_TxCreationKeysErrorZ_get_err(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR owner);
694 export function CResult_TxCreationKeysErrorZ_get_err(owner: number): Secp256k1Error {
695 if(!isWasmInitialized) {
696 throw new Error("initializeWasm() must be awaited first!");
698 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_get_err(owner);
699 return nativeResponseValue;
702 export class LDKCOption_u32Z {
703 protected constructor() {}
706 export function LDKCOption_u32Z_ty_from_ptr(ptr: number): number {
707 if(!isWasmInitialized) {
708 throw new Error("initializeWasm() must be awaited first!");
710 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_ty_from_ptr(ptr);
711 return nativeResponseValue;
714 export function LDKCOption_u32Z_Some_get_some(ptr: number): number {
715 if(!isWasmInitialized) {
716 throw new Error("initializeWasm() must be awaited first!");
718 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_Some_get_some(ptr);
719 return nativeResponseValue;
721 // struct LDKHTLCOutputInCommitment CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
723 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner: number): number {
724 if(!isWasmInitialized) {
725 throw new Error("initializeWasm() must be awaited first!");
727 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner);
728 return nativeResponseValue;
730 // struct LDKDecodeError CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
732 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner: number): number {
733 if(!isWasmInitialized) {
734 throw new Error("initializeWasm() must be awaited first!");
736 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner);
737 return nativeResponseValue;
739 // struct LDKCounterpartyChannelTransactionParameters CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
741 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner: number): number {
742 if(!isWasmInitialized) {
743 throw new Error("initializeWasm() must be awaited first!");
745 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner);
746 return nativeResponseValue;
748 // struct LDKDecodeError CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
750 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner: number): number {
751 if(!isWasmInitialized) {
752 throw new Error("initializeWasm() must be awaited first!");
754 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner);
755 return nativeResponseValue;
757 // struct LDKChannelTransactionParameters CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
759 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner: number): number {
760 if(!isWasmInitialized) {
761 throw new Error("initializeWasm() must be awaited first!");
763 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner);
764 return nativeResponseValue;
766 // struct LDKDecodeError CResult_ChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
768 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner: number): number {
769 if(!isWasmInitialized) {
770 throw new Error("initializeWasm() must be awaited first!");
772 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner);
773 return nativeResponseValue;
775 // struct LDKHolderCommitmentTransaction CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
777 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner: number): number {
778 if(!isWasmInitialized) {
779 throw new Error("initializeWasm() must be awaited first!");
781 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner);
782 return nativeResponseValue;
784 // struct LDKDecodeError CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
786 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner: number): number {
787 if(!isWasmInitialized) {
788 throw new Error("initializeWasm() must be awaited first!");
790 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner);
791 return nativeResponseValue;
793 // struct LDKBuiltCommitmentTransaction CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
795 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner: number): number {
796 if(!isWasmInitialized) {
797 throw new Error("initializeWasm() must be awaited first!");
799 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner);
800 return nativeResponseValue;
802 // struct LDKDecodeError CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
804 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner: number): number {
805 if(!isWasmInitialized) {
806 throw new Error("initializeWasm() must be awaited first!");
808 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner);
809 return nativeResponseValue;
811 // struct LDKTrustedClosingTransaction *CResult_TrustedClosingTransactionNoneZ_get_ok(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
813 export function CResult_TrustedClosingTransactionNoneZ_get_ok(owner: number): number {
814 if(!isWasmInitialized) {
815 throw new Error("initializeWasm() must be awaited first!");
817 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_ok(owner);
818 return nativeResponseValue;
820 // void CResult_TrustedClosingTransactionNoneZ_get_err(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
822 export function CResult_TrustedClosingTransactionNoneZ_get_err(owner: number): void {
823 if(!isWasmInitialized) {
824 throw new Error("initializeWasm() must be awaited first!");
826 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_err(owner);
827 // debug statements here
829 // struct LDKCommitmentTransaction CResult_CommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
831 export function CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner: number): number {
832 if(!isWasmInitialized) {
833 throw new Error("initializeWasm() must be awaited first!");
835 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner);
836 return nativeResponseValue;
838 // struct LDKDecodeError CResult_CommitmentTransactionDecodeErrorZ_get_err(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
840 export function CResult_CommitmentTransactionDecodeErrorZ_get_err(owner: number): number {
841 if(!isWasmInitialized) {
842 throw new Error("initializeWasm() must be awaited first!");
844 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_err(owner);
845 return nativeResponseValue;
847 // struct LDKTrustedCommitmentTransaction *CResult_TrustedCommitmentTransactionNoneZ_get_ok(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
849 export function CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner: number): number {
850 if(!isWasmInitialized) {
851 throw new Error("initializeWasm() must be awaited first!");
853 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner);
854 return nativeResponseValue;
856 // void CResult_TrustedCommitmentTransactionNoneZ_get_err(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
858 export function CResult_TrustedCommitmentTransactionNoneZ_get_err(owner: number): void {
859 if(!isWasmInitialized) {
860 throw new Error("initializeWasm() must be awaited first!");
862 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_err(owner);
863 // debug statements here
865 // struct LDKCVec_SignatureZ CResult_CVec_SignatureZNoneZ_get_ok(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
867 export function CResult_CVec_SignatureZNoneZ_get_ok(owner: number): number {
868 if(!isWasmInitialized) {
869 throw new Error("initializeWasm() must be awaited first!");
871 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_ok(owner);
872 return nativeResponseValue;
874 // void CResult_CVec_SignatureZNoneZ_get_err(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
876 export function CResult_CVec_SignatureZNoneZ_get_err(owner: number): void {
877 if(!isWasmInitialized) {
878 throw new Error("initializeWasm() must be awaited first!");
880 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_err(owner);
881 // debug statements here
883 // struct LDKShutdownScript CResult_ShutdownScriptDecodeErrorZ_get_ok(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
885 export function CResult_ShutdownScriptDecodeErrorZ_get_ok(owner: number): number {
886 if(!isWasmInitialized) {
887 throw new Error("initializeWasm() must be awaited first!");
889 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_ok(owner);
890 return nativeResponseValue;
892 // struct LDKDecodeError CResult_ShutdownScriptDecodeErrorZ_get_err(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
894 export function CResult_ShutdownScriptDecodeErrorZ_get_err(owner: number): number {
895 if(!isWasmInitialized) {
896 throw new Error("initializeWasm() must be awaited first!");
898 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_err(owner);
899 return nativeResponseValue;
901 // struct LDKShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
903 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner: number): number {
904 if(!isWasmInitialized) {
905 throw new Error("initializeWasm() must be awaited first!");
907 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner);
908 return nativeResponseValue;
910 // struct LDKInvalidShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
912 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner: number): number {
913 if(!isWasmInitialized) {
914 throw new Error("initializeWasm() must be awaited first!");
916 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner);
917 return nativeResponseValue;
919 // struct LDKRouteHop CResult_RouteHopDecodeErrorZ_get_ok(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
921 export function CResult_RouteHopDecodeErrorZ_get_ok(owner: number): number {
922 if(!isWasmInitialized) {
923 throw new Error("initializeWasm() must be awaited first!");
925 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_ok(owner);
926 return nativeResponseValue;
928 // struct LDKDecodeError CResult_RouteHopDecodeErrorZ_get_err(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
930 export function CResult_RouteHopDecodeErrorZ_get_err(owner: number): number {
931 if(!isWasmInitialized) {
932 throw new Error("initializeWasm() must be awaited first!");
934 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_err(owner);
935 return nativeResponseValue;
937 // struct LDKRoute CResult_RouteDecodeErrorZ_get_ok(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
939 export function CResult_RouteDecodeErrorZ_get_ok(owner: number): number {
940 if(!isWasmInitialized) {
941 throw new Error("initializeWasm() must be awaited first!");
943 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_ok(owner);
944 return nativeResponseValue;
946 // struct LDKDecodeError CResult_RouteDecodeErrorZ_get_err(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
948 export function CResult_RouteDecodeErrorZ_get_err(owner: number): number {
949 if(!isWasmInitialized) {
950 throw new Error("initializeWasm() must be awaited first!");
952 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_err(owner);
953 return nativeResponseValue;
955 // struct LDKRouteParameters CResult_RouteParametersDecodeErrorZ_get_ok(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
957 export function CResult_RouteParametersDecodeErrorZ_get_ok(owner: number): number {
958 if(!isWasmInitialized) {
959 throw new Error("initializeWasm() must be awaited first!");
961 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_ok(owner);
962 return nativeResponseValue;
964 // struct LDKDecodeError CResult_RouteParametersDecodeErrorZ_get_err(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
966 export function CResult_RouteParametersDecodeErrorZ_get_err(owner: number): number {
967 if(!isWasmInitialized) {
968 throw new Error("initializeWasm() must be awaited first!");
970 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_err(owner);
971 return nativeResponseValue;
974 export class LDKCOption_u64Z {
975 protected constructor() {}
978 export function LDKCOption_u64Z_ty_from_ptr(ptr: number): number {
979 if(!isWasmInitialized) {
980 throw new Error("initializeWasm() must be awaited first!");
982 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_ty_from_ptr(ptr);
983 return nativeResponseValue;
986 export function LDKCOption_u64Z_Some_get_some(ptr: number): bigint {
987 if(!isWasmInitialized) {
988 throw new Error("initializeWasm() must be awaited first!");
990 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_Some_get_some(ptr);
991 return nativeResponseValue;
993 // struct LDKPaymentParameters CResult_PaymentParametersDecodeErrorZ_get_ok(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
995 export function CResult_PaymentParametersDecodeErrorZ_get_ok(owner: number): number {
996 if(!isWasmInitialized) {
997 throw new Error("initializeWasm() must be awaited first!");
999 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_ok(owner);
1000 return nativeResponseValue;
1002 // struct LDKDecodeError CResult_PaymentParametersDecodeErrorZ_get_err(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
1004 export function CResult_PaymentParametersDecodeErrorZ_get_err(owner: number): number {
1005 if(!isWasmInitialized) {
1006 throw new Error("initializeWasm() must be awaited first!");
1008 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_err(owner);
1009 return nativeResponseValue;
1011 // struct LDKRouteHint CResult_RouteHintDecodeErrorZ_get_ok(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
1013 export function CResult_RouteHintDecodeErrorZ_get_ok(owner: number): number {
1014 if(!isWasmInitialized) {
1015 throw new Error("initializeWasm() must be awaited first!");
1017 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_ok(owner);
1018 return nativeResponseValue;
1020 // struct LDKDecodeError CResult_RouteHintDecodeErrorZ_get_err(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
1022 export function CResult_RouteHintDecodeErrorZ_get_err(owner: number): number {
1023 if(!isWasmInitialized) {
1024 throw new Error("initializeWasm() must be awaited first!");
1026 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_err(owner);
1027 return nativeResponseValue;
1029 // struct LDKRouteHintHop CResult_RouteHintHopDecodeErrorZ_get_ok(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
1031 export function CResult_RouteHintHopDecodeErrorZ_get_ok(owner: number): number {
1032 if(!isWasmInitialized) {
1033 throw new Error("initializeWasm() must be awaited first!");
1035 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_ok(owner);
1036 return nativeResponseValue;
1038 // struct LDKDecodeError CResult_RouteHintHopDecodeErrorZ_get_err(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
1040 export function CResult_RouteHintHopDecodeErrorZ_get_err(owner: number): number {
1041 if(!isWasmInitialized) {
1042 throw new Error("initializeWasm() must be awaited first!");
1044 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_err(owner);
1045 return nativeResponseValue;
1047 // struct LDKRoute CResult_RouteLightningErrorZ_get_ok(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
1049 export function CResult_RouteLightningErrorZ_get_ok(owner: number): number {
1050 if(!isWasmInitialized) {
1051 throw new Error("initializeWasm() must be awaited first!");
1053 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_ok(owner);
1054 return nativeResponseValue;
1056 // struct LDKLightningError CResult_RouteLightningErrorZ_get_err(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
1058 export function CResult_RouteLightningErrorZ_get_err(owner: number): number {
1059 if(!isWasmInitialized) {
1060 throw new Error("initializeWasm() must be awaited first!");
1062 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_err(owner);
1063 return nativeResponseValue;
1065 // struct LDKTxOut CResult_TxOutAccessErrorZ_get_ok(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
1067 export function CResult_TxOutAccessErrorZ_get_ok(owner: number): number {
1068 if(!isWasmInitialized) {
1069 throw new Error("initializeWasm() must be awaited first!");
1071 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_ok(owner);
1072 return nativeResponseValue;
1074 // enum LDKAccessError CResult_TxOutAccessErrorZ_get_err(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
1076 export function CResult_TxOutAccessErrorZ_get_err(owner: number): AccessError {
1077 if(!isWasmInitialized) {
1078 throw new Error("initializeWasm() must be awaited first!");
1080 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_err(owner);
1081 return nativeResponseValue;
1083 // uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
1085 export function C2Tuple_usizeTransactionZ_get_a(owner: number): number {
1086 if(!isWasmInitialized) {
1087 throw new Error("initializeWasm() must be awaited first!");
1089 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_a(owner);
1090 return nativeResponseValue;
1092 // struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
1094 export function C2Tuple_usizeTransactionZ_get_b(owner: number): number {
1095 if(!isWasmInitialized) {
1096 throw new Error("initializeWasm() must be awaited first!");
1098 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_b(owner);
1099 return nativeResponseValue;
1101 // void CResult_NoneChannelMonitorUpdateErrZ_get_ok(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR owner);
1103 export function CResult_NoneChannelMonitorUpdateErrZ_get_ok(owner: number): void {
1104 if(!isWasmInitialized) {
1105 throw new Error("initializeWasm() must be awaited first!");
1107 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_get_ok(owner);
1108 // debug statements here
1110 // enum LDKChannelMonitorUpdateErr CResult_NoneChannelMonitorUpdateErrZ_get_err(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR owner);
1112 export function CResult_NoneChannelMonitorUpdateErrZ_get_err(owner: number): ChannelMonitorUpdateErr {
1113 if(!isWasmInitialized) {
1114 throw new Error("initializeWasm() must be awaited first!");
1116 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_get_err(owner);
1117 return nativeResponseValue;
1120 export class LDKMonitorEvent {
1121 protected constructor() {}
1124 export function LDKMonitorEvent_ty_from_ptr(ptr: number): number {
1125 if(!isWasmInitialized) {
1126 throw new Error("initializeWasm() must be awaited first!");
1128 const nativeResponseValue = wasm.TS_LDKMonitorEvent_ty_from_ptr(ptr);
1129 return nativeResponseValue;
1132 export function LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr: number): number {
1133 if(!isWasmInitialized) {
1134 throw new Error("initializeWasm() must be awaited first!");
1136 const nativeResponseValue = wasm.TS_LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr);
1137 return nativeResponseValue;
1140 export function LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr: number): number {
1141 if(!isWasmInitialized) {
1142 throw new Error("initializeWasm() must be awaited first!");
1144 const nativeResponseValue = wasm.TS_LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr);
1145 return nativeResponseValue;
1148 export function LDKMonitorEvent_UpdateCompleted_get_funding_txo(ptr: number): number {
1149 if(!isWasmInitialized) {
1150 throw new Error("initializeWasm() must be awaited first!");
1152 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateCompleted_get_funding_txo(ptr);
1153 return nativeResponseValue;
1156 export function LDKMonitorEvent_UpdateCompleted_get_monitor_update_id(ptr: number): bigint {
1157 if(!isWasmInitialized) {
1158 throw new Error("initializeWasm() must be awaited first!");
1160 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateCompleted_get_monitor_update_id(ptr);
1161 return nativeResponseValue;
1164 export function LDKMonitorEvent_UpdateFailed_get_update_failed(ptr: number): number {
1165 if(!isWasmInitialized) {
1166 throw new Error("initializeWasm() must be awaited first!");
1168 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateFailed_get_update_failed(ptr);
1169 return nativeResponseValue;
1172 export class LDKCOption_C2Tuple_usizeTransactionZZ {
1173 protected constructor() {}
1176 export function LDKCOption_C2Tuple_usizeTransactionZZ_ty_from_ptr(ptr: number): number {
1177 if(!isWasmInitialized) {
1178 throw new Error("initializeWasm() must be awaited first!");
1180 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_usizeTransactionZZ_ty_from_ptr(ptr);
1181 return nativeResponseValue;
1184 export function LDKCOption_C2Tuple_usizeTransactionZZ_Some_get_some(ptr: number): number {
1185 if(!isWasmInitialized) {
1186 throw new Error("initializeWasm() must be awaited first!");
1188 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_usizeTransactionZZ_Some_get_some(ptr);
1189 return nativeResponseValue;
1192 export class LDKClosureReason {
1193 protected constructor() {}
1196 export function LDKClosureReason_ty_from_ptr(ptr: number): number {
1197 if(!isWasmInitialized) {
1198 throw new Error("initializeWasm() must be awaited first!");
1200 const nativeResponseValue = wasm.TS_LDKClosureReason_ty_from_ptr(ptr);
1201 return nativeResponseValue;
1204 export function LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr: number): number {
1205 if(!isWasmInitialized) {
1206 throw new Error("initializeWasm() must be awaited first!");
1208 const nativeResponseValue = wasm.TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr);
1209 return nativeResponseValue;
1212 export function LDKClosureReason_ProcessingError_get_err(ptr: number): number {
1213 if(!isWasmInitialized) {
1214 throw new Error("initializeWasm() must be awaited first!");
1216 const nativeResponseValue = wasm.TS_LDKClosureReason_ProcessingError_get_err(ptr);
1217 return nativeResponseValue;
1220 export class LDKCOption_ClosureReasonZ {
1221 protected constructor() {}
1224 export function LDKCOption_ClosureReasonZ_ty_from_ptr(ptr: number): number {
1225 if(!isWasmInitialized) {
1226 throw new Error("initializeWasm() must be awaited first!");
1228 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_ty_from_ptr(ptr);
1229 return nativeResponseValue;
1232 export function LDKCOption_ClosureReasonZ_Some_get_some(ptr: number): number {
1233 if(!isWasmInitialized) {
1234 throw new Error("initializeWasm() must be awaited first!");
1236 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_Some_get_some(ptr);
1237 return nativeResponseValue;
1239 // struct LDKCOption_ClosureReasonZ CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
1241 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner: number): number {
1242 if(!isWasmInitialized) {
1243 throw new Error("initializeWasm() must be awaited first!");
1245 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner);
1246 return nativeResponseValue;
1248 // struct LDKDecodeError CResult_COption_ClosureReasonZDecodeErrorZ_get_err(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
1250 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner: number): number {
1251 if(!isWasmInitialized) {
1252 throw new Error("initializeWasm() must be awaited first!");
1254 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner);
1255 return nativeResponseValue;
1258 export class LDKNetworkUpdate {
1259 protected constructor() {}
1262 export function LDKNetworkUpdate_ty_from_ptr(ptr: number): number {
1263 if(!isWasmInitialized) {
1264 throw new Error("initializeWasm() must be awaited first!");
1266 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ty_from_ptr(ptr);
1267 return nativeResponseValue;
1270 export function LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr: number): number {
1271 if(!isWasmInitialized) {
1272 throw new Error("initializeWasm() must be awaited first!");
1274 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr);
1275 return nativeResponseValue;
1278 export function LDKNetworkUpdate_ChannelClosed_get_short_channel_id(ptr: number): bigint {
1279 if(!isWasmInitialized) {
1280 throw new Error("initializeWasm() must be awaited first!");
1282 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelClosed_get_short_channel_id(ptr);
1283 return nativeResponseValue;
1286 export function LDKNetworkUpdate_ChannelClosed_get_is_permanent(ptr: number): boolean {
1287 if(!isWasmInitialized) {
1288 throw new Error("initializeWasm() must be awaited first!");
1290 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelClosed_get_is_permanent(ptr);
1291 return nativeResponseValue;
1294 export function LDKNetworkUpdate_NodeFailure_get_node_id(ptr: number): number {
1295 if(!isWasmInitialized) {
1296 throw new Error("initializeWasm() must be awaited first!");
1298 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_node_id(ptr);
1299 return nativeResponseValue;
1302 export function LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr: number): boolean {
1303 if(!isWasmInitialized) {
1304 throw new Error("initializeWasm() must be awaited first!");
1306 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr);
1307 return nativeResponseValue;
1310 export class LDKCOption_NetworkUpdateZ {
1311 protected constructor() {}
1314 export function LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr: number): number {
1315 if(!isWasmInitialized) {
1316 throw new Error("initializeWasm() must be awaited first!");
1318 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr);
1319 return nativeResponseValue;
1322 export function LDKCOption_NetworkUpdateZ_Some_get_some(ptr: number): number {
1323 if(!isWasmInitialized) {
1324 throw new Error("initializeWasm() must be awaited first!");
1326 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_Some_get_some(ptr);
1327 return nativeResponseValue;
1330 export class LDKSpendableOutputDescriptor {
1331 protected constructor() {}
1334 export function LDKSpendableOutputDescriptor_ty_from_ptr(ptr: number): number {
1335 if(!isWasmInitialized) {
1336 throw new Error("initializeWasm() must be awaited first!");
1338 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_ty_from_ptr(ptr);
1339 return nativeResponseValue;
1342 export function LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr: number): number {
1343 if(!isWasmInitialized) {
1344 throw new Error("initializeWasm() must be awaited first!");
1346 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr);
1347 return nativeResponseValue;
1350 export function LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr: number): number {
1351 if(!isWasmInitialized) {
1352 throw new Error("initializeWasm() must be awaited first!");
1354 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr);
1355 return nativeResponseValue;
1358 export function LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr: number): number {
1359 if(!isWasmInitialized) {
1360 throw new Error("initializeWasm() must be awaited first!");
1362 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr);
1363 return nativeResponseValue;
1366 export function LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr: number): number {
1367 if(!isWasmInitialized) {
1368 throw new Error("initializeWasm() must be awaited first!");
1370 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr);
1371 return nativeResponseValue;
1374 export class LDKPaymentPurpose {
1375 protected constructor() {}
1378 export function LDKPaymentPurpose_ty_from_ptr(ptr: number): number {
1379 if(!isWasmInitialized) {
1380 throw new Error("initializeWasm() must be awaited first!");
1382 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_ty_from_ptr(ptr);
1383 return nativeResponseValue;
1386 export function LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr: number): number {
1387 if(!isWasmInitialized) {
1388 throw new Error("initializeWasm() must be awaited first!");
1390 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr);
1391 return nativeResponseValue;
1394 export function LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr: number): number {
1395 if(!isWasmInitialized) {
1396 throw new Error("initializeWasm() must be awaited first!");
1398 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr);
1399 return nativeResponseValue;
1402 export function LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr: number): number {
1403 if(!isWasmInitialized) {
1404 throw new Error("initializeWasm() must be awaited first!");
1406 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr);
1407 return nativeResponseValue;
1410 export class LDKEvent {
1411 protected constructor() {}
1414 export function LDKEvent_ty_from_ptr(ptr: number): number {
1415 if(!isWasmInitialized) {
1416 throw new Error("initializeWasm() must be awaited first!");
1418 const nativeResponseValue = wasm.TS_LDKEvent_ty_from_ptr(ptr);
1419 return nativeResponseValue;
1422 export function LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr: number): number {
1423 if(!isWasmInitialized) {
1424 throw new Error("initializeWasm() must be awaited first!");
1426 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr);
1427 return nativeResponseValue;
1430 export function LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr: number): bigint {
1431 if(!isWasmInitialized) {
1432 throw new Error("initializeWasm() must be awaited first!");
1434 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr);
1435 return nativeResponseValue;
1438 export function LDKEvent_FundingGenerationReady_get_output_script(ptr: number): number {
1439 if(!isWasmInitialized) {
1440 throw new Error("initializeWasm() must be awaited first!");
1442 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_output_script(ptr);
1443 return nativeResponseValue;
1446 export function LDKEvent_FundingGenerationReady_get_user_channel_id(ptr: number): bigint {
1447 if(!isWasmInitialized) {
1448 throw new Error("initializeWasm() must be awaited first!");
1450 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_user_channel_id(ptr);
1451 return nativeResponseValue;
1454 export function LDKEvent_PaymentReceived_get_payment_hash(ptr: number): number {
1455 if(!isWasmInitialized) {
1456 throw new Error("initializeWasm() must be awaited first!");
1458 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_payment_hash(ptr);
1459 return nativeResponseValue;
1462 export function LDKEvent_PaymentReceived_get_amt(ptr: number): bigint {
1463 if(!isWasmInitialized) {
1464 throw new Error("initializeWasm() must be awaited first!");
1466 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_amt(ptr);
1467 return nativeResponseValue;
1470 export function LDKEvent_PaymentReceived_get_purpose(ptr: number): number {
1471 if(!isWasmInitialized) {
1472 throw new Error("initializeWasm() must be awaited first!");
1474 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_purpose(ptr);
1475 return nativeResponseValue;
1478 export function LDKEvent_PaymentSent_get_payment_id(ptr: number): number {
1479 if(!isWasmInitialized) {
1480 throw new Error("initializeWasm() must be awaited first!");
1482 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_id(ptr);
1483 return nativeResponseValue;
1486 export function LDKEvent_PaymentSent_get_payment_preimage(ptr: number): number {
1487 if(!isWasmInitialized) {
1488 throw new Error("initializeWasm() must be awaited first!");
1490 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_preimage(ptr);
1491 return nativeResponseValue;
1494 export function LDKEvent_PaymentSent_get_payment_hash(ptr: number): number {
1495 if(!isWasmInitialized) {
1496 throw new Error("initializeWasm() must be awaited first!");
1498 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_hash(ptr);
1499 return nativeResponseValue;
1502 export function LDKEvent_PaymentSent_get_fee_paid_msat(ptr: number): number {
1503 if(!isWasmInitialized) {
1504 throw new Error("initializeWasm() must be awaited first!");
1506 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_fee_paid_msat(ptr);
1507 return nativeResponseValue;
1510 export function LDKEvent_PaymentPathFailed_get_payment_id(ptr: number): number {
1511 if(!isWasmInitialized) {
1512 throw new Error("initializeWasm() must be awaited first!");
1514 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_id(ptr);
1515 return nativeResponseValue;
1518 export function LDKEvent_PaymentPathFailed_get_payment_hash(ptr: number): number {
1519 if(!isWasmInitialized) {
1520 throw new Error("initializeWasm() must be awaited first!");
1522 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_hash(ptr);
1523 return nativeResponseValue;
1526 export function LDKEvent_PaymentPathFailed_get_rejected_by_dest(ptr: number): boolean {
1527 if(!isWasmInitialized) {
1528 throw new Error("initializeWasm() must be awaited first!");
1530 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_rejected_by_dest(ptr);
1531 return nativeResponseValue;
1534 export function LDKEvent_PaymentPathFailed_get_network_update(ptr: number): number {
1535 if(!isWasmInitialized) {
1536 throw new Error("initializeWasm() must be awaited first!");
1538 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_network_update(ptr);
1539 return nativeResponseValue;
1542 export function LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr: number): boolean {
1543 if(!isWasmInitialized) {
1544 throw new Error("initializeWasm() must be awaited first!");
1546 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr);
1547 return nativeResponseValue;
1550 export function LDKEvent_PaymentPathFailed_get_path(ptr: number): number {
1551 if(!isWasmInitialized) {
1552 throw new Error("initializeWasm() must be awaited first!");
1554 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_path(ptr);
1555 return nativeResponseValue;
1558 export function LDKEvent_PaymentPathFailed_get_short_channel_id(ptr: number): number {
1559 if(!isWasmInitialized) {
1560 throw new Error("initializeWasm() must be awaited first!");
1562 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_short_channel_id(ptr);
1563 return nativeResponseValue;
1566 export function LDKEvent_PaymentPathFailed_get_retry(ptr: number): number {
1567 if(!isWasmInitialized) {
1568 throw new Error("initializeWasm() must be awaited first!");
1570 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_retry(ptr);
1571 return nativeResponseValue;
1574 export function LDKEvent_PaymentFailed_get_payment_id(ptr: number): number {
1575 if(!isWasmInitialized) {
1576 throw new Error("initializeWasm() must be awaited first!");
1578 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_id(ptr);
1579 return nativeResponseValue;
1582 export function LDKEvent_PaymentFailed_get_payment_hash(ptr: number): number {
1583 if(!isWasmInitialized) {
1584 throw new Error("initializeWasm() must be awaited first!");
1586 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_hash(ptr);
1587 return nativeResponseValue;
1590 export function LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr: number): bigint {
1591 if(!isWasmInitialized) {
1592 throw new Error("initializeWasm() must be awaited first!");
1594 const nativeResponseValue = wasm.TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr);
1595 return nativeResponseValue;
1598 export function LDKEvent_SpendableOutputs_get_outputs(ptr: number): number {
1599 if(!isWasmInitialized) {
1600 throw new Error("initializeWasm() must be awaited first!");
1602 const nativeResponseValue = wasm.TS_LDKEvent_SpendableOutputs_get_outputs(ptr);
1603 return nativeResponseValue;
1606 export function LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr: number): number {
1607 if(!isWasmInitialized) {
1608 throw new Error("initializeWasm() must be awaited first!");
1610 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr);
1611 return nativeResponseValue;
1614 export function LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr: number): boolean {
1615 if(!isWasmInitialized) {
1616 throw new Error("initializeWasm() must be awaited first!");
1618 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr);
1619 return nativeResponseValue;
1622 export function LDKEvent_ChannelClosed_get_channel_id(ptr: number): number {
1623 if(!isWasmInitialized) {
1624 throw new Error("initializeWasm() must be awaited first!");
1626 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_channel_id(ptr);
1627 return nativeResponseValue;
1630 export function LDKEvent_ChannelClosed_get_user_channel_id(ptr: number): bigint {
1631 if(!isWasmInitialized) {
1632 throw new Error("initializeWasm() must be awaited first!");
1634 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_user_channel_id(ptr);
1635 return nativeResponseValue;
1638 export function LDKEvent_ChannelClosed_get_reason(ptr: number): number {
1639 if(!isWasmInitialized) {
1640 throw new Error("initializeWasm() must be awaited first!");
1642 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_reason(ptr);
1643 return nativeResponseValue;
1646 export function LDKEvent_DiscardFunding_get_channel_id(ptr: number): number {
1647 if(!isWasmInitialized) {
1648 throw new Error("initializeWasm() must be awaited first!");
1650 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_channel_id(ptr);
1651 return nativeResponseValue;
1654 export function LDKEvent_DiscardFunding_get_transaction(ptr: number): number {
1655 if(!isWasmInitialized) {
1656 throw new Error("initializeWasm() must be awaited first!");
1658 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_transaction(ptr);
1659 return nativeResponseValue;
1662 export function LDKEvent_PaymentPathSuccessful_get_payment_id(ptr: number): number {
1663 if(!isWasmInitialized) {
1664 throw new Error("initializeWasm() must be awaited first!");
1666 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_id(ptr);
1667 return nativeResponseValue;
1670 export function LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr: number): number {
1671 if(!isWasmInitialized) {
1672 throw new Error("initializeWasm() must be awaited first!");
1674 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr);
1675 return nativeResponseValue;
1678 export function LDKEvent_PaymentPathSuccessful_get_path(ptr: number): number {
1679 if(!isWasmInitialized) {
1680 throw new Error("initializeWasm() must be awaited first!");
1682 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_path(ptr);
1683 return nativeResponseValue;
1686 export function LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr: number): number {
1687 if(!isWasmInitialized) {
1688 throw new Error("initializeWasm() must be awaited first!");
1690 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr);
1691 return nativeResponseValue;
1694 export function LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr: number): number {
1695 if(!isWasmInitialized) {
1696 throw new Error("initializeWasm() must be awaited first!");
1698 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr);
1699 return nativeResponseValue;
1702 export function LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr: number): bigint {
1703 if(!isWasmInitialized) {
1704 throw new Error("initializeWasm() must be awaited first!");
1706 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr);
1707 return nativeResponseValue;
1710 export function LDKEvent_OpenChannelRequest_get_push_msat(ptr: number): bigint {
1711 if(!isWasmInitialized) {
1712 throw new Error("initializeWasm() must be awaited first!");
1714 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_push_msat(ptr);
1715 return nativeResponseValue;
1718 export class LDKCOption_EventZ {
1719 protected constructor() {}
1722 export function LDKCOption_EventZ_ty_from_ptr(ptr: number): number {
1723 if(!isWasmInitialized) {
1724 throw new Error("initializeWasm() must be awaited first!");
1726 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_ty_from_ptr(ptr);
1727 return nativeResponseValue;
1730 export function LDKCOption_EventZ_Some_get_some(ptr: number): number {
1731 if(!isWasmInitialized) {
1732 throw new Error("initializeWasm() must be awaited first!");
1734 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_Some_get_some(ptr);
1735 return nativeResponseValue;
1737 // struct LDKCOption_EventZ CResult_COption_EventZDecodeErrorZ_get_ok(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
1739 export function CResult_COption_EventZDecodeErrorZ_get_ok(owner: number): number {
1740 if(!isWasmInitialized) {
1741 throw new Error("initializeWasm() must be awaited first!");
1743 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_ok(owner);
1744 return nativeResponseValue;
1746 // struct LDKDecodeError CResult_COption_EventZDecodeErrorZ_get_err(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
1748 export function CResult_COption_EventZDecodeErrorZ_get_err(owner: number): number {
1749 if(!isWasmInitialized) {
1750 throw new Error("initializeWasm() must be awaited first!");
1752 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_err(owner);
1753 return nativeResponseValue;
1756 export class LDKErrorAction {
1757 protected constructor() {}
1760 export function LDKErrorAction_ty_from_ptr(ptr: number): number {
1761 if(!isWasmInitialized) {
1762 throw new Error("initializeWasm() must be awaited first!");
1764 const nativeResponseValue = wasm.TS_LDKErrorAction_ty_from_ptr(ptr);
1765 return nativeResponseValue;
1768 export function LDKErrorAction_DisconnectPeer_get_msg(ptr: number): number {
1769 if(!isWasmInitialized) {
1770 throw new Error("initializeWasm() must be awaited first!");
1772 const nativeResponseValue = wasm.TS_LDKErrorAction_DisconnectPeer_get_msg(ptr);
1773 return nativeResponseValue;
1776 export function LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr: number): Level {
1777 if(!isWasmInitialized) {
1778 throw new Error("initializeWasm() must be awaited first!");
1780 const nativeResponseValue = wasm.TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr);
1781 return nativeResponseValue;
1784 export function LDKErrorAction_SendErrorMessage_get_msg(ptr: number): number {
1785 if(!isWasmInitialized) {
1786 throw new Error("initializeWasm() must be awaited first!");
1788 const nativeResponseValue = wasm.TS_LDKErrorAction_SendErrorMessage_get_msg(ptr);
1789 return nativeResponseValue;
1792 export function LDKErrorAction_SendWarningMessage_get_msg(ptr: number): number {
1793 if(!isWasmInitialized) {
1794 throw new Error("initializeWasm() must be awaited first!");
1796 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_msg(ptr);
1797 return nativeResponseValue;
1800 export function LDKErrorAction_SendWarningMessage_get_log_level(ptr: number): Level {
1801 if(!isWasmInitialized) {
1802 throw new Error("initializeWasm() must be awaited first!");
1804 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_log_level(ptr);
1805 return nativeResponseValue;
1808 export class LDKMessageSendEvent {
1809 protected constructor() {}
1812 export function LDKMessageSendEvent_ty_from_ptr(ptr: number): number {
1813 if(!isWasmInitialized) {
1814 throw new Error("initializeWasm() must be awaited first!");
1816 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_ty_from_ptr(ptr);
1817 return nativeResponseValue;
1820 export function LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr: number): number {
1821 if(!isWasmInitialized) {
1822 throw new Error("initializeWasm() must be awaited first!");
1824 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr);
1825 return nativeResponseValue;
1828 export function LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr: number): number {
1829 if(!isWasmInitialized) {
1830 throw new Error("initializeWasm() must be awaited first!");
1832 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr);
1833 return nativeResponseValue;
1836 export function LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr: number): number {
1837 if(!isWasmInitialized) {
1838 throw new Error("initializeWasm() must be awaited first!");
1840 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr);
1841 return nativeResponseValue;
1844 export function LDKMessageSendEvent_SendOpenChannel_get_msg(ptr: number): number {
1845 if(!isWasmInitialized) {
1846 throw new Error("initializeWasm() must be awaited first!");
1848 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_msg(ptr);
1849 return nativeResponseValue;
1852 export function LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr: number): number {
1853 if(!isWasmInitialized) {
1854 throw new Error("initializeWasm() must be awaited first!");
1856 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr);
1857 return nativeResponseValue;
1860 export function LDKMessageSendEvent_SendFundingCreated_get_msg(ptr: number): number {
1861 if(!isWasmInitialized) {
1862 throw new Error("initializeWasm() must be awaited first!");
1864 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_msg(ptr);
1865 return nativeResponseValue;
1868 export function LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr: number): number {
1869 if(!isWasmInitialized) {
1870 throw new Error("initializeWasm() must be awaited first!");
1872 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr);
1873 return nativeResponseValue;
1876 export function LDKMessageSendEvent_SendFundingSigned_get_msg(ptr: number): number {
1877 if(!isWasmInitialized) {
1878 throw new Error("initializeWasm() must be awaited first!");
1880 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_msg(ptr);
1881 return nativeResponseValue;
1884 export function LDKMessageSendEvent_SendFundingLocked_get_node_id(ptr: number): number {
1885 if(!isWasmInitialized) {
1886 throw new Error("initializeWasm() must be awaited first!");
1888 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingLocked_get_node_id(ptr);
1889 return nativeResponseValue;
1892 export function LDKMessageSendEvent_SendFundingLocked_get_msg(ptr: number): number {
1893 if(!isWasmInitialized) {
1894 throw new Error("initializeWasm() must be awaited first!");
1896 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingLocked_get_msg(ptr);
1897 return nativeResponseValue;
1900 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr: number): number {
1901 if(!isWasmInitialized) {
1902 throw new Error("initializeWasm() must be awaited first!");
1904 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr);
1905 return nativeResponseValue;
1908 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr: number): number {
1909 if(!isWasmInitialized) {
1910 throw new Error("initializeWasm() must be awaited first!");
1912 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr);
1913 return nativeResponseValue;
1916 export function LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr: number): number {
1917 if(!isWasmInitialized) {
1918 throw new Error("initializeWasm() must be awaited first!");
1920 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr);
1921 return nativeResponseValue;
1924 export function LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr: number): number {
1925 if(!isWasmInitialized) {
1926 throw new Error("initializeWasm() must be awaited first!");
1928 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr);
1929 return nativeResponseValue;
1932 export function LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr: number): number {
1933 if(!isWasmInitialized) {
1934 throw new Error("initializeWasm() must be awaited first!");
1936 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr);
1937 return nativeResponseValue;
1940 export function LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr: number): number {
1941 if(!isWasmInitialized) {
1942 throw new Error("initializeWasm() must be awaited first!");
1944 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr);
1945 return nativeResponseValue;
1948 export function LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr: number): number {
1949 if(!isWasmInitialized) {
1950 throw new Error("initializeWasm() must be awaited first!");
1952 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr);
1953 return nativeResponseValue;
1956 export function LDKMessageSendEvent_SendClosingSigned_get_msg(ptr: number): number {
1957 if(!isWasmInitialized) {
1958 throw new Error("initializeWasm() must be awaited first!");
1960 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_msg(ptr);
1961 return nativeResponseValue;
1964 export function LDKMessageSendEvent_SendShutdown_get_node_id(ptr: number): number {
1965 if(!isWasmInitialized) {
1966 throw new Error("initializeWasm() must be awaited first!");
1968 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_node_id(ptr);
1969 return nativeResponseValue;
1972 export function LDKMessageSendEvent_SendShutdown_get_msg(ptr: number): number {
1973 if(!isWasmInitialized) {
1974 throw new Error("initializeWasm() must be awaited first!");
1976 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_msg(ptr);
1977 return nativeResponseValue;
1980 export function LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr: number): number {
1981 if(!isWasmInitialized) {
1982 throw new Error("initializeWasm() must be awaited first!");
1984 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr);
1985 return nativeResponseValue;
1988 export function LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr: number): number {
1989 if(!isWasmInitialized) {
1990 throw new Error("initializeWasm() must be awaited first!");
1992 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr);
1993 return nativeResponseValue;
1996 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr: number): number {
1997 if(!isWasmInitialized) {
1998 throw new Error("initializeWasm() must be awaited first!");
2000 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr);
2001 return nativeResponseValue;
2004 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr: number): number {
2005 if(!isWasmInitialized) {
2006 throw new Error("initializeWasm() must be awaited first!");
2008 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr);
2009 return nativeResponseValue;
2012 export function LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr: number): number {
2013 if(!isWasmInitialized) {
2014 throw new Error("initializeWasm() must be awaited first!");
2016 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr);
2017 return nativeResponseValue;
2020 export function LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr: number): number {
2021 if(!isWasmInitialized) {
2022 throw new Error("initializeWasm() must be awaited first!");
2024 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr);
2025 return nativeResponseValue;
2028 export function LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr: number): number {
2029 if(!isWasmInitialized) {
2030 throw new Error("initializeWasm() must be awaited first!");
2032 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr);
2033 return nativeResponseValue;
2036 export function LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr: number): number {
2037 if(!isWasmInitialized) {
2038 throw new Error("initializeWasm() must be awaited first!");
2040 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr);
2041 return nativeResponseValue;
2044 export function LDKMessageSendEvent_HandleError_get_node_id(ptr: number): number {
2045 if(!isWasmInitialized) {
2046 throw new Error("initializeWasm() must be awaited first!");
2048 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_node_id(ptr);
2049 return nativeResponseValue;
2052 export function LDKMessageSendEvent_HandleError_get_action(ptr: number): number {
2053 if(!isWasmInitialized) {
2054 throw new Error("initializeWasm() must be awaited first!");
2056 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_action(ptr);
2057 return nativeResponseValue;
2060 export function LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr: number): number {
2061 if(!isWasmInitialized) {
2062 throw new Error("initializeWasm() must be awaited first!");
2064 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr);
2065 return nativeResponseValue;
2068 export function LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr: number): number {
2069 if(!isWasmInitialized) {
2070 throw new Error("initializeWasm() must be awaited first!");
2072 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr);
2073 return nativeResponseValue;
2076 export function LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr: number): number {
2077 if(!isWasmInitialized) {
2078 throw new Error("initializeWasm() must be awaited first!");
2080 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr);
2081 return nativeResponseValue;
2084 export function LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr: number): number {
2085 if(!isWasmInitialized) {
2086 throw new Error("initializeWasm() must be awaited first!");
2088 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr);
2089 return nativeResponseValue;
2092 export function LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr: number): number {
2093 if(!isWasmInitialized) {
2094 throw new Error("initializeWasm() must be awaited first!");
2096 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr);
2097 return nativeResponseValue;
2100 export function LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr: number): number {
2101 if(!isWasmInitialized) {
2102 throw new Error("initializeWasm() must be awaited first!");
2104 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr);
2105 return nativeResponseValue;
2107 // struct LDKFixedPenaltyScorer CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2109 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner: number): number {
2110 if(!isWasmInitialized) {
2111 throw new Error("initializeWasm() must be awaited first!");
2113 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner);
2114 return nativeResponseValue;
2116 // struct LDKDecodeError CResult_FixedPenaltyScorerDecodeErrorZ_get_err(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2118 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner: number): number {
2119 if(!isWasmInitialized) {
2120 throw new Error("initializeWasm() must be awaited first!");
2122 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner);
2123 return nativeResponseValue;
2125 // struct LDKScoringParameters CResult_ScoringParametersDecodeErrorZ_get_ok(LDKCResult_ScoringParametersDecodeErrorZ *NONNULL_PTR owner);
2127 export function CResult_ScoringParametersDecodeErrorZ_get_ok(owner: number): number {
2128 if(!isWasmInitialized) {
2129 throw new Error("initializeWasm() must be awaited first!");
2131 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_get_ok(owner);
2132 return nativeResponseValue;
2134 // struct LDKDecodeError CResult_ScoringParametersDecodeErrorZ_get_err(LDKCResult_ScoringParametersDecodeErrorZ *NONNULL_PTR owner);
2136 export function CResult_ScoringParametersDecodeErrorZ_get_err(owner: number): number {
2137 if(!isWasmInitialized) {
2138 throw new Error("initializeWasm() must be awaited first!");
2140 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_get_err(owner);
2141 return nativeResponseValue;
2143 // struct LDKScorer *CResult_ScorerDecodeErrorZ_get_ok(LDKCResult_ScorerDecodeErrorZ *NONNULL_PTR owner);
2145 export function CResult_ScorerDecodeErrorZ_get_ok(owner: number): number {
2146 if(!isWasmInitialized) {
2147 throw new Error("initializeWasm() must be awaited first!");
2149 const nativeResponseValue = wasm.TS_CResult_ScorerDecodeErrorZ_get_ok(owner);
2150 return nativeResponseValue;
2152 // struct LDKDecodeError CResult_ScorerDecodeErrorZ_get_err(LDKCResult_ScorerDecodeErrorZ *NONNULL_PTR owner);
2154 export function CResult_ScorerDecodeErrorZ_get_err(owner: number): number {
2155 if(!isWasmInitialized) {
2156 throw new Error("initializeWasm() must be awaited first!");
2158 const nativeResponseValue = wasm.TS_CResult_ScorerDecodeErrorZ_get_err(owner);
2159 return nativeResponseValue;
2161 // struct LDKProbabilisticScoringParameters CResult_ProbabilisticScoringParametersDecodeErrorZ_get_ok(LDKCResult_ProbabilisticScoringParametersDecodeErrorZ *NONNULL_PTR owner);
2163 export function CResult_ProbabilisticScoringParametersDecodeErrorZ_get_ok(owner: number): number {
2164 if(!isWasmInitialized) {
2165 throw new Error("initializeWasm() must be awaited first!");
2167 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScoringParametersDecodeErrorZ_get_ok(owner);
2168 return nativeResponseValue;
2170 // struct LDKDecodeError CResult_ProbabilisticScoringParametersDecodeErrorZ_get_err(LDKCResult_ProbabilisticScoringParametersDecodeErrorZ *NONNULL_PTR owner);
2172 export function CResult_ProbabilisticScoringParametersDecodeErrorZ_get_err(owner: number): number {
2173 if(!isWasmInitialized) {
2174 throw new Error("initializeWasm() must be awaited first!");
2176 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScoringParametersDecodeErrorZ_get_err(owner);
2177 return nativeResponseValue;
2179 // struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2181 export function CResult_InitFeaturesDecodeErrorZ_get_ok(owner: number): number {
2182 if(!isWasmInitialized) {
2183 throw new Error("initializeWasm() must be awaited first!");
2185 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_ok(owner);
2186 return nativeResponseValue;
2188 // struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2190 export function CResult_InitFeaturesDecodeErrorZ_get_err(owner: number): number {
2191 if(!isWasmInitialized) {
2192 throw new Error("initializeWasm() must be awaited first!");
2194 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_err(owner);
2195 return nativeResponseValue;
2197 // struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2199 export function CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner: number): number {
2200 if(!isWasmInitialized) {
2201 throw new Error("initializeWasm() must be awaited first!");
2203 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner);
2204 return nativeResponseValue;
2206 // struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2208 export function CResult_ChannelFeaturesDecodeErrorZ_get_err(owner: number): number {
2209 if(!isWasmInitialized) {
2210 throw new Error("initializeWasm() must be awaited first!");
2212 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(owner);
2213 return nativeResponseValue;
2215 // struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2217 export function CResult_NodeFeaturesDecodeErrorZ_get_ok(owner: number): number {
2218 if(!isWasmInitialized) {
2219 throw new Error("initializeWasm() must be awaited first!");
2221 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(owner);
2222 return nativeResponseValue;
2224 // struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2226 export function CResult_NodeFeaturesDecodeErrorZ_get_err(owner: number): number {
2227 if(!isWasmInitialized) {
2228 throw new Error("initializeWasm() must be awaited first!");
2230 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_err(owner);
2231 return nativeResponseValue;
2233 // struct LDKInvoiceFeatures CResult_InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2235 export function CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner: number): number {
2236 if(!isWasmInitialized) {
2237 throw new Error("initializeWasm() must be awaited first!");
2239 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner);
2240 return nativeResponseValue;
2242 // struct LDKDecodeError CResult_InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2244 export function CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner: number): number {
2245 if(!isWasmInitialized) {
2246 throw new Error("initializeWasm() must be awaited first!");
2248 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner);
2249 return nativeResponseValue;
2251 // struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2253 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner: number): number {
2254 if(!isWasmInitialized) {
2255 throw new Error("initializeWasm() must be awaited first!");
2257 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner);
2258 return nativeResponseValue;
2260 // struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2262 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner: number): number {
2263 if(!isWasmInitialized) {
2264 throw new Error("initializeWasm() must be awaited first!");
2266 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner);
2267 return nativeResponseValue;
2269 // struct LDKDelayedPaymentOutputDescriptor CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2271 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
2272 if(!isWasmInitialized) {
2273 throw new Error("initializeWasm() must be awaited first!");
2275 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
2276 return nativeResponseValue;
2278 // struct LDKDecodeError CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2280 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
2281 if(!isWasmInitialized) {
2282 throw new Error("initializeWasm() must be awaited first!");
2284 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
2285 return nativeResponseValue;
2287 // struct LDKStaticPaymentOutputDescriptor CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2289 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
2290 if(!isWasmInitialized) {
2291 throw new Error("initializeWasm() must be awaited first!");
2293 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
2294 return nativeResponseValue;
2296 // struct LDKDecodeError CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2298 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
2299 if(!isWasmInitialized) {
2300 throw new Error("initializeWasm() must be awaited first!");
2302 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
2303 return nativeResponseValue;
2305 // struct LDKSpendableOutputDescriptor CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2307 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
2308 if(!isWasmInitialized) {
2309 throw new Error("initializeWasm() must be awaited first!");
2311 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner);
2312 return nativeResponseValue;
2314 // struct LDKDecodeError CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2316 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
2317 if(!isWasmInitialized) {
2318 throw new Error("initializeWasm() must be awaited first!");
2320 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner);
2321 return nativeResponseValue;
2323 // struct LDKSignature C2Tuple_SignatureCVec_SignatureZZ_get_a(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
2325 export function C2Tuple_SignatureCVec_SignatureZZ_get_a(owner: number): number {
2326 if(!isWasmInitialized) {
2327 throw new Error("initializeWasm() must be awaited first!");
2329 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_a(owner);
2330 return nativeResponseValue;
2332 // struct LDKCVec_SignatureZ C2Tuple_SignatureCVec_SignatureZZ_get_b(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
2334 export function C2Tuple_SignatureCVec_SignatureZZ_get_b(owner: number): number {
2335 if(!isWasmInitialized) {
2336 throw new Error("initializeWasm() must be awaited first!");
2338 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_b(owner);
2339 return nativeResponseValue;
2341 // struct LDKC2Tuple_SignatureCVec_SignatureZZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
2343 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner: number): number {
2344 if(!isWasmInitialized) {
2345 throw new Error("initializeWasm() must be awaited first!");
2347 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner);
2348 return nativeResponseValue;
2350 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
2352 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner: number): void {
2353 if(!isWasmInitialized) {
2354 throw new Error("initializeWasm() must be awaited first!");
2356 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner);
2357 // debug statements here
2359 // struct LDKSignature CResult_SignatureNoneZ_get_ok(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
2361 export function CResult_SignatureNoneZ_get_ok(owner: number): number {
2362 if(!isWasmInitialized) {
2363 throw new Error("initializeWasm() must be awaited first!");
2365 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_ok(owner);
2366 return nativeResponseValue;
2368 // void CResult_SignatureNoneZ_get_err(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
2370 export function CResult_SignatureNoneZ_get_err(owner: number): void {
2371 if(!isWasmInitialized) {
2372 throw new Error("initializeWasm() must be awaited first!");
2374 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_err(owner);
2375 // debug statements here
2377 // struct LDKSignature C2Tuple_SignatureSignatureZ_get_a(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner);
2379 export function C2Tuple_SignatureSignatureZ_get_a(owner: number): number {
2380 if(!isWasmInitialized) {
2381 throw new Error("initializeWasm() must be awaited first!");
2383 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_get_a(owner);
2384 return nativeResponseValue;
2386 // struct LDKSignature C2Tuple_SignatureSignatureZ_get_b(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner);
2388 export function C2Tuple_SignatureSignatureZ_get_b(owner: number): number {
2389 if(!isWasmInitialized) {
2390 throw new Error("initializeWasm() must be awaited first!");
2392 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_get_b(owner);
2393 return nativeResponseValue;
2395 // struct LDKC2Tuple_SignatureSignatureZ CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner);
2397 export function CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner: number): number {
2398 if(!isWasmInitialized) {
2399 throw new Error("initializeWasm() must be awaited first!");
2401 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner);
2402 return nativeResponseValue;
2404 // void CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner);
2406 export function CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner: number): void {
2407 if(!isWasmInitialized) {
2408 throw new Error("initializeWasm() must be awaited first!");
2410 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner);
2411 // debug statements here
2413 // struct LDKSecretKey CResult_SecretKeyNoneZ_get_ok(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner);
2415 export function CResult_SecretKeyNoneZ_get_ok(owner: number): number {
2416 if(!isWasmInitialized) {
2417 throw new Error("initializeWasm() must be awaited first!");
2419 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_get_ok(owner);
2420 return nativeResponseValue;
2422 // void CResult_SecretKeyNoneZ_get_err(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner);
2424 export function CResult_SecretKeyNoneZ_get_err(owner: number): void {
2425 if(!isWasmInitialized) {
2426 throw new Error("initializeWasm() must be awaited first!");
2428 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_get_err(owner);
2429 // debug statements here
2432 export interface LDKBaseSign {
2433 get_per_commitment_point (idx: bigint): number;
2434 release_commitment_secret (idx: bigint): number;
2435 validate_holder_commitment (holder_tx: number, preimages: number): number;
2436 channel_keys_id (): number;
2437 sign_counterparty_commitment (commitment_tx: number, preimages: number): number;
2438 validate_counterparty_revocation (idx: bigint, secret: number): number;
2439 sign_holder_commitment_and_htlcs (commitment_tx: number): number;
2440 sign_justice_revoked_output (justice_tx: number, input: number, amount: bigint, per_commitment_key: number): number;
2441 sign_justice_revoked_htlc (justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: number): number;
2442 sign_counterparty_htlc_transaction (htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: number): number;
2443 sign_closing_transaction (closing_tx: number): number;
2444 sign_channel_announcement (msg: number): number;
2445 ready_channel (channel_parameters: number): void;
2449 export function LDKBaseSign_new(impl: LDKBaseSign, pubkeys: number): number {
2450 if(!isWasmInitialized) {
2451 throw new Error("initializeWasm() must be awaited first!");
2453 var new_obj_idx = js_objs.length;
2454 for (var i = 0; i < js_objs.length; i++) {
2455 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2457 js_objs[i] = new WeakRef(impl);
2458 return wasm.TS_LDKBaseSign_new(i);
2460 // LDKPublicKey BaseSign_get_per_commitment_point LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
2462 export function BaseSign_get_per_commitment_point(this_arg: number, idx: bigint): number {
2463 if(!isWasmInitialized) {
2464 throw new Error("initializeWasm() must be awaited first!");
2466 const nativeResponseValue = wasm.TS_BaseSign_get_per_commitment_point(this_arg, idx);
2467 return nativeResponseValue;
2469 // LDKThirtyTwoBytes BaseSign_release_commitment_secret LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
2471 export function BaseSign_release_commitment_secret(this_arg: number, idx: bigint): number {
2472 if(!isWasmInitialized) {
2473 throw new Error("initializeWasm() must be awaited first!");
2475 const nativeResponseValue = wasm.TS_BaseSign_release_commitment_secret(this_arg, idx);
2476 return nativeResponseValue;
2478 // LDKCResult_NoneNoneZ BaseSign_validate_holder_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_PaymentPreimageZ preimages
2480 export function BaseSign_validate_holder_commitment(this_arg: number, holder_tx: number, preimages: number): number {
2481 if(!isWasmInitialized) {
2482 throw new Error("initializeWasm() must be awaited first!");
2484 const nativeResponseValue = wasm.TS_BaseSign_validate_holder_commitment(this_arg, holder_tx, preimages);
2485 return nativeResponseValue;
2487 // LDKThirtyTwoBytes BaseSign_channel_keys_id LDKBaseSign *NONNULL_PTR this_arg
2489 export function BaseSign_channel_keys_id(this_arg: number): number {
2490 if(!isWasmInitialized) {
2491 throw new Error("initializeWasm() must be awaited first!");
2493 const nativeResponseValue = wasm.TS_BaseSign_channel_keys_id(this_arg);
2494 return nativeResponseValue;
2496 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_counterparty_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_PaymentPreimageZ preimages
2498 export function BaseSign_sign_counterparty_commitment(this_arg: number, commitment_tx: number, preimages: number): number {
2499 if(!isWasmInitialized) {
2500 throw new Error("initializeWasm() must be awaited first!");
2502 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_commitment(this_arg, commitment_tx, preimages);
2503 return nativeResponseValue;
2505 // LDKCResult_NoneNoneZ BaseSign_validate_counterparty_revocation LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx, const uint8_t (*secret)[32]
2507 export function BaseSign_validate_counterparty_revocation(this_arg: number, idx: bigint, secret: number): number {
2508 if(!isWasmInitialized) {
2509 throw new Error("initializeWasm() must be awaited first!");
2511 const nativeResponseValue = wasm.TS_BaseSign_validate_counterparty_revocation(this_arg, idx, secret);
2512 return nativeResponseValue;
2514 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_holder_commitment_and_htlcs LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx
2516 export function BaseSign_sign_holder_commitment_and_htlcs(this_arg: number, commitment_tx: number): number {
2517 if(!isWasmInitialized) {
2518 throw new Error("initializeWasm() must be awaited first!");
2520 const nativeResponseValue = wasm.TS_BaseSign_sign_holder_commitment_and_htlcs(this_arg, commitment_tx);
2521 return nativeResponseValue;
2523 // 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]
2525 export function BaseSign_sign_justice_revoked_output(this_arg: number, justice_tx: number, input: number, amount: bigint, per_commitment_key: number): number {
2526 if(!isWasmInitialized) {
2527 throw new Error("initializeWasm() must be awaited first!");
2529 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_output(this_arg, justice_tx, input, amount, per_commitment_key);
2530 return nativeResponseValue;
2532 // 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
2534 export function BaseSign_sign_justice_revoked_htlc(this_arg: number, justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: number): number {
2535 if(!isWasmInitialized) {
2536 throw new Error("initializeWasm() must be awaited first!");
2538 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_htlc(this_arg, justice_tx, input, amount, per_commitment_key, htlc);
2539 return nativeResponseValue;
2541 // 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
2543 export function BaseSign_sign_counterparty_htlc_transaction(this_arg: number, htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: number): number {
2544 if(!isWasmInitialized) {
2545 throw new Error("initializeWasm() must be awaited first!");
2547 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_htlc_transaction(this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
2548 return nativeResponseValue;
2550 // LDKCResult_SignatureNoneZ BaseSign_sign_closing_transaction LDKBaseSign *NONNULL_PTR this_arg, const struct LDKClosingTransaction *NONNULL_PTR closing_tx
2552 export function BaseSign_sign_closing_transaction(this_arg: number, closing_tx: number): number {
2553 if(!isWasmInitialized) {
2554 throw new Error("initializeWasm() must be awaited first!");
2556 const nativeResponseValue = wasm.TS_BaseSign_sign_closing_transaction(this_arg, closing_tx);
2557 return nativeResponseValue;
2559 // LDKCResult_C2Tuple_SignatureSignatureZNoneZ BaseSign_sign_channel_announcement LDKBaseSign *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg
2561 export function BaseSign_sign_channel_announcement(this_arg: number, msg: number): number {
2562 if(!isWasmInitialized) {
2563 throw new Error("initializeWasm() must be awaited first!");
2565 const nativeResponseValue = wasm.TS_BaseSign_sign_channel_announcement(this_arg, msg);
2566 return nativeResponseValue;
2568 // void BaseSign_ready_channel LDKBaseSign *NONNULL_PTR this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters
2570 export function BaseSign_ready_channel(this_arg: number, channel_parameters: number): void {
2571 if(!isWasmInitialized) {
2572 throw new Error("initializeWasm() must be awaited first!");
2574 const nativeResponseValue = wasm.TS_BaseSign_ready_channel(this_arg, channel_parameters);
2575 // debug statements here
2577 // LDKChannelPublicKeys BaseSign_get_pubkeys LDKBaseSign *NONNULL_PTR this_arg
2579 export function BaseSign_get_pubkeys(this_arg: number): number {
2580 if(!isWasmInitialized) {
2581 throw new Error("initializeWasm() must be awaited first!");
2583 const nativeResponseValue = wasm.TS_BaseSign_get_pubkeys(this_arg);
2584 return nativeResponseValue;
2587 export interface LDKSign {
2592 export function LDKSign_new(impl: LDKSign, BaseSign: LDKBaseSign, pubkeys: number): number {
2593 if(!isWasmInitialized) {
2594 throw new Error("initializeWasm() must be awaited first!");
2596 var new_obj_idx = js_objs.length;
2597 for (var i = 0; i < js_objs.length; i++) {
2598 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2600 js_objs[i] = new WeakRef(impl);
2601 return wasm.TS_LDKSign_new(i);
2603 // LDKCVec_u8Z Sign_write LDKSign *NONNULL_PTR this_arg
2605 export function Sign_write(this_arg: number): number {
2606 if(!isWasmInitialized) {
2607 throw new Error("initializeWasm() must be awaited first!");
2609 const nativeResponseValue = wasm.TS_Sign_write(this_arg);
2610 return nativeResponseValue;
2612 // struct LDKSign CResult_SignDecodeErrorZ_get_ok(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
2614 export function CResult_SignDecodeErrorZ_get_ok(owner: number): number {
2615 if(!isWasmInitialized) {
2616 throw new Error("initializeWasm() must be awaited first!");
2618 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_ok(owner);
2619 return nativeResponseValue;
2621 // struct LDKDecodeError CResult_SignDecodeErrorZ_get_err(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
2623 export function CResult_SignDecodeErrorZ_get_err(owner: number): number {
2624 if(!isWasmInitialized) {
2625 throw new Error("initializeWasm() must be awaited first!");
2627 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_err(owner);
2628 return nativeResponseValue;
2630 // struct LDKRecoverableSignature CResult_RecoverableSignatureNoneZ_get_ok(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
2632 export function CResult_RecoverableSignatureNoneZ_get_ok(owner: number): number {
2633 if(!isWasmInitialized) {
2634 throw new Error("initializeWasm() must be awaited first!");
2636 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_ok(owner);
2637 return nativeResponseValue;
2639 // void CResult_RecoverableSignatureNoneZ_get_err(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
2641 export function CResult_RecoverableSignatureNoneZ_get_err(owner: number): void {
2642 if(!isWasmInitialized) {
2643 throw new Error("initializeWasm() must be awaited first!");
2645 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_err(owner);
2646 // debug statements here
2648 // struct LDKCVec_CVec_u8ZZ CResult_CVec_CVec_u8ZZNoneZ_get_ok(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
2650 export function CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner: number): number {
2651 if(!isWasmInitialized) {
2652 throw new Error("initializeWasm() must be awaited first!");
2654 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner);
2655 return nativeResponseValue;
2657 // void CResult_CVec_CVec_u8ZZNoneZ_get_err(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
2659 export function CResult_CVec_CVec_u8ZZNoneZ_get_err(owner: number): void {
2660 if(!isWasmInitialized) {
2661 throw new Error("initializeWasm() must be awaited first!");
2663 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_err(owner);
2664 // debug statements here
2666 // struct LDKInMemorySigner CResult_InMemorySignerDecodeErrorZ_get_ok(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
2668 export function CResult_InMemorySignerDecodeErrorZ_get_ok(owner: number): number {
2669 if(!isWasmInitialized) {
2670 throw new Error("initializeWasm() must be awaited first!");
2672 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_ok(owner);
2673 return nativeResponseValue;
2675 // struct LDKDecodeError CResult_InMemorySignerDecodeErrorZ_get_err(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
2677 export function CResult_InMemorySignerDecodeErrorZ_get_err(owner: number): number {
2678 if(!isWasmInitialized) {
2679 throw new Error("initializeWasm() must be awaited first!");
2681 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_err(owner);
2682 return nativeResponseValue;
2684 // struct LDKTransaction CResult_TransactionNoneZ_get_ok(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
2686 export function CResult_TransactionNoneZ_get_ok(owner: number): number {
2687 if(!isWasmInitialized) {
2688 throw new Error("initializeWasm() must be awaited first!");
2690 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_ok(owner);
2691 return nativeResponseValue;
2693 // void CResult_TransactionNoneZ_get_err(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
2695 export function CResult_TransactionNoneZ_get_err(owner: number): void {
2696 if(!isWasmInitialized) {
2697 throw new Error("initializeWasm() must be awaited first!");
2699 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_err(owner);
2700 // debug statements here
2703 export class LDKCOption_u16Z {
2704 protected constructor() {}
2707 export function LDKCOption_u16Z_ty_from_ptr(ptr: number): number {
2708 if(!isWasmInitialized) {
2709 throw new Error("initializeWasm() must be awaited first!");
2711 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_ty_from_ptr(ptr);
2712 return nativeResponseValue;
2715 export function LDKCOption_u16Z_Some_get_some(ptr: number): number {
2716 if(!isWasmInitialized) {
2717 throw new Error("initializeWasm() must be awaited first!");
2719 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_Some_get_some(ptr);
2720 return nativeResponseValue;
2723 export class LDKAPIError {
2724 protected constructor() {}
2727 export function LDKAPIError_ty_from_ptr(ptr: number): number {
2728 if(!isWasmInitialized) {
2729 throw new Error("initializeWasm() must be awaited first!");
2731 const nativeResponseValue = wasm.TS_LDKAPIError_ty_from_ptr(ptr);
2732 return nativeResponseValue;
2735 export function LDKAPIError_APIMisuseError_get_err(ptr: number): number {
2736 if(!isWasmInitialized) {
2737 throw new Error("initializeWasm() must be awaited first!");
2739 const nativeResponseValue = wasm.TS_LDKAPIError_APIMisuseError_get_err(ptr);
2740 return nativeResponseValue;
2743 export function LDKAPIError_FeeRateTooHigh_get_err(ptr: number): number {
2744 if(!isWasmInitialized) {
2745 throw new Error("initializeWasm() must be awaited first!");
2747 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_err(ptr);
2748 return nativeResponseValue;
2751 export function LDKAPIError_FeeRateTooHigh_get_feerate(ptr: number): number {
2752 if(!isWasmInitialized) {
2753 throw new Error("initializeWasm() must be awaited first!");
2755 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_feerate(ptr);
2756 return nativeResponseValue;
2759 export function LDKAPIError_RouteError_get_err(ptr: number): number {
2760 if(!isWasmInitialized) {
2761 throw new Error("initializeWasm() must be awaited first!");
2763 const nativeResponseValue = wasm.TS_LDKAPIError_RouteError_get_err(ptr);
2764 return nativeResponseValue;
2767 export function LDKAPIError_ChannelUnavailable_get_err(ptr: number): number {
2768 if(!isWasmInitialized) {
2769 throw new Error("initializeWasm() must be awaited first!");
2771 const nativeResponseValue = wasm.TS_LDKAPIError_ChannelUnavailable_get_err(ptr);
2772 return nativeResponseValue;
2775 export function LDKAPIError_IncompatibleShutdownScript_get_script(ptr: number): number {
2776 if(!isWasmInitialized) {
2777 throw new Error("initializeWasm() must be awaited first!");
2779 const nativeResponseValue = wasm.TS_LDKAPIError_IncompatibleShutdownScript_get_script(ptr);
2780 return nativeResponseValue;
2782 // void CResult_NoneAPIErrorZ_get_ok(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
2784 export function CResult_NoneAPIErrorZ_get_ok(owner: number): void {
2785 if(!isWasmInitialized) {
2786 throw new Error("initializeWasm() must be awaited first!");
2788 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_ok(owner);
2789 // debug statements here
2791 // struct LDKAPIError CResult_NoneAPIErrorZ_get_err(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
2793 export function CResult_NoneAPIErrorZ_get_err(owner: number): number {
2794 if(!isWasmInitialized) {
2795 throw new Error("initializeWasm() must be awaited first!");
2797 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_err(owner);
2798 return nativeResponseValue;
2800 // struct LDKThirtyTwoBytes CResult__u832APIErrorZ_get_ok(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
2802 export function CResult__u832APIErrorZ_get_ok(owner: number): number {
2803 if(!isWasmInitialized) {
2804 throw new Error("initializeWasm() must be awaited first!");
2806 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_ok(owner);
2807 return nativeResponseValue;
2809 // struct LDKAPIError CResult__u832APIErrorZ_get_err(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
2811 export function CResult__u832APIErrorZ_get_err(owner: number): number {
2812 if(!isWasmInitialized) {
2813 throw new Error("initializeWasm() must be awaited first!");
2815 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_err(owner);
2816 return nativeResponseValue;
2819 export class LDKPaymentSendFailure {
2820 protected constructor() {}
2823 export function LDKPaymentSendFailure_ty_from_ptr(ptr: number): number {
2824 if(!isWasmInitialized) {
2825 throw new Error("initializeWasm() must be awaited first!");
2827 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ty_from_ptr(ptr);
2828 return nativeResponseValue;
2831 export function LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr: number): number {
2832 if(!isWasmInitialized) {
2833 throw new Error("initializeWasm() must be awaited first!");
2835 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr);
2836 return nativeResponseValue;
2839 export function LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr: number): number {
2840 if(!isWasmInitialized) {
2841 throw new Error("initializeWasm() must be awaited first!");
2843 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr);
2844 return nativeResponseValue;
2847 export function LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr: number): number {
2848 if(!isWasmInitialized) {
2849 throw new Error("initializeWasm() must be awaited first!");
2851 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr);
2852 return nativeResponseValue;
2855 export function LDKPaymentSendFailure_PartialFailure_get_results(ptr: number): number {
2856 if(!isWasmInitialized) {
2857 throw new Error("initializeWasm() must be awaited first!");
2859 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_results(ptr);
2860 return nativeResponseValue;
2863 export function LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr: number): number {
2864 if(!isWasmInitialized) {
2865 throw new Error("initializeWasm() must be awaited first!");
2867 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr);
2868 return nativeResponseValue;
2871 export function LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr: number): number {
2872 if(!isWasmInitialized) {
2873 throw new Error("initializeWasm() must be awaited first!");
2875 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr);
2876 return nativeResponseValue;
2878 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentSendFailureZ_get_ok(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
2880 export function CResult_PaymentIdPaymentSendFailureZ_get_ok(owner: number): number {
2881 if(!isWasmInitialized) {
2882 throw new Error("initializeWasm() must be awaited first!");
2884 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_ok(owner);
2885 return nativeResponseValue;
2887 // struct LDKPaymentSendFailure CResult_PaymentIdPaymentSendFailureZ_get_err(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
2889 export function CResult_PaymentIdPaymentSendFailureZ_get_err(owner: number): number {
2890 if(!isWasmInitialized) {
2891 throw new Error("initializeWasm() must be awaited first!");
2893 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_err(owner);
2894 return nativeResponseValue;
2896 // void CResult_NonePaymentSendFailureZ_get_ok(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
2898 export function CResult_NonePaymentSendFailureZ_get_ok(owner: number): void {
2899 if(!isWasmInitialized) {
2900 throw new Error("initializeWasm() must be awaited first!");
2902 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_ok(owner);
2903 // debug statements here
2905 // struct LDKPaymentSendFailure CResult_NonePaymentSendFailureZ_get_err(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
2907 export function CResult_NonePaymentSendFailureZ_get_err(owner: number): number {
2908 if(!isWasmInitialized) {
2909 throw new Error("initializeWasm() must be awaited first!");
2911 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_err(owner);
2912 return nativeResponseValue;
2914 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_a(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
2916 export function C2Tuple_PaymentHashPaymentIdZ_get_a(owner: number): number {
2917 if(!isWasmInitialized) {
2918 throw new Error("initializeWasm() must be awaited first!");
2920 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_a(owner);
2921 return nativeResponseValue;
2923 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_b(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
2925 export function C2Tuple_PaymentHashPaymentIdZ_get_b(owner: number): number {
2926 if(!isWasmInitialized) {
2927 throw new Error("initializeWasm() must be awaited first!");
2929 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_b(owner);
2930 return nativeResponseValue;
2932 // struct LDKC2Tuple_PaymentHashPaymentIdZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
2934 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner: number): number {
2935 if(!isWasmInitialized) {
2936 throw new Error("initializeWasm() must be awaited first!");
2938 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner);
2939 return nativeResponseValue;
2941 // struct LDKPaymentSendFailure CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
2943 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner: number): number {
2944 if(!isWasmInitialized) {
2945 throw new Error("initializeWasm() must be awaited first!");
2947 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner);
2948 return nativeResponseValue;
2951 export class LDKNetAddress {
2952 protected constructor() {}
2955 export function LDKNetAddress_ty_from_ptr(ptr: number): number {
2956 if(!isWasmInitialized) {
2957 throw new Error("initializeWasm() must be awaited first!");
2959 const nativeResponseValue = wasm.TS_LDKNetAddress_ty_from_ptr(ptr);
2960 return nativeResponseValue;
2963 export function LDKNetAddress_IPv4_get_addr(ptr: number): number {
2964 if(!isWasmInitialized) {
2965 throw new Error("initializeWasm() must be awaited first!");
2967 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_addr(ptr);
2968 return nativeResponseValue;
2971 export function LDKNetAddress_IPv4_get_port(ptr: number): number {
2972 if(!isWasmInitialized) {
2973 throw new Error("initializeWasm() must be awaited first!");
2975 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_port(ptr);
2976 return nativeResponseValue;
2979 export function LDKNetAddress_IPv6_get_addr(ptr: number): number {
2980 if(!isWasmInitialized) {
2981 throw new Error("initializeWasm() must be awaited first!");
2983 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_addr(ptr);
2984 return nativeResponseValue;
2987 export function LDKNetAddress_IPv6_get_port(ptr: number): number {
2988 if(!isWasmInitialized) {
2989 throw new Error("initializeWasm() must be awaited first!");
2991 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_port(ptr);
2992 return nativeResponseValue;
2995 export function LDKNetAddress_OnionV2_get_onion_v2(ptr: number): number {
2996 if(!isWasmInitialized) {
2997 throw new Error("initializeWasm() must be awaited first!");
2999 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV2_get_onion_v2(ptr);
3000 return nativeResponseValue;
3003 export function LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr: number): number {
3004 if(!isWasmInitialized) {
3005 throw new Error("initializeWasm() must be awaited first!");
3007 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr);
3008 return nativeResponseValue;
3011 export function LDKNetAddress_OnionV3_get_checksum(ptr: number): number {
3012 if(!isWasmInitialized) {
3013 throw new Error("initializeWasm() must be awaited first!");
3015 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_checksum(ptr);
3016 return nativeResponseValue;
3019 export function LDKNetAddress_OnionV3_get_version(ptr: number): number {
3020 if(!isWasmInitialized) {
3021 throw new Error("initializeWasm() must be awaited first!");
3023 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_version(ptr);
3024 return nativeResponseValue;
3027 export function LDKNetAddress_OnionV3_get_port(ptr: number): number {
3028 if(!isWasmInitialized) {
3029 throw new Error("initializeWasm() must be awaited first!");
3031 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_port(ptr);
3032 return nativeResponseValue;
3034 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_a(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
3036 export function C2Tuple_PaymentHashPaymentSecretZ_get_a(owner: number): number {
3037 if(!isWasmInitialized) {
3038 throw new Error("initializeWasm() must be awaited first!");
3040 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_a(owner);
3041 return nativeResponseValue;
3043 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_b(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
3045 export function C2Tuple_PaymentHashPaymentSecretZ_get_b(owner: number): number {
3046 if(!isWasmInitialized) {
3047 throw new Error("initializeWasm() must be awaited first!");
3049 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_b(owner);
3050 return nativeResponseValue;
3052 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
3054 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner: number): number {
3055 if(!isWasmInitialized) {
3056 throw new Error("initializeWasm() must be awaited first!");
3058 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner);
3059 return nativeResponseValue;
3061 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
3063 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner: number): void {
3064 if(!isWasmInitialized) {
3065 throw new Error("initializeWasm() must be awaited first!");
3067 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner);
3068 // debug statements here
3070 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
3072 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner: number): number {
3073 if(!isWasmInitialized) {
3074 throw new Error("initializeWasm() must be awaited first!");
3076 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner);
3077 return nativeResponseValue;
3079 // struct LDKAPIError CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
3081 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner: number): number {
3082 if(!isWasmInitialized) {
3083 throw new Error("initializeWasm() must be awaited first!");
3085 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner);
3086 return nativeResponseValue;
3088 // struct LDKThirtyTwoBytes CResult_PaymentSecretNoneZ_get_ok(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
3090 export function CResult_PaymentSecretNoneZ_get_ok(owner: number): number {
3091 if(!isWasmInitialized) {
3092 throw new Error("initializeWasm() must be awaited first!");
3094 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_ok(owner);
3095 return nativeResponseValue;
3097 // void CResult_PaymentSecretNoneZ_get_err(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
3099 export function CResult_PaymentSecretNoneZ_get_err(owner: number): void {
3100 if(!isWasmInitialized) {
3101 throw new Error("initializeWasm() must be awaited first!");
3103 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_err(owner);
3104 // debug statements here
3106 // struct LDKThirtyTwoBytes CResult_PaymentSecretAPIErrorZ_get_ok(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
3108 export function CResult_PaymentSecretAPIErrorZ_get_ok(owner: number): number {
3109 if(!isWasmInitialized) {
3110 throw new Error("initializeWasm() must be awaited first!");
3112 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_ok(owner);
3113 return nativeResponseValue;
3115 // struct LDKAPIError CResult_PaymentSecretAPIErrorZ_get_err(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
3117 export function CResult_PaymentSecretAPIErrorZ_get_err(owner: number): number {
3118 if(!isWasmInitialized) {
3119 throw new Error("initializeWasm() must be awaited first!");
3121 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_err(owner);
3122 return nativeResponseValue;
3124 // struct LDKThirtyTwoBytes CResult_PaymentPreimageAPIErrorZ_get_ok(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
3126 export function CResult_PaymentPreimageAPIErrorZ_get_ok(owner: number): number {
3127 if(!isWasmInitialized) {
3128 throw new Error("initializeWasm() must be awaited first!");
3130 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_ok(owner);
3131 return nativeResponseValue;
3133 // struct LDKAPIError CResult_PaymentPreimageAPIErrorZ_get_err(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
3135 export function CResult_PaymentPreimageAPIErrorZ_get_err(owner: number): number {
3136 if(!isWasmInitialized) {
3137 throw new Error("initializeWasm() must be awaited first!");
3139 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_err(owner);
3140 return nativeResponseValue;
3142 // struct LDKCounterpartyForwardingInfo CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
3144 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner: number): number {
3145 if(!isWasmInitialized) {
3146 throw new Error("initializeWasm() must be awaited first!");
3148 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner);
3149 return nativeResponseValue;
3151 // struct LDKDecodeError CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
3153 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner: number): number {
3154 if(!isWasmInitialized) {
3155 throw new Error("initializeWasm() must be awaited first!");
3157 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner);
3158 return nativeResponseValue;
3160 // struct LDKChannelCounterparty CResult_ChannelCounterpartyDecodeErrorZ_get_ok(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
3162 export function CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner: number): number {
3163 if(!isWasmInitialized) {
3164 throw new Error("initializeWasm() must be awaited first!");
3166 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner);
3167 return nativeResponseValue;
3169 // struct LDKDecodeError CResult_ChannelCounterpartyDecodeErrorZ_get_err(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
3171 export function CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner: number): number {
3172 if(!isWasmInitialized) {
3173 throw new Error("initializeWasm() must be awaited first!");
3175 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner);
3176 return nativeResponseValue;
3178 // struct LDKChannelDetails CResult_ChannelDetailsDecodeErrorZ_get_ok(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
3180 export function CResult_ChannelDetailsDecodeErrorZ_get_ok(owner: number): number {
3181 if(!isWasmInitialized) {
3182 throw new Error("initializeWasm() must be awaited first!");
3184 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_ok(owner);
3185 return nativeResponseValue;
3187 // struct LDKDecodeError CResult_ChannelDetailsDecodeErrorZ_get_err(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
3189 export function CResult_ChannelDetailsDecodeErrorZ_get_err(owner: number): number {
3190 if(!isWasmInitialized) {
3191 throw new Error("initializeWasm() must be awaited first!");
3193 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_err(owner);
3194 return nativeResponseValue;
3196 // struct LDKPhantomRouteHints CResult_PhantomRouteHintsDecodeErrorZ_get_ok(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
3198 export function CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner: number): number {
3199 if(!isWasmInitialized) {
3200 throw new Error("initializeWasm() must be awaited first!");
3202 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner);
3203 return nativeResponseValue;
3205 // struct LDKDecodeError CResult_PhantomRouteHintsDecodeErrorZ_get_err(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
3207 export function CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner: number): number {
3208 if(!isWasmInitialized) {
3209 throw new Error("initializeWasm() must be awaited first!");
3211 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner);
3212 return nativeResponseValue;
3215 export interface LDKWatch {
3216 watch_channel (funding_txo: number, monitor: number): number;
3217 update_channel (funding_txo: number, update: number): number;
3218 release_pending_monitor_events (): number;
3222 export function LDKWatch_new(impl: LDKWatch): number {
3223 if(!isWasmInitialized) {
3224 throw new Error("initializeWasm() must be awaited first!");
3226 var new_obj_idx = js_objs.length;
3227 for (var i = 0; i < js_objs.length; i++) {
3228 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3230 js_objs[i] = new WeakRef(impl);
3231 return wasm.TS_LDKWatch_new(i);
3233 // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_watch_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor
3235 export function Watch_watch_channel(this_arg: number, funding_txo: number, monitor: number): number {
3236 if(!isWasmInitialized) {
3237 throw new Error("initializeWasm() must be awaited first!");
3239 const nativeResponseValue = wasm.TS_Watch_watch_channel(this_arg, funding_txo, monitor);
3240 return nativeResponseValue;
3242 // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_update_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update
3244 export function Watch_update_channel(this_arg: number, funding_txo: number, update: number): number {
3245 if(!isWasmInitialized) {
3246 throw new Error("initializeWasm() must be awaited first!");
3248 const nativeResponseValue = wasm.TS_Watch_update_channel(this_arg, funding_txo, update);
3249 return nativeResponseValue;
3251 // LDKCVec_MonitorEventZ Watch_release_pending_monitor_events LDKWatch *NONNULL_PTR this_arg
3253 export function Watch_release_pending_monitor_events(this_arg: number): number {
3254 if(!isWasmInitialized) {
3255 throw new Error("initializeWasm() must be awaited first!");
3257 const nativeResponseValue = wasm.TS_Watch_release_pending_monitor_events(this_arg);
3258 return nativeResponseValue;
3261 export interface LDKBroadcasterInterface {
3262 broadcast_transaction (tx: number): void;
3266 export function LDKBroadcasterInterface_new(impl: LDKBroadcasterInterface): number {
3267 if(!isWasmInitialized) {
3268 throw new Error("initializeWasm() must be awaited first!");
3270 var new_obj_idx = js_objs.length;
3271 for (var i = 0; i < js_objs.length; i++) {
3272 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3274 js_objs[i] = new WeakRef(impl);
3275 return wasm.TS_LDKBroadcasterInterface_new(i);
3277 // void BroadcasterInterface_broadcast_transaction LDKBroadcasterInterface *NONNULL_PTR this_arg, struct LDKTransaction tx
3279 export function BroadcasterInterface_broadcast_transaction(this_arg: number, tx: number): void {
3280 if(!isWasmInitialized) {
3281 throw new Error("initializeWasm() must be awaited first!");
3283 const nativeResponseValue = wasm.TS_BroadcasterInterface_broadcast_transaction(this_arg, tx);
3284 // debug statements here
3287 export interface LDKKeysInterface {
3288 get_node_secret (recipient: Recipient): number;
3289 get_destination_script (): number;
3290 get_shutdown_scriptpubkey (): number;
3291 get_channel_signer (inbound: boolean, channel_value_satoshis: bigint): number;
3292 get_secure_random_bytes (): number;
3293 read_chan_signer (reader: number): number;
3294 sign_invoice (hrp_bytes: number, invoice_data: number, receipient: Recipient): number;
3295 get_inbound_payment_key_material (): number;
3299 export function LDKKeysInterface_new(impl: LDKKeysInterface): number {
3300 if(!isWasmInitialized) {
3301 throw new Error("initializeWasm() must be awaited first!");
3303 var new_obj_idx = js_objs.length;
3304 for (var i = 0; i < js_objs.length; i++) {
3305 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3307 js_objs[i] = new WeakRef(impl);
3308 return wasm.TS_LDKKeysInterface_new(i);
3310 // LDKCResult_SecretKeyNoneZ KeysInterface_get_node_secret LDKKeysInterface *NONNULL_PTR this_arg, enum LDKRecipient recipient
3312 export function KeysInterface_get_node_secret(this_arg: number, recipient: Recipient): number {
3313 if(!isWasmInitialized) {
3314 throw new Error("initializeWasm() must be awaited first!");
3316 const nativeResponseValue = wasm.TS_KeysInterface_get_node_secret(this_arg, recipient);
3317 return nativeResponseValue;
3319 // LDKCVec_u8Z KeysInterface_get_destination_script LDKKeysInterface *NONNULL_PTR this_arg
3321 export function KeysInterface_get_destination_script(this_arg: number): number {
3322 if(!isWasmInitialized) {
3323 throw new Error("initializeWasm() must be awaited first!");
3325 const nativeResponseValue = wasm.TS_KeysInterface_get_destination_script(this_arg);
3326 return nativeResponseValue;
3328 // LDKShutdownScript KeysInterface_get_shutdown_scriptpubkey LDKKeysInterface *NONNULL_PTR this_arg
3330 export function KeysInterface_get_shutdown_scriptpubkey(this_arg: number): number {
3331 if(!isWasmInitialized) {
3332 throw new Error("initializeWasm() must be awaited first!");
3334 const nativeResponseValue = wasm.TS_KeysInterface_get_shutdown_scriptpubkey(this_arg);
3335 return nativeResponseValue;
3337 // LDKSign KeysInterface_get_channel_signer LDKKeysInterface *NONNULL_PTR this_arg, bool inbound, uint64_t channel_value_satoshis
3339 export function KeysInterface_get_channel_signer(this_arg: number, inbound: boolean, channel_value_satoshis: bigint): number {
3340 if(!isWasmInitialized) {
3341 throw new Error("initializeWasm() must be awaited first!");
3343 const nativeResponseValue = wasm.TS_KeysInterface_get_channel_signer(this_arg, inbound, channel_value_satoshis);
3344 return nativeResponseValue;
3346 // LDKThirtyTwoBytes KeysInterface_get_secure_random_bytes LDKKeysInterface *NONNULL_PTR this_arg
3348 export function KeysInterface_get_secure_random_bytes(this_arg: number): number {
3349 if(!isWasmInitialized) {
3350 throw new Error("initializeWasm() must be awaited first!");
3352 const nativeResponseValue = wasm.TS_KeysInterface_get_secure_random_bytes(this_arg);
3353 return nativeResponseValue;
3355 // LDKCResult_SignDecodeErrorZ KeysInterface_read_chan_signer LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice reader
3357 export function KeysInterface_read_chan_signer(this_arg: number, reader: number): number {
3358 if(!isWasmInitialized) {
3359 throw new Error("initializeWasm() must be awaited first!");
3361 const nativeResponseValue = wasm.TS_KeysInterface_read_chan_signer(this_arg, reader);
3362 return nativeResponseValue;
3364 // LDKCResult_RecoverableSignatureNoneZ KeysInterface_sign_invoice LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z invoice_data, enum LDKRecipient receipient
3366 export function KeysInterface_sign_invoice(this_arg: number, hrp_bytes: number, invoice_data: number, receipient: Recipient): number {
3367 if(!isWasmInitialized) {
3368 throw new Error("initializeWasm() must be awaited first!");
3370 const nativeResponseValue = wasm.TS_KeysInterface_sign_invoice(this_arg, hrp_bytes, invoice_data, receipient);
3371 return nativeResponseValue;
3373 // LDKThirtyTwoBytes KeysInterface_get_inbound_payment_key_material LDKKeysInterface *NONNULL_PTR this_arg
3375 export function KeysInterface_get_inbound_payment_key_material(this_arg: number): number {
3376 if(!isWasmInitialized) {
3377 throw new Error("initializeWasm() must be awaited first!");
3379 const nativeResponseValue = wasm.TS_KeysInterface_get_inbound_payment_key_material(this_arg);
3380 return nativeResponseValue;
3383 export interface LDKFeeEstimator {
3384 get_est_sat_per_1000_weight (confirmation_target: ConfirmationTarget): number;
3388 export function LDKFeeEstimator_new(impl: LDKFeeEstimator): number {
3389 if(!isWasmInitialized) {
3390 throw new Error("initializeWasm() must be awaited first!");
3392 var new_obj_idx = js_objs.length;
3393 for (var i = 0; i < js_objs.length; i++) {
3394 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3396 js_objs[i] = new WeakRef(impl);
3397 return wasm.TS_LDKFeeEstimator_new(i);
3399 // uint32_t FeeEstimator_get_est_sat_per_1000_weight LDKFeeEstimator *NONNULL_PTR this_arg, enum LDKConfirmationTarget confirmation_target
3401 export function FeeEstimator_get_est_sat_per_1000_weight(this_arg: number, confirmation_target: ConfirmationTarget): number {
3402 if(!isWasmInitialized) {
3403 throw new Error("initializeWasm() must be awaited first!");
3405 const nativeResponseValue = wasm.TS_FeeEstimator_get_est_sat_per_1000_weight(this_arg, confirmation_target);
3406 return nativeResponseValue;
3409 export interface LDKLogger {
3410 log (record: number): void;
3414 export function LDKLogger_new(impl: LDKLogger): number {
3415 if(!isWasmInitialized) {
3416 throw new Error("initializeWasm() must be awaited first!");
3418 var new_obj_idx = js_objs.length;
3419 for (var i = 0; i < js_objs.length; i++) {
3420 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3422 js_objs[i] = new WeakRef(impl);
3423 return wasm.TS_LDKLogger_new(i);
3425 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelManagerZ_get_a(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
3427 export function C2Tuple_BlockHashChannelManagerZ_get_a(owner: number): number {
3428 if(!isWasmInitialized) {
3429 throw new Error("initializeWasm() must be awaited first!");
3431 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_a(owner);
3432 return nativeResponseValue;
3434 // struct LDKChannelManager *C2Tuple_BlockHashChannelManagerZ_get_b(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
3436 export function C2Tuple_BlockHashChannelManagerZ_get_b(owner: number): number {
3437 if(!isWasmInitialized) {
3438 throw new Error("initializeWasm() must be awaited first!");
3440 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_b(owner);
3441 return nativeResponseValue;
3443 // struct LDKC2Tuple_BlockHashChannelManagerZ *CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
3445 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner: number): number {
3446 if(!isWasmInitialized) {
3447 throw new Error("initializeWasm() must be awaited first!");
3449 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner);
3450 return nativeResponseValue;
3452 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
3454 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner: number): number {
3455 if(!isWasmInitialized) {
3456 throw new Error("initializeWasm() must be awaited first!");
3458 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner);
3459 return nativeResponseValue;
3461 // struct LDKChannelConfig CResult_ChannelConfigDecodeErrorZ_get_ok(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
3463 export function CResult_ChannelConfigDecodeErrorZ_get_ok(owner: number): number {
3464 if(!isWasmInitialized) {
3465 throw new Error("initializeWasm() must be awaited first!");
3467 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_ok(owner);
3468 return nativeResponseValue;
3470 // struct LDKDecodeError CResult_ChannelConfigDecodeErrorZ_get_err(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
3472 export function CResult_ChannelConfigDecodeErrorZ_get_err(owner: number): number {
3473 if(!isWasmInitialized) {
3474 throw new Error("initializeWasm() must be awaited first!");
3476 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_err(owner);
3477 return nativeResponseValue;
3479 // struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
3481 export function CResult_OutPointDecodeErrorZ_get_ok(owner: number): number {
3482 if(!isWasmInitialized) {
3483 throw new Error("initializeWasm() must be awaited first!");
3485 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_ok(owner);
3486 return nativeResponseValue;
3488 // struct LDKDecodeError CResult_OutPointDecodeErrorZ_get_err(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
3490 export function CResult_OutPointDecodeErrorZ_get_err(owner: number): number {
3491 if(!isWasmInitialized) {
3492 throw new Error("initializeWasm() must be awaited first!");
3494 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_err(owner);
3495 return nativeResponseValue;
3498 export interface LDKType {
3500 debug_str (): number;
3505 export function LDKType_new(impl: LDKType): number {
3506 if(!isWasmInitialized) {
3507 throw new Error("initializeWasm() must be awaited first!");
3509 var new_obj_idx = js_objs.length;
3510 for (var i = 0; i < js_objs.length; i++) {
3511 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3513 js_objs[i] = new WeakRef(impl);
3514 return wasm.TS_LDKType_new(i);
3516 // uint16_t Type_type_id LDKType *NONNULL_PTR this_arg
3518 export function Type_type_id(this_arg: number): number {
3519 if(!isWasmInitialized) {
3520 throw new Error("initializeWasm() must be awaited first!");
3522 const nativeResponseValue = wasm.TS_Type_type_id(this_arg);
3523 return nativeResponseValue;
3525 // LDKStr Type_debug_str LDKType *NONNULL_PTR this_arg
3527 export function Type_debug_str(this_arg: number): number {
3528 if(!isWasmInitialized) {
3529 throw new Error("initializeWasm() must be awaited first!");
3531 const nativeResponseValue = wasm.TS_Type_debug_str(this_arg);
3532 return nativeResponseValue;
3534 // LDKCVec_u8Z Type_write LDKType *NONNULL_PTR this_arg
3536 export function Type_write(this_arg: number): number {
3537 if(!isWasmInitialized) {
3538 throw new Error("initializeWasm() must be awaited first!");
3540 const nativeResponseValue = wasm.TS_Type_write(this_arg);
3541 return nativeResponseValue;
3544 export class LDKCOption_TypeZ {
3545 protected constructor() {}
3548 export function LDKCOption_TypeZ_ty_from_ptr(ptr: number): number {
3549 if(!isWasmInitialized) {
3550 throw new Error("initializeWasm() must be awaited first!");
3552 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_ty_from_ptr(ptr);
3553 return nativeResponseValue;
3556 export function LDKCOption_TypeZ_Some_get_some(ptr: number): number {
3557 if(!isWasmInitialized) {
3558 throw new Error("initializeWasm() must be awaited first!");
3560 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_Some_get_some(ptr);
3561 return nativeResponseValue;
3563 // struct LDKCOption_TypeZ CResult_COption_TypeZDecodeErrorZ_get_ok(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
3565 export function CResult_COption_TypeZDecodeErrorZ_get_ok(owner: number): number {
3566 if(!isWasmInitialized) {
3567 throw new Error("initializeWasm() must be awaited first!");
3569 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_ok(owner);
3570 return nativeResponseValue;
3572 // struct LDKDecodeError CResult_COption_TypeZDecodeErrorZ_get_err(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
3574 export function CResult_COption_TypeZDecodeErrorZ_get_err(owner: number): number {
3575 if(!isWasmInitialized) {
3576 throw new Error("initializeWasm() must be awaited first!");
3578 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_err(owner);
3579 return nativeResponseValue;
3582 export class LDKPaymentError {
3583 protected constructor() {}
3586 export function LDKPaymentError_ty_from_ptr(ptr: number): number {
3587 if(!isWasmInitialized) {
3588 throw new Error("initializeWasm() must be awaited first!");
3590 const nativeResponseValue = wasm.TS_LDKPaymentError_ty_from_ptr(ptr);
3591 return nativeResponseValue;
3594 export function LDKPaymentError_Invoice_get_invoice(ptr: number): number {
3595 if(!isWasmInitialized) {
3596 throw new Error("initializeWasm() must be awaited first!");
3598 const nativeResponseValue = wasm.TS_LDKPaymentError_Invoice_get_invoice(ptr);
3599 return nativeResponseValue;
3602 export function LDKPaymentError_Routing_get_routing(ptr: number): number {
3603 if(!isWasmInitialized) {
3604 throw new Error("initializeWasm() must be awaited first!");
3606 const nativeResponseValue = wasm.TS_LDKPaymentError_Routing_get_routing(ptr);
3607 return nativeResponseValue;
3610 export function LDKPaymentError_Sending_get_sending(ptr: number): number {
3611 if(!isWasmInitialized) {
3612 throw new Error("initializeWasm() must be awaited first!");
3614 const nativeResponseValue = wasm.TS_LDKPaymentError_Sending_get_sending(ptr);
3615 return nativeResponseValue;
3617 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentErrorZ_get_ok(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
3619 export function CResult_PaymentIdPaymentErrorZ_get_ok(owner: number): number {
3620 if(!isWasmInitialized) {
3621 throw new Error("initializeWasm() must be awaited first!");
3623 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_ok(owner);
3624 return nativeResponseValue;
3626 // struct LDKPaymentError CResult_PaymentIdPaymentErrorZ_get_err(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
3628 export function CResult_PaymentIdPaymentErrorZ_get_err(owner: number): number {
3629 if(!isWasmInitialized) {
3630 throw new Error("initializeWasm() must be awaited first!");
3632 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_err(owner);
3633 return nativeResponseValue;
3635 // enum LDKSiPrefix CResult_SiPrefixNoneZ_get_ok(LDKCResult_SiPrefixNoneZ *NONNULL_PTR owner);
3637 export function CResult_SiPrefixNoneZ_get_ok(owner: number): SiPrefix {
3638 if(!isWasmInitialized) {
3639 throw new Error("initializeWasm() must be awaited first!");
3641 const nativeResponseValue = wasm.TS_CResult_SiPrefixNoneZ_get_ok(owner);
3642 return nativeResponseValue;
3644 // void CResult_SiPrefixNoneZ_get_err(LDKCResult_SiPrefixNoneZ *NONNULL_PTR owner);
3646 export function CResult_SiPrefixNoneZ_get_err(owner: number): void {
3647 if(!isWasmInitialized) {
3648 throw new Error("initializeWasm() must be awaited first!");
3650 const nativeResponseValue = wasm.TS_CResult_SiPrefixNoneZ_get_err(owner);
3651 // debug statements here
3653 // struct LDKInvoice CResult_InvoiceNoneZ_get_ok(LDKCResult_InvoiceNoneZ *NONNULL_PTR owner);
3655 export function CResult_InvoiceNoneZ_get_ok(owner: number): number {
3656 if(!isWasmInitialized) {
3657 throw new Error("initializeWasm() must be awaited first!");
3659 const nativeResponseValue = wasm.TS_CResult_InvoiceNoneZ_get_ok(owner);
3660 return nativeResponseValue;
3662 // void CResult_InvoiceNoneZ_get_err(LDKCResult_InvoiceNoneZ *NONNULL_PTR owner);
3664 export function CResult_InvoiceNoneZ_get_err(owner: number): void {
3665 if(!isWasmInitialized) {
3666 throw new Error("initializeWasm() must be awaited first!");
3668 const nativeResponseValue = wasm.TS_CResult_InvoiceNoneZ_get_err(owner);
3669 // debug statements here
3671 // struct LDKSignedRawInvoice CResult_SignedRawInvoiceNoneZ_get_ok(LDKCResult_SignedRawInvoiceNoneZ *NONNULL_PTR owner);
3673 export function CResult_SignedRawInvoiceNoneZ_get_ok(owner: number): number {
3674 if(!isWasmInitialized) {
3675 throw new Error("initializeWasm() must be awaited first!");
3677 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceNoneZ_get_ok(owner);
3678 return nativeResponseValue;
3680 // void CResult_SignedRawInvoiceNoneZ_get_err(LDKCResult_SignedRawInvoiceNoneZ *NONNULL_PTR owner);
3682 export function CResult_SignedRawInvoiceNoneZ_get_err(owner: number): void {
3683 if(!isWasmInitialized) {
3684 throw new Error("initializeWasm() must be awaited first!");
3686 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceNoneZ_get_err(owner);
3687 // debug statements here
3689 // struct LDKRawInvoice C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
3691 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner: number): number {
3692 if(!isWasmInitialized) {
3693 throw new Error("initializeWasm() must be awaited first!");
3695 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner);
3696 return nativeResponseValue;
3698 // struct LDKThirtyTwoBytes C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
3700 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner: number): number {
3701 if(!isWasmInitialized) {
3702 throw new Error("initializeWasm() must be awaited first!");
3704 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner);
3705 return nativeResponseValue;
3707 // struct LDKInvoiceSignature C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
3709 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner: number): number {
3710 if(!isWasmInitialized) {
3711 throw new Error("initializeWasm() must be awaited first!");
3713 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner);
3714 return nativeResponseValue;
3716 // struct LDKPayeePubKey CResult_PayeePubKeyErrorZ_get_ok(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
3718 export function CResult_PayeePubKeyErrorZ_get_ok(owner: number): number {
3719 if(!isWasmInitialized) {
3720 throw new Error("initializeWasm() must be awaited first!");
3722 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_ok(owner);
3723 return nativeResponseValue;
3725 // enum LDKSecp256k1Error CResult_PayeePubKeyErrorZ_get_err(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
3727 export function CResult_PayeePubKeyErrorZ_get_err(owner: number): Secp256k1Error {
3728 if(!isWasmInitialized) {
3729 throw new Error("initializeWasm() must be awaited first!");
3731 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_err(owner);
3732 return nativeResponseValue;
3734 // struct LDKPositiveTimestamp CResult_PositiveTimestampCreationErrorZ_get_ok(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
3736 export function CResult_PositiveTimestampCreationErrorZ_get_ok(owner: number): number {
3737 if(!isWasmInitialized) {
3738 throw new Error("initializeWasm() must be awaited first!");
3740 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_ok(owner);
3741 return nativeResponseValue;
3743 // enum LDKCreationError CResult_PositiveTimestampCreationErrorZ_get_err(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
3745 export function CResult_PositiveTimestampCreationErrorZ_get_err(owner: number): CreationError {
3746 if(!isWasmInitialized) {
3747 throw new Error("initializeWasm() must be awaited first!");
3749 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_err(owner);
3750 return nativeResponseValue;
3752 // void CResult_NoneSemanticErrorZ_get_ok(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
3754 export function CResult_NoneSemanticErrorZ_get_ok(owner: number): void {
3755 if(!isWasmInitialized) {
3756 throw new Error("initializeWasm() must be awaited first!");
3758 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_ok(owner);
3759 // debug statements here
3761 // enum LDKSemanticError CResult_NoneSemanticErrorZ_get_err(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
3763 export function CResult_NoneSemanticErrorZ_get_err(owner: number): SemanticError {
3764 if(!isWasmInitialized) {
3765 throw new Error("initializeWasm() must be awaited first!");
3767 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_err(owner);
3768 return nativeResponseValue;
3770 // struct LDKInvoice CResult_InvoiceSemanticErrorZ_get_ok(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
3772 export function CResult_InvoiceSemanticErrorZ_get_ok(owner: number): number {
3773 if(!isWasmInitialized) {
3774 throw new Error("initializeWasm() must be awaited first!");
3776 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_ok(owner);
3777 return nativeResponseValue;
3779 // enum LDKSemanticError CResult_InvoiceSemanticErrorZ_get_err(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
3781 export function CResult_InvoiceSemanticErrorZ_get_err(owner: number): SemanticError {
3782 if(!isWasmInitialized) {
3783 throw new Error("initializeWasm() must be awaited first!");
3785 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_err(owner);
3786 return nativeResponseValue;
3788 // struct LDKDescription CResult_DescriptionCreationErrorZ_get_ok(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
3790 export function CResult_DescriptionCreationErrorZ_get_ok(owner: number): number {
3791 if(!isWasmInitialized) {
3792 throw new Error("initializeWasm() must be awaited first!");
3794 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_ok(owner);
3795 return nativeResponseValue;
3797 // enum LDKCreationError CResult_DescriptionCreationErrorZ_get_err(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
3799 export function CResult_DescriptionCreationErrorZ_get_err(owner: number): CreationError {
3800 if(!isWasmInitialized) {
3801 throw new Error("initializeWasm() must be awaited first!");
3803 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_err(owner);
3804 return nativeResponseValue;
3806 // struct LDKPrivateRoute CResult_PrivateRouteCreationErrorZ_get_ok(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
3808 export function CResult_PrivateRouteCreationErrorZ_get_ok(owner: number): number {
3809 if(!isWasmInitialized) {
3810 throw new Error("initializeWasm() must be awaited first!");
3812 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_ok(owner);
3813 return nativeResponseValue;
3815 // enum LDKCreationError CResult_PrivateRouteCreationErrorZ_get_err(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
3817 export function CResult_PrivateRouteCreationErrorZ_get_err(owner: number): CreationError {
3818 if(!isWasmInitialized) {
3819 throw new Error("initializeWasm() must be awaited first!");
3821 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_err(owner);
3822 return nativeResponseValue;
3824 // struct LDKStr CResult_StringErrorZ_get_ok(LDKCResult_StringErrorZ *NONNULL_PTR owner);
3826 export function CResult_StringErrorZ_get_ok(owner: number): number {
3827 if(!isWasmInitialized) {
3828 throw new Error("initializeWasm() must be awaited first!");
3830 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_ok(owner);
3831 return nativeResponseValue;
3833 // enum LDKSecp256k1Error CResult_StringErrorZ_get_err(LDKCResult_StringErrorZ *NONNULL_PTR owner);
3835 export function CResult_StringErrorZ_get_err(owner: number): Secp256k1Error {
3836 if(!isWasmInitialized) {
3837 throw new Error("initializeWasm() must be awaited first!");
3839 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_err(owner);
3840 return nativeResponseValue;
3842 // struct LDKChannelMonitorUpdate CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
3844 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner: number): number {
3845 if(!isWasmInitialized) {
3846 throw new Error("initializeWasm() must be awaited first!");
3848 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner);
3849 return nativeResponseValue;
3851 // struct LDKDecodeError CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
3853 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner: number): number {
3854 if(!isWasmInitialized) {
3855 throw new Error("initializeWasm() must be awaited first!");
3857 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner);
3858 return nativeResponseValue;
3861 export class LDKCOption_MonitorEventZ {
3862 protected constructor() {}
3865 export function LDKCOption_MonitorEventZ_ty_from_ptr(ptr: number): number {
3866 if(!isWasmInitialized) {
3867 throw new Error("initializeWasm() must be awaited first!");
3869 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_ty_from_ptr(ptr);
3870 return nativeResponseValue;
3873 export function LDKCOption_MonitorEventZ_Some_get_some(ptr: number): number {
3874 if(!isWasmInitialized) {
3875 throw new Error("initializeWasm() must be awaited first!");
3877 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_Some_get_some(ptr);
3878 return nativeResponseValue;
3880 // struct LDKCOption_MonitorEventZ CResult_COption_MonitorEventZDecodeErrorZ_get_ok(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
3882 export function CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner: number): number {
3883 if(!isWasmInitialized) {
3884 throw new Error("initializeWasm() must be awaited first!");
3886 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner);
3887 return nativeResponseValue;
3889 // struct LDKDecodeError CResult_COption_MonitorEventZDecodeErrorZ_get_err(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
3891 export function CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner: number): number {
3892 if(!isWasmInitialized) {
3893 throw new Error("initializeWasm() must be awaited first!");
3895 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner);
3896 return nativeResponseValue;
3898 // struct LDKHTLCUpdate CResult_HTLCUpdateDecodeErrorZ_get_ok(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
3900 export function CResult_HTLCUpdateDecodeErrorZ_get_ok(owner: number): number {
3901 if(!isWasmInitialized) {
3902 throw new Error("initializeWasm() must be awaited first!");
3904 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_ok(owner);
3905 return nativeResponseValue;
3907 // struct LDKDecodeError CResult_HTLCUpdateDecodeErrorZ_get_err(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
3909 export function CResult_HTLCUpdateDecodeErrorZ_get_err(owner: number): number {
3910 if(!isWasmInitialized) {
3911 throw new Error("initializeWasm() must be awaited first!");
3913 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_err(owner);
3914 return nativeResponseValue;
3916 // struct LDKOutPoint C2Tuple_OutPointScriptZ_get_a(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
3918 export function C2Tuple_OutPointScriptZ_get_a(owner: number): number {
3919 if(!isWasmInitialized) {
3920 throw new Error("initializeWasm() must be awaited first!");
3922 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_a(owner);
3923 return nativeResponseValue;
3925 // struct LDKCVec_u8Z C2Tuple_OutPointScriptZ_get_b(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
3927 export function C2Tuple_OutPointScriptZ_get_b(owner: number): number {
3928 if(!isWasmInitialized) {
3929 throw new Error("initializeWasm() must be awaited first!");
3931 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_b(owner);
3932 return nativeResponseValue;
3934 // uint32_t C2Tuple_u32ScriptZ_get_a(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
3936 export function C2Tuple_u32ScriptZ_get_a(owner: number): number {
3937 if(!isWasmInitialized) {
3938 throw new Error("initializeWasm() must be awaited first!");
3940 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_a(owner);
3941 return nativeResponseValue;
3943 // struct LDKCVec_u8Z C2Tuple_u32ScriptZ_get_b(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
3945 export function C2Tuple_u32ScriptZ_get_b(owner: number): number {
3946 if(!isWasmInitialized) {
3947 throw new Error("initializeWasm() must be awaited first!");
3949 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_b(owner);
3950 return nativeResponseValue;
3952 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
3954 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner: number): number {
3955 if(!isWasmInitialized) {
3956 throw new Error("initializeWasm() must be awaited first!");
3958 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner);
3959 return nativeResponseValue;
3961 // struct LDKCVec_C2Tuple_u32ScriptZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
3963 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner: number): number {
3964 if(!isWasmInitialized) {
3965 throw new Error("initializeWasm() must be awaited first!");
3967 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner);
3968 return nativeResponseValue;
3970 // uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
3972 export function C2Tuple_u32TxOutZ_get_a(owner: number): number {
3973 if(!isWasmInitialized) {
3974 throw new Error("initializeWasm() must be awaited first!");
3976 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_a(owner);
3977 return nativeResponseValue;
3979 // struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
3981 export function C2Tuple_u32TxOutZ_get_b(owner: number): number {
3982 if(!isWasmInitialized) {
3983 throw new Error("initializeWasm() must be awaited first!");
3985 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_b(owner);
3986 return nativeResponseValue;
3988 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
3990 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner: number): number {
3991 if(!isWasmInitialized) {
3992 throw new Error("initializeWasm() must be awaited first!");
3994 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner);
3995 return nativeResponseValue;
3997 // struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
3999 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner: number): number {
4000 if(!isWasmInitialized) {
4001 throw new Error("initializeWasm() must be awaited first!");
4003 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner);
4004 return nativeResponseValue;
4007 export class LDKBalance {
4008 protected constructor() {}
4011 export function LDKBalance_ty_from_ptr(ptr: number): number {
4012 if(!isWasmInitialized) {
4013 throw new Error("initializeWasm() must be awaited first!");
4015 const nativeResponseValue = wasm.TS_LDKBalance_ty_from_ptr(ptr);
4016 return nativeResponseValue;
4019 export function LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr: number): bigint {
4020 if(!isWasmInitialized) {
4021 throw new Error("initializeWasm() must be awaited first!");
4023 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr);
4024 return nativeResponseValue;
4027 export function LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr: number): bigint {
4028 if(!isWasmInitialized) {
4029 throw new Error("initializeWasm() must be awaited first!");
4031 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr);
4032 return nativeResponseValue;
4035 export function LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr: number): number {
4036 if(!isWasmInitialized) {
4037 throw new Error("initializeWasm() must be awaited first!");
4039 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr);
4040 return nativeResponseValue;
4043 export function LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr: number): bigint {
4044 if(!isWasmInitialized) {
4045 throw new Error("initializeWasm() must be awaited first!");
4047 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr);
4048 return nativeResponseValue;
4051 export function LDKBalance_ContentiousClaimable_get_timeout_height(ptr: number): number {
4052 if(!isWasmInitialized) {
4053 throw new Error("initializeWasm() must be awaited first!");
4055 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_timeout_height(ptr);
4056 return nativeResponseValue;
4059 export function LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_amount_satoshis(ptr: number): bigint {
4060 if(!isWasmInitialized) {
4061 throw new Error("initializeWasm() must be awaited first!");
4063 const nativeResponseValue = wasm.TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_amount_satoshis(ptr);
4064 return nativeResponseValue;
4067 export function LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_height(ptr: number): number {
4068 if(!isWasmInitialized) {
4069 throw new Error("initializeWasm() must be awaited first!");
4071 const nativeResponseValue = wasm.TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_height(ptr);
4072 return nativeResponseValue;
4074 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelMonitorZ_get_a(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
4076 export function C2Tuple_BlockHashChannelMonitorZ_get_a(owner: number): number {
4077 if(!isWasmInitialized) {
4078 throw new Error("initializeWasm() must be awaited first!");
4080 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_a(owner);
4081 return nativeResponseValue;
4083 // struct LDKChannelMonitor C2Tuple_BlockHashChannelMonitorZ_get_b(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
4085 export function C2Tuple_BlockHashChannelMonitorZ_get_b(owner: number): number {
4086 if(!isWasmInitialized) {
4087 throw new Error("initializeWasm() must be awaited first!");
4089 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_b(owner);
4090 return nativeResponseValue;
4092 // struct LDKC2Tuple_BlockHashChannelMonitorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
4094 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner: number): number {
4095 if(!isWasmInitialized) {
4096 throw new Error("initializeWasm() must be awaited first!");
4098 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner);
4099 return nativeResponseValue;
4101 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
4103 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner: number): number {
4104 if(!isWasmInitialized) {
4105 throw new Error("initializeWasm() must be awaited first!");
4107 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner);
4108 return nativeResponseValue;
4110 // void CResult_NoneLightningErrorZ_get_ok(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
4112 export function CResult_NoneLightningErrorZ_get_ok(owner: number): void {
4113 if(!isWasmInitialized) {
4114 throw new Error("initializeWasm() must be awaited first!");
4116 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_ok(owner);
4117 // debug statements here
4119 // struct LDKLightningError CResult_NoneLightningErrorZ_get_err(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
4121 export function CResult_NoneLightningErrorZ_get_err(owner: number): number {
4122 if(!isWasmInitialized) {
4123 throw new Error("initializeWasm() must be awaited first!");
4125 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_err(owner);
4126 return nativeResponseValue;
4128 // struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
4130 export function C2Tuple_PublicKeyTypeZ_get_a(owner: number): number {
4131 if(!isWasmInitialized) {
4132 throw new Error("initializeWasm() must be awaited first!");
4134 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_a(owner);
4135 return nativeResponseValue;
4137 // struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
4139 export function C2Tuple_PublicKeyTypeZ_get_b(owner: number): number {
4140 if(!isWasmInitialized) {
4141 throw new Error("initializeWasm() must be awaited first!");
4143 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_b(owner);
4144 return nativeResponseValue;
4146 // bool CResult_boolLightningErrorZ_get_ok(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
4148 export function CResult_boolLightningErrorZ_get_ok(owner: number): boolean {
4149 if(!isWasmInitialized) {
4150 throw new Error("initializeWasm() must be awaited first!");
4152 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_ok(owner);
4153 return nativeResponseValue;
4155 // struct LDKLightningError CResult_boolLightningErrorZ_get_err(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
4157 export function CResult_boolLightningErrorZ_get_err(owner: number): number {
4158 if(!isWasmInitialized) {
4159 throw new Error("initializeWasm() must be awaited first!");
4161 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_err(owner);
4162 return nativeResponseValue;
4164 // struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
4166 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner: number): number {
4167 if(!isWasmInitialized) {
4168 throw new Error("initializeWasm() must be awaited first!");
4170 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner);
4171 return nativeResponseValue;
4173 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
4175 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner: number): number {
4176 if(!isWasmInitialized) {
4177 throw new Error("initializeWasm() must be awaited first!");
4179 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner);
4180 return nativeResponseValue;
4182 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
4184 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner: number): number {
4185 if(!isWasmInitialized) {
4186 throw new Error("initializeWasm() must be awaited first!");
4188 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner);
4189 return nativeResponseValue;
4191 // struct LDKCVec_u8Z CResult_CVec_u8ZPeerHandleErrorZ_get_ok(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
4193 export function CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner: number): number {
4194 if(!isWasmInitialized) {
4195 throw new Error("initializeWasm() must be awaited first!");
4197 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner);
4198 return nativeResponseValue;
4200 // struct LDKPeerHandleError CResult_CVec_u8ZPeerHandleErrorZ_get_err(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
4202 export function CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner: number): number {
4203 if(!isWasmInitialized) {
4204 throw new Error("initializeWasm() must be awaited first!");
4206 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner);
4207 return nativeResponseValue;
4209 // void CResult_NonePeerHandleErrorZ_get_ok(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
4211 export function CResult_NonePeerHandleErrorZ_get_ok(owner: number): void {
4212 if(!isWasmInitialized) {
4213 throw new Error("initializeWasm() must be awaited first!");
4215 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_ok(owner);
4216 // debug statements here
4218 // struct LDKPeerHandleError CResult_NonePeerHandleErrorZ_get_err(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
4220 export function CResult_NonePeerHandleErrorZ_get_err(owner: number): number {
4221 if(!isWasmInitialized) {
4222 throw new Error("initializeWasm() must be awaited first!");
4224 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_err(owner);
4225 return nativeResponseValue;
4227 // bool CResult_boolPeerHandleErrorZ_get_ok(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
4229 export function CResult_boolPeerHandleErrorZ_get_ok(owner: number): boolean {
4230 if(!isWasmInitialized) {
4231 throw new Error("initializeWasm() must be awaited first!");
4233 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_ok(owner);
4234 return nativeResponseValue;
4236 // struct LDKPeerHandleError CResult_boolPeerHandleErrorZ_get_err(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
4238 export function CResult_boolPeerHandleErrorZ_get_err(owner: number): number {
4239 if(!isWasmInitialized) {
4240 throw new Error("initializeWasm() must be awaited first!");
4242 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_err(owner);
4243 return nativeResponseValue;
4245 // struct LDKNodeId CResult_NodeIdDecodeErrorZ_get_ok(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
4247 export function CResult_NodeIdDecodeErrorZ_get_ok(owner: number): number {
4248 if(!isWasmInitialized) {
4249 throw new Error("initializeWasm() must be awaited first!");
4251 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_ok(owner);
4252 return nativeResponseValue;
4254 // struct LDKDecodeError CResult_NodeIdDecodeErrorZ_get_err(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
4256 export function CResult_NodeIdDecodeErrorZ_get_err(owner: number): number {
4257 if(!isWasmInitialized) {
4258 throw new Error("initializeWasm() must be awaited first!");
4260 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_err(owner);
4261 return nativeResponseValue;
4263 // struct LDKCOption_NetworkUpdateZ CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
4265 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner: number): number {
4266 if(!isWasmInitialized) {
4267 throw new Error("initializeWasm() must be awaited first!");
4269 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner);
4270 return nativeResponseValue;
4272 // struct LDKDecodeError CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
4274 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner: number): number {
4275 if(!isWasmInitialized) {
4276 throw new Error("initializeWasm() must be awaited first!");
4278 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner);
4279 return nativeResponseValue;
4282 export interface LDKAccess {
4283 get_utxo (genesis_hash: number, short_channel_id: bigint): number;
4287 export function LDKAccess_new(impl: LDKAccess): number {
4288 if(!isWasmInitialized) {
4289 throw new Error("initializeWasm() must be awaited first!");
4291 var new_obj_idx = js_objs.length;
4292 for (var i = 0; i < js_objs.length; i++) {
4293 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4295 js_objs[i] = new WeakRef(impl);
4296 return wasm.TS_LDKAccess_new(i);
4298 // LDKCResult_TxOutAccessErrorZ Access_get_utxo LDKAccess *NONNULL_PTR this_arg, const uint8_t (*genesis_hash)[32], uint64_t short_channel_id
4300 export function Access_get_utxo(this_arg: number, genesis_hash: number, short_channel_id: bigint): number {
4301 if(!isWasmInitialized) {
4302 throw new Error("initializeWasm() must be awaited first!");
4304 const nativeResponseValue = wasm.TS_Access_get_utxo(this_arg, genesis_hash, short_channel_id);
4305 return nativeResponseValue;
4308 export class LDKCOption_AccessZ {
4309 protected constructor() {}
4312 export function LDKCOption_AccessZ_ty_from_ptr(ptr: number): number {
4313 if(!isWasmInitialized) {
4314 throw new Error("initializeWasm() must be awaited first!");
4316 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_ty_from_ptr(ptr);
4317 return nativeResponseValue;
4320 export function LDKCOption_AccessZ_Some_get_some(ptr: number): number {
4321 if(!isWasmInitialized) {
4322 throw new Error("initializeWasm() must be awaited first!");
4324 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_Some_get_some(ptr);
4325 return nativeResponseValue;
4327 // struct LDKChannelUpdateInfo CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
4329 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner: number): number {
4330 if(!isWasmInitialized) {
4331 throw new Error("initializeWasm() must be awaited first!");
4333 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner);
4334 return nativeResponseValue;
4336 // struct LDKDecodeError CResult_ChannelUpdateInfoDecodeErrorZ_get_err(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
4338 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner: number): number {
4339 if(!isWasmInitialized) {
4340 throw new Error("initializeWasm() must be awaited first!");
4342 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner);
4343 return nativeResponseValue;
4345 // struct LDKChannelInfo CResult_ChannelInfoDecodeErrorZ_get_ok(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
4347 export function CResult_ChannelInfoDecodeErrorZ_get_ok(owner: number): number {
4348 if(!isWasmInitialized) {
4349 throw new Error("initializeWasm() must be awaited first!");
4351 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_ok(owner);
4352 return nativeResponseValue;
4354 // struct LDKDecodeError CResult_ChannelInfoDecodeErrorZ_get_err(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
4356 export function CResult_ChannelInfoDecodeErrorZ_get_err(owner: number): number {
4357 if(!isWasmInitialized) {
4358 throw new Error("initializeWasm() must be awaited first!");
4360 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_err(owner);
4361 return nativeResponseValue;
4363 // struct LDKRoutingFees CResult_RoutingFeesDecodeErrorZ_get_ok(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
4365 export function CResult_RoutingFeesDecodeErrorZ_get_ok(owner: number): number {
4366 if(!isWasmInitialized) {
4367 throw new Error("initializeWasm() must be awaited first!");
4369 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_ok(owner);
4370 return nativeResponseValue;
4372 // struct LDKDecodeError CResult_RoutingFeesDecodeErrorZ_get_err(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
4374 export function CResult_RoutingFeesDecodeErrorZ_get_err(owner: number): number {
4375 if(!isWasmInitialized) {
4376 throw new Error("initializeWasm() must be awaited first!");
4378 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_err(owner);
4379 return nativeResponseValue;
4381 // struct LDKNodeAnnouncementInfo CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
4383 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner: number): number {
4384 if(!isWasmInitialized) {
4385 throw new Error("initializeWasm() must be awaited first!");
4387 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner);
4388 return nativeResponseValue;
4390 // struct LDKDecodeError CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
4392 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner: number): number {
4393 if(!isWasmInitialized) {
4394 throw new Error("initializeWasm() must be awaited first!");
4396 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner);
4397 return nativeResponseValue;
4399 // struct LDKNodeInfo CResult_NodeInfoDecodeErrorZ_get_ok(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
4401 export function CResult_NodeInfoDecodeErrorZ_get_ok(owner: number): number {
4402 if(!isWasmInitialized) {
4403 throw new Error("initializeWasm() must be awaited first!");
4405 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_ok(owner);
4406 return nativeResponseValue;
4408 // struct LDKDecodeError CResult_NodeInfoDecodeErrorZ_get_err(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
4410 export function CResult_NodeInfoDecodeErrorZ_get_err(owner: number): number {
4411 if(!isWasmInitialized) {
4412 throw new Error("initializeWasm() must be awaited first!");
4414 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_err(owner);
4415 return nativeResponseValue;
4417 // struct LDKNetworkGraph CResult_NetworkGraphDecodeErrorZ_get_ok(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
4419 export function CResult_NetworkGraphDecodeErrorZ_get_ok(owner: number): number {
4420 if(!isWasmInitialized) {
4421 throw new Error("initializeWasm() must be awaited first!");
4423 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_ok(owner);
4424 return nativeResponseValue;
4426 // struct LDKDecodeError CResult_NetworkGraphDecodeErrorZ_get_err(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
4428 export function CResult_NetworkGraphDecodeErrorZ_get_err(owner: number): number {
4429 if(!isWasmInitialized) {
4430 throw new Error("initializeWasm() must be awaited first!");
4432 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_err(owner);
4433 return nativeResponseValue;
4436 export class LDKCOption_CVec_NetAddressZZ {
4437 protected constructor() {}
4440 export function LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr: number): number {
4441 if(!isWasmInitialized) {
4442 throw new Error("initializeWasm() must be awaited first!");
4444 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr);
4445 return nativeResponseValue;
4448 export function LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr: number): number {
4449 if(!isWasmInitialized) {
4450 throw new Error("initializeWasm() must be awaited first!");
4452 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr);
4453 return nativeResponseValue;
4455 // struct LDKNetAddress CResult_NetAddressDecodeErrorZ_get_ok(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
4457 export function CResult_NetAddressDecodeErrorZ_get_ok(owner: number): number {
4458 if(!isWasmInitialized) {
4459 throw new Error("initializeWasm() must be awaited first!");
4461 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_ok(owner);
4462 return nativeResponseValue;
4464 // struct LDKDecodeError CResult_NetAddressDecodeErrorZ_get_err(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
4466 export function CResult_NetAddressDecodeErrorZ_get_err(owner: number): number {
4467 if(!isWasmInitialized) {
4468 throw new Error("initializeWasm() must be awaited first!");
4470 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_err(owner);
4471 return nativeResponseValue;
4473 // struct LDKAcceptChannel CResult_AcceptChannelDecodeErrorZ_get_ok(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
4475 export function CResult_AcceptChannelDecodeErrorZ_get_ok(owner: number): number {
4476 if(!isWasmInitialized) {
4477 throw new Error("initializeWasm() must be awaited first!");
4479 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_ok(owner);
4480 return nativeResponseValue;
4482 // struct LDKDecodeError CResult_AcceptChannelDecodeErrorZ_get_err(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
4484 export function CResult_AcceptChannelDecodeErrorZ_get_err(owner: number): number {
4485 if(!isWasmInitialized) {
4486 throw new Error("initializeWasm() must be awaited first!");
4488 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_err(owner);
4489 return nativeResponseValue;
4491 // struct LDKAnnouncementSignatures CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
4493 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner: number): number {
4494 if(!isWasmInitialized) {
4495 throw new Error("initializeWasm() must be awaited first!");
4497 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner);
4498 return nativeResponseValue;
4500 // struct LDKDecodeError CResult_AnnouncementSignaturesDecodeErrorZ_get_err(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
4502 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner: number): number {
4503 if(!isWasmInitialized) {
4504 throw new Error("initializeWasm() must be awaited first!");
4506 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner);
4507 return nativeResponseValue;
4509 // struct LDKChannelReestablish CResult_ChannelReestablishDecodeErrorZ_get_ok(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
4511 export function CResult_ChannelReestablishDecodeErrorZ_get_ok(owner: number): number {
4512 if(!isWasmInitialized) {
4513 throw new Error("initializeWasm() must be awaited first!");
4515 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_ok(owner);
4516 return nativeResponseValue;
4518 // struct LDKDecodeError CResult_ChannelReestablishDecodeErrorZ_get_err(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
4520 export function CResult_ChannelReestablishDecodeErrorZ_get_err(owner: number): number {
4521 if(!isWasmInitialized) {
4522 throw new Error("initializeWasm() must be awaited first!");
4524 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_err(owner);
4525 return nativeResponseValue;
4527 // struct LDKClosingSigned CResult_ClosingSignedDecodeErrorZ_get_ok(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
4529 export function CResult_ClosingSignedDecodeErrorZ_get_ok(owner: number): number {
4530 if(!isWasmInitialized) {
4531 throw new Error("initializeWasm() must be awaited first!");
4533 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_ok(owner);
4534 return nativeResponseValue;
4536 // struct LDKDecodeError CResult_ClosingSignedDecodeErrorZ_get_err(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
4538 export function CResult_ClosingSignedDecodeErrorZ_get_err(owner: number): number {
4539 if(!isWasmInitialized) {
4540 throw new Error("initializeWasm() must be awaited first!");
4542 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_err(owner);
4543 return nativeResponseValue;
4545 // struct LDKClosingSignedFeeRange CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
4547 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner: number): number {
4548 if(!isWasmInitialized) {
4549 throw new Error("initializeWasm() must be awaited first!");
4551 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner);
4552 return nativeResponseValue;
4554 // struct LDKDecodeError CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
4556 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner: number): number {
4557 if(!isWasmInitialized) {
4558 throw new Error("initializeWasm() must be awaited first!");
4560 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner);
4561 return nativeResponseValue;
4563 // struct LDKCommitmentSigned CResult_CommitmentSignedDecodeErrorZ_get_ok(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
4565 export function CResult_CommitmentSignedDecodeErrorZ_get_ok(owner: number): number {
4566 if(!isWasmInitialized) {
4567 throw new Error("initializeWasm() must be awaited first!");
4569 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_ok(owner);
4570 return nativeResponseValue;
4572 // struct LDKDecodeError CResult_CommitmentSignedDecodeErrorZ_get_err(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
4574 export function CResult_CommitmentSignedDecodeErrorZ_get_err(owner: number): number {
4575 if(!isWasmInitialized) {
4576 throw new Error("initializeWasm() must be awaited first!");
4578 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_err(owner);
4579 return nativeResponseValue;
4581 // struct LDKFundingCreated CResult_FundingCreatedDecodeErrorZ_get_ok(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
4583 export function CResult_FundingCreatedDecodeErrorZ_get_ok(owner: number): number {
4584 if(!isWasmInitialized) {
4585 throw new Error("initializeWasm() must be awaited first!");
4587 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_ok(owner);
4588 return nativeResponseValue;
4590 // struct LDKDecodeError CResult_FundingCreatedDecodeErrorZ_get_err(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
4592 export function CResult_FundingCreatedDecodeErrorZ_get_err(owner: number): number {
4593 if(!isWasmInitialized) {
4594 throw new Error("initializeWasm() must be awaited first!");
4596 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_err(owner);
4597 return nativeResponseValue;
4599 // struct LDKFundingSigned CResult_FundingSignedDecodeErrorZ_get_ok(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
4601 export function CResult_FundingSignedDecodeErrorZ_get_ok(owner: number): number {
4602 if(!isWasmInitialized) {
4603 throw new Error("initializeWasm() must be awaited first!");
4605 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_ok(owner);
4606 return nativeResponseValue;
4608 // struct LDKDecodeError CResult_FundingSignedDecodeErrorZ_get_err(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
4610 export function CResult_FundingSignedDecodeErrorZ_get_err(owner: number): number {
4611 if(!isWasmInitialized) {
4612 throw new Error("initializeWasm() must be awaited first!");
4614 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_err(owner);
4615 return nativeResponseValue;
4617 // struct LDKFundingLocked CResult_FundingLockedDecodeErrorZ_get_ok(LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR owner);
4619 export function CResult_FundingLockedDecodeErrorZ_get_ok(owner: number): number {
4620 if(!isWasmInitialized) {
4621 throw new Error("initializeWasm() must be awaited first!");
4623 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_get_ok(owner);
4624 return nativeResponseValue;
4626 // struct LDKDecodeError CResult_FundingLockedDecodeErrorZ_get_err(LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR owner);
4628 export function CResult_FundingLockedDecodeErrorZ_get_err(owner: number): number {
4629 if(!isWasmInitialized) {
4630 throw new Error("initializeWasm() must be awaited first!");
4632 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_get_err(owner);
4633 return nativeResponseValue;
4635 // struct LDKInit CResult_InitDecodeErrorZ_get_ok(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
4637 export function CResult_InitDecodeErrorZ_get_ok(owner: number): number {
4638 if(!isWasmInitialized) {
4639 throw new Error("initializeWasm() must be awaited first!");
4641 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_ok(owner);
4642 return nativeResponseValue;
4644 // struct LDKDecodeError CResult_InitDecodeErrorZ_get_err(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
4646 export function CResult_InitDecodeErrorZ_get_err(owner: number): number {
4647 if(!isWasmInitialized) {
4648 throw new Error("initializeWasm() must be awaited first!");
4650 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_err(owner);
4651 return nativeResponseValue;
4653 // struct LDKOpenChannel CResult_OpenChannelDecodeErrorZ_get_ok(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
4655 export function CResult_OpenChannelDecodeErrorZ_get_ok(owner: number): number {
4656 if(!isWasmInitialized) {
4657 throw new Error("initializeWasm() must be awaited first!");
4659 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_ok(owner);
4660 return nativeResponseValue;
4662 // struct LDKDecodeError CResult_OpenChannelDecodeErrorZ_get_err(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
4664 export function CResult_OpenChannelDecodeErrorZ_get_err(owner: number): number {
4665 if(!isWasmInitialized) {
4666 throw new Error("initializeWasm() must be awaited first!");
4668 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_err(owner);
4669 return nativeResponseValue;
4671 // struct LDKRevokeAndACK CResult_RevokeAndACKDecodeErrorZ_get_ok(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
4673 export function CResult_RevokeAndACKDecodeErrorZ_get_ok(owner: number): number {
4674 if(!isWasmInitialized) {
4675 throw new Error("initializeWasm() must be awaited first!");
4677 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_ok(owner);
4678 return nativeResponseValue;
4680 // struct LDKDecodeError CResult_RevokeAndACKDecodeErrorZ_get_err(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
4682 export function CResult_RevokeAndACKDecodeErrorZ_get_err(owner: number): number {
4683 if(!isWasmInitialized) {
4684 throw new Error("initializeWasm() must be awaited first!");
4686 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_err(owner);
4687 return nativeResponseValue;
4689 // struct LDKShutdown CResult_ShutdownDecodeErrorZ_get_ok(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
4691 export function CResult_ShutdownDecodeErrorZ_get_ok(owner: number): number {
4692 if(!isWasmInitialized) {
4693 throw new Error("initializeWasm() must be awaited first!");
4695 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_ok(owner);
4696 return nativeResponseValue;
4698 // struct LDKDecodeError CResult_ShutdownDecodeErrorZ_get_err(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
4700 export function CResult_ShutdownDecodeErrorZ_get_err(owner: number): number {
4701 if(!isWasmInitialized) {
4702 throw new Error("initializeWasm() must be awaited first!");
4704 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_err(owner);
4705 return nativeResponseValue;
4707 // struct LDKUpdateFailHTLC CResult_UpdateFailHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
4709 export function CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner: number): number {
4710 if(!isWasmInitialized) {
4711 throw new Error("initializeWasm() must be awaited first!");
4713 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner);
4714 return nativeResponseValue;
4716 // struct LDKDecodeError CResult_UpdateFailHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
4718 export function CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner: number): number {
4719 if(!isWasmInitialized) {
4720 throw new Error("initializeWasm() must be awaited first!");
4722 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner);
4723 return nativeResponseValue;
4725 // struct LDKUpdateFailMalformedHTLC CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
4727 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner: number): number {
4728 if(!isWasmInitialized) {
4729 throw new Error("initializeWasm() must be awaited first!");
4731 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner);
4732 return nativeResponseValue;
4734 // struct LDKDecodeError CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
4736 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner: number): number {
4737 if(!isWasmInitialized) {
4738 throw new Error("initializeWasm() must be awaited first!");
4740 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner);
4741 return nativeResponseValue;
4743 // struct LDKUpdateFee CResult_UpdateFeeDecodeErrorZ_get_ok(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
4745 export function CResult_UpdateFeeDecodeErrorZ_get_ok(owner: number): number {
4746 if(!isWasmInitialized) {
4747 throw new Error("initializeWasm() must be awaited first!");
4749 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_ok(owner);
4750 return nativeResponseValue;
4752 // struct LDKDecodeError CResult_UpdateFeeDecodeErrorZ_get_err(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
4754 export function CResult_UpdateFeeDecodeErrorZ_get_err(owner: number): number {
4755 if(!isWasmInitialized) {
4756 throw new Error("initializeWasm() must be awaited first!");
4758 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_err(owner);
4759 return nativeResponseValue;
4761 // struct LDKUpdateFulfillHTLC CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
4763 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner: number): number {
4764 if(!isWasmInitialized) {
4765 throw new Error("initializeWasm() must be awaited first!");
4767 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner);
4768 return nativeResponseValue;
4770 // struct LDKDecodeError CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
4772 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner: number): number {
4773 if(!isWasmInitialized) {
4774 throw new Error("initializeWasm() must be awaited first!");
4776 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner);
4777 return nativeResponseValue;
4779 // struct LDKUpdateAddHTLC CResult_UpdateAddHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
4781 export function CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner: number): number {
4782 if(!isWasmInitialized) {
4783 throw new Error("initializeWasm() must be awaited first!");
4785 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner);
4786 return nativeResponseValue;
4788 // struct LDKDecodeError CResult_UpdateAddHTLCDecodeErrorZ_get_err(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
4790 export function CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner: number): number {
4791 if(!isWasmInitialized) {
4792 throw new Error("initializeWasm() must be awaited first!");
4794 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner);
4795 return nativeResponseValue;
4797 // struct LDKPing CResult_PingDecodeErrorZ_get_ok(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
4799 export function CResult_PingDecodeErrorZ_get_ok(owner: number): number {
4800 if(!isWasmInitialized) {
4801 throw new Error("initializeWasm() must be awaited first!");
4803 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_ok(owner);
4804 return nativeResponseValue;
4806 // struct LDKDecodeError CResult_PingDecodeErrorZ_get_err(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
4808 export function CResult_PingDecodeErrorZ_get_err(owner: number): number {
4809 if(!isWasmInitialized) {
4810 throw new Error("initializeWasm() must be awaited first!");
4812 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_err(owner);
4813 return nativeResponseValue;
4815 // struct LDKPong CResult_PongDecodeErrorZ_get_ok(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
4817 export function CResult_PongDecodeErrorZ_get_ok(owner: number): number {
4818 if(!isWasmInitialized) {
4819 throw new Error("initializeWasm() must be awaited first!");
4821 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_ok(owner);
4822 return nativeResponseValue;
4824 // struct LDKDecodeError CResult_PongDecodeErrorZ_get_err(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
4826 export function CResult_PongDecodeErrorZ_get_err(owner: number): number {
4827 if(!isWasmInitialized) {
4828 throw new Error("initializeWasm() must be awaited first!");
4830 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_err(owner);
4831 return nativeResponseValue;
4833 // struct LDKUnsignedChannelAnnouncement CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
4835 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner: number): number {
4836 if(!isWasmInitialized) {
4837 throw new Error("initializeWasm() must be awaited first!");
4839 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner);
4840 return nativeResponseValue;
4842 // struct LDKDecodeError CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
4844 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner: number): number {
4845 if(!isWasmInitialized) {
4846 throw new Error("initializeWasm() must be awaited first!");
4848 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner);
4849 return nativeResponseValue;
4851 // struct LDKChannelAnnouncement CResult_ChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
4853 export function CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner: number): number {
4854 if(!isWasmInitialized) {
4855 throw new Error("initializeWasm() must be awaited first!");
4857 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner);
4858 return nativeResponseValue;
4860 // struct LDKDecodeError CResult_ChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
4862 export function CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner: number): number {
4863 if(!isWasmInitialized) {
4864 throw new Error("initializeWasm() must be awaited first!");
4866 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner);
4867 return nativeResponseValue;
4869 // struct LDKUnsignedChannelUpdate CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
4871 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner: number): number {
4872 if(!isWasmInitialized) {
4873 throw new Error("initializeWasm() must be awaited first!");
4875 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner);
4876 return nativeResponseValue;
4878 // struct LDKDecodeError CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
4880 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner: number): number {
4881 if(!isWasmInitialized) {
4882 throw new Error("initializeWasm() must be awaited first!");
4884 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner);
4885 return nativeResponseValue;
4887 // struct LDKChannelUpdate CResult_ChannelUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
4889 export function CResult_ChannelUpdateDecodeErrorZ_get_ok(owner: number): number {
4890 if(!isWasmInitialized) {
4891 throw new Error("initializeWasm() must be awaited first!");
4893 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_ok(owner);
4894 return nativeResponseValue;
4896 // struct LDKDecodeError CResult_ChannelUpdateDecodeErrorZ_get_err(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
4898 export function CResult_ChannelUpdateDecodeErrorZ_get_err(owner: number): number {
4899 if(!isWasmInitialized) {
4900 throw new Error("initializeWasm() must be awaited first!");
4902 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_err(owner);
4903 return nativeResponseValue;
4905 // struct LDKErrorMessage CResult_ErrorMessageDecodeErrorZ_get_ok(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
4907 export function CResult_ErrorMessageDecodeErrorZ_get_ok(owner: number): number {
4908 if(!isWasmInitialized) {
4909 throw new Error("initializeWasm() must be awaited first!");
4911 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_ok(owner);
4912 return nativeResponseValue;
4914 // struct LDKDecodeError CResult_ErrorMessageDecodeErrorZ_get_err(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
4916 export function CResult_ErrorMessageDecodeErrorZ_get_err(owner: number): number {
4917 if(!isWasmInitialized) {
4918 throw new Error("initializeWasm() must be awaited first!");
4920 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_err(owner);
4921 return nativeResponseValue;
4923 // struct LDKWarningMessage CResult_WarningMessageDecodeErrorZ_get_ok(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
4925 export function CResult_WarningMessageDecodeErrorZ_get_ok(owner: number): number {
4926 if(!isWasmInitialized) {
4927 throw new Error("initializeWasm() must be awaited first!");
4929 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_ok(owner);
4930 return nativeResponseValue;
4932 // struct LDKDecodeError CResult_WarningMessageDecodeErrorZ_get_err(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
4934 export function CResult_WarningMessageDecodeErrorZ_get_err(owner: number): number {
4935 if(!isWasmInitialized) {
4936 throw new Error("initializeWasm() must be awaited first!");
4938 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_err(owner);
4939 return nativeResponseValue;
4941 // struct LDKUnsignedNodeAnnouncement CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
4943 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner: number): number {
4944 if(!isWasmInitialized) {
4945 throw new Error("initializeWasm() must be awaited first!");
4947 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner);
4948 return nativeResponseValue;
4950 // struct LDKDecodeError CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
4952 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner: number): number {
4953 if(!isWasmInitialized) {
4954 throw new Error("initializeWasm() must be awaited first!");
4956 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner);
4957 return nativeResponseValue;
4959 // struct LDKNodeAnnouncement CResult_NodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
4961 export function CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner: number): number {
4962 if(!isWasmInitialized) {
4963 throw new Error("initializeWasm() must be awaited first!");
4965 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner);
4966 return nativeResponseValue;
4968 // struct LDKDecodeError CResult_NodeAnnouncementDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
4970 export function CResult_NodeAnnouncementDecodeErrorZ_get_err(owner: number): number {
4971 if(!isWasmInitialized) {
4972 throw new Error("initializeWasm() must be awaited first!");
4974 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_err(owner);
4975 return nativeResponseValue;
4977 // struct LDKQueryShortChannelIds CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
4979 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner: number): number {
4980 if(!isWasmInitialized) {
4981 throw new Error("initializeWasm() must be awaited first!");
4983 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner);
4984 return nativeResponseValue;
4986 // struct LDKDecodeError CResult_QueryShortChannelIdsDecodeErrorZ_get_err(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
4988 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner: number): number {
4989 if(!isWasmInitialized) {
4990 throw new Error("initializeWasm() must be awaited first!");
4992 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner);
4993 return nativeResponseValue;
4995 // struct LDKReplyShortChannelIdsEnd CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
4997 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner: number): number {
4998 if(!isWasmInitialized) {
4999 throw new Error("initializeWasm() must be awaited first!");
5001 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner);
5002 return nativeResponseValue;
5004 // struct LDKDecodeError CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
5006 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner: number): number {
5007 if(!isWasmInitialized) {
5008 throw new Error("initializeWasm() must be awaited first!");
5010 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner);
5011 return nativeResponseValue;
5013 // struct LDKQueryChannelRange CResult_QueryChannelRangeDecodeErrorZ_get_ok(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5015 export function CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner: number): number {
5016 if(!isWasmInitialized) {
5017 throw new Error("initializeWasm() must be awaited first!");
5019 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner);
5020 return nativeResponseValue;
5022 // struct LDKDecodeError CResult_QueryChannelRangeDecodeErrorZ_get_err(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5024 export function CResult_QueryChannelRangeDecodeErrorZ_get_err(owner: number): number {
5025 if(!isWasmInitialized) {
5026 throw new Error("initializeWasm() must be awaited first!");
5028 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_err(owner);
5029 return nativeResponseValue;
5031 // struct LDKReplyChannelRange CResult_ReplyChannelRangeDecodeErrorZ_get_ok(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5033 export function CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner: number): number {
5034 if(!isWasmInitialized) {
5035 throw new Error("initializeWasm() must be awaited first!");
5037 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner);
5038 return nativeResponseValue;
5040 // struct LDKDecodeError CResult_ReplyChannelRangeDecodeErrorZ_get_err(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5042 export function CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner: number): number {
5043 if(!isWasmInitialized) {
5044 throw new Error("initializeWasm() must be awaited first!");
5046 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner);
5047 return nativeResponseValue;
5049 // struct LDKGossipTimestampFilter CResult_GossipTimestampFilterDecodeErrorZ_get_ok(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
5051 export function CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner: number): number {
5052 if(!isWasmInitialized) {
5053 throw new Error("initializeWasm() must be awaited first!");
5055 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner);
5056 return nativeResponseValue;
5058 // struct LDKDecodeError CResult_GossipTimestampFilterDecodeErrorZ_get_err(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
5060 export function CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner: number): number {
5061 if(!isWasmInitialized) {
5062 throw new Error("initializeWasm() must be awaited first!");
5064 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner);
5065 return nativeResponseValue;
5068 export class LDKSignOrCreationError {
5069 protected constructor() {}
5072 export function LDKSignOrCreationError_ty_from_ptr(ptr: number): number {
5073 if(!isWasmInitialized) {
5074 throw new Error("initializeWasm() must be awaited first!");
5076 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_ty_from_ptr(ptr);
5077 return nativeResponseValue;
5080 export function LDKSignOrCreationError_CreationError_get_creation_error(ptr: number): CreationError {
5081 if(!isWasmInitialized) {
5082 throw new Error("initializeWasm() must be awaited first!");
5084 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_CreationError_get_creation_error(ptr);
5085 return nativeResponseValue;
5087 // struct LDKInvoice CResult_InvoiceSignOrCreationErrorZ_get_ok(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
5089 export function CResult_InvoiceSignOrCreationErrorZ_get_ok(owner: number): number {
5090 if(!isWasmInitialized) {
5091 throw new Error("initializeWasm() must be awaited first!");
5093 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_ok(owner);
5094 return nativeResponseValue;
5096 // struct LDKSignOrCreationError CResult_InvoiceSignOrCreationErrorZ_get_err(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
5098 export function CResult_InvoiceSignOrCreationErrorZ_get_err(owner: number): number {
5099 if(!isWasmInitialized) {
5100 throw new Error("initializeWasm() must be awaited first!");
5102 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_err(owner);
5103 return nativeResponseValue;
5106 export interface LDKFilter {
5107 register_tx (txid: number, script_pubkey: number): void;
5108 register_output (output: number): number;
5112 export function LDKFilter_new(impl: LDKFilter): number {
5113 if(!isWasmInitialized) {
5114 throw new Error("initializeWasm() must be awaited first!");
5116 var new_obj_idx = js_objs.length;
5117 for (var i = 0; i < js_objs.length; i++) {
5118 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5120 js_objs[i] = new WeakRef(impl);
5121 return wasm.TS_LDKFilter_new(i);
5123 // void Filter_register_tx LDKFilter *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
5125 export function Filter_register_tx(this_arg: number, txid: number, script_pubkey: number): void {
5126 if(!isWasmInitialized) {
5127 throw new Error("initializeWasm() must be awaited first!");
5129 const nativeResponseValue = wasm.TS_Filter_register_tx(this_arg, txid, script_pubkey);
5130 // debug statements here
5132 // LDKCOption_C2Tuple_usizeTransactionZZ Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
5134 export function Filter_register_output(this_arg: number, output: number): number {
5135 if(!isWasmInitialized) {
5136 throw new Error("initializeWasm() must be awaited first!");
5138 const nativeResponseValue = wasm.TS_Filter_register_output(this_arg, output);
5139 return nativeResponseValue;
5142 export class LDKCOption_FilterZ {
5143 protected constructor() {}
5146 export function LDKCOption_FilterZ_ty_from_ptr(ptr: number): number {
5147 if(!isWasmInitialized) {
5148 throw new Error("initializeWasm() must be awaited first!");
5150 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_ty_from_ptr(ptr);
5151 return nativeResponseValue;
5154 export function LDKCOption_FilterZ_Some_get_some(ptr: number): number {
5155 if(!isWasmInitialized) {
5156 throw new Error("initializeWasm() must be awaited first!");
5158 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_Some_get_some(ptr);
5159 return nativeResponseValue;
5161 // struct LDKLockedChannelMonitor *CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
5163 export function CResult_LockedChannelMonitorNoneZ_get_ok(owner: number): number {
5164 if(!isWasmInitialized) {
5165 throw new Error("initializeWasm() must be awaited first!");
5167 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_ok(owner);
5168 return nativeResponseValue;
5170 // void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
5172 export function CResult_LockedChannelMonitorNoneZ_get_err(owner: number): void {
5173 if(!isWasmInitialized) {
5174 throw new Error("initializeWasm() must be awaited first!");
5176 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_err(owner);
5177 // debug statements here
5180 export interface LDKMessageSendEventsProvider {
5181 get_and_clear_pending_msg_events (): number;
5185 export function LDKMessageSendEventsProvider_new(impl: LDKMessageSendEventsProvider): number {
5186 if(!isWasmInitialized) {
5187 throw new Error("initializeWasm() must be awaited first!");
5189 var new_obj_idx = js_objs.length;
5190 for (var i = 0; i < js_objs.length; i++) {
5191 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5193 js_objs[i] = new WeakRef(impl);
5194 return wasm.TS_LDKMessageSendEventsProvider_new(i);
5196 // LDKCVec_MessageSendEventZ MessageSendEventsProvider_get_and_clear_pending_msg_events LDKMessageSendEventsProvider *NONNULL_PTR this_arg
5198 export function MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg: number): number {
5199 if(!isWasmInitialized) {
5200 throw new Error("initializeWasm() must be awaited first!");
5202 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg);
5203 return nativeResponseValue;
5206 export interface LDKEventHandler {
5207 handle_event (event: number): void;
5211 export function LDKEventHandler_new(impl: LDKEventHandler): number {
5212 if(!isWasmInitialized) {
5213 throw new Error("initializeWasm() must be awaited first!");
5215 var new_obj_idx = js_objs.length;
5216 for (var i = 0; i < js_objs.length; i++) {
5217 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5219 js_objs[i] = new WeakRef(impl);
5220 return wasm.TS_LDKEventHandler_new(i);
5222 // void EventHandler_handle_event LDKEventHandler *NONNULL_PTR this_arg, const struct LDKEvent *NONNULL_PTR event
5224 export function EventHandler_handle_event(this_arg: number, event: number): void {
5225 if(!isWasmInitialized) {
5226 throw new Error("initializeWasm() must be awaited first!");
5228 const nativeResponseValue = wasm.TS_EventHandler_handle_event(this_arg, event);
5229 // debug statements here
5232 export interface LDKEventsProvider {
5233 process_pending_events (handler: number): void;
5237 export function LDKEventsProvider_new(impl: LDKEventsProvider): number {
5238 if(!isWasmInitialized) {
5239 throw new Error("initializeWasm() must be awaited first!");
5241 var new_obj_idx = js_objs.length;
5242 for (var i = 0; i < js_objs.length; i++) {
5243 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5245 js_objs[i] = new WeakRef(impl);
5246 return wasm.TS_LDKEventsProvider_new(i);
5248 // void EventsProvider_process_pending_events LDKEventsProvider *NONNULL_PTR this_arg, struct LDKEventHandler handler
5250 export function EventsProvider_process_pending_events(this_arg: number, handler: number): void {
5251 if(!isWasmInitialized) {
5252 throw new Error("initializeWasm() must be awaited first!");
5254 const nativeResponseValue = wasm.TS_EventsProvider_process_pending_events(this_arg, handler);
5255 // debug statements here
5258 export interface LDKListen {
5259 block_connected (block: number, height: number): void;
5260 block_disconnected (header: number, height: number): void;
5264 export function LDKListen_new(impl: LDKListen): 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_LDKListen_new(i);
5275 // void Listen_block_connected LDKListen *NONNULL_PTR this_arg, struct LDKu8slice block, uint32_t height
5277 export function Listen_block_connected(this_arg: number, block: number, height: number): void {
5278 if(!isWasmInitialized) {
5279 throw new Error("initializeWasm() must be awaited first!");
5281 const nativeResponseValue = wasm.TS_Listen_block_connected(this_arg, block, height);
5282 // debug statements here
5284 // void Listen_block_disconnected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
5286 export function Listen_block_disconnected(this_arg: number, header: number, height: number): void {
5287 if(!isWasmInitialized) {
5288 throw new Error("initializeWasm() must be awaited first!");
5290 const nativeResponseValue = wasm.TS_Listen_block_disconnected(this_arg, header, height);
5291 // debug statements here
5294 export interface LDKConfirm {
5295 transactions_confirmed (header: number, txdata: number, height: number): void;
5296 transaction_unconfirmed (txid: number): void;
5297 best_block_updated (header: number, height: number): void;
5298 get_relevant_txids (): number;
5302 export function LDKConfirm_new(impl: LDKConfirm): number {
5303 if(!isWasmInitialized) {
5304 throw new Error("initializeWasm() must be awaited first!");
5306 var new_obj_idx = js_objs.length;
5307 for (var i = 0; i < js_objs.length; i++) {
5308 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5310 js_objs[i] = new WeakRef(impl);
5311 return wasm.TS_LDKConfirm_new(i);
5313 // void Confirm_transactions_confirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
5315 export function Confirm_transactions_confirmed(this_arg: number, header: number, txdata: number, height: number): void {
5316 if(!isWasmInitialized) {
5317 throw new Error("initializeWasm() must be awaited first!");
5319 const nativeResponseValue = wasm.TS_Confirm_transactions_confirmed(this_arg, header, txdata, height);
5320 // debug statements here
5322 // void Confirm_transaction_unconfirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*txid)[32]
5324 export function Confirm_transaction_unconfirmed(this_arg: number, txid: number): void {
5325 if(!isWasmInitialized) {
5326 throw new Error("initializeWasm() must be awaited first!");
5328 const nativeResponseValue = wasm.TS_Confirm_transaction_unconfirmed(this_arg, txid);
5329 // debug statements here
5331 // void Confirm_best_block_updated LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
5333 export function Confirm_best_block_updated(this_arg: number, header: number, height: number): void {
5334 if(!isWasmInitialized) {
5335 throw new Error("initializeWasm() must be awaited first!");
5337 const nativeResponseValue = wasm.TS_Confirm_best_block_updated(this_arg, header, height);
5338 // debug statements here
5340 // LDKCVec_TxidZ Confirm_get_relevant_txids LDKConfirm *NONNULL_PTR this_arg
5342 export function Confirm_get_relevant_txids(this_arg: number): number {
5343 if(!isWasmInitialized) {
5344 throw new Error("initializeWasm() must be awaited first!");
5346 const nativeResponseValue = wasm.TS_Confirm_get_relevant_txids(this_arg);
5347 return nativeResponseValue;
5350 export interface LDKPersist {
5351 persist_new_channel (channel_id: number, data: number, update_id: number): number;
5352 update_persisted_channel (channel_id: number, update: number, data: number, update_id: number): number;
5356 export function LDKPersist_new(impl: LDKPersist): number {
5357 if(!isWasmInitialized) {
5358 throw new Error("initializeWasm() must be awaited first!");
5360 var new_obj_idx = js_objs.length;
5361 for (var i = 0; i < js_objs.length; i++) {
5362 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5364 js_objs[i] = new WeakRef(impl);
5365 return wasm.TS_LDKPersist_new(i);
5367 // 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
5369 export function Persist_persist_new_channel(this_arg: number, channel_id: number, data: number, update_id: number): number {
5370 if(!isWasmInitialized) {
5371 throw new Error("initializeWasm() must be awaited first!");
5373 const nativeResponseValue = wasm.TS_Persist_persist_new_channel(this_arg, channel_id, data, update_id);
5374 return nativeResponseValue;
5376 // 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
5378 export function Persist_update_persisted_channel(this_arg: number, channel_id: number, update: number, data: number, update_id: number): number {
5379 if(!isWasmInitialized) {
5380 throw new Error("initializeWasm() must be awaited first!");
5382 const nativeResponseValue = wasm.TS_Persist_update_persisted_channel(this_arg, channel_id, update, data, update_id);
5383 return nativeResponseValue;
5386 export interface LDKChannelMessageHandler {
5387 handle_open_channel (their_node_id: number, their_features: number, msg: number): void;
5388 handle_accept_channel (their_node_id: number, their_features: number, msg: number): void;
5389 handle_funding_created (their_node_id: number, msg: number): void;
5390 handle_funding_signed (their_node_id: number, msg: number): void;
5391 handle_funding_locked (their_node_id: number, msg: number): void;
5392 handle_shutdown (their_node_id: number, their_features: number, msg: number): void;
5393 handle_closing_signed (their_node_id: number, msg: number): void;
5394 handle_update_add_htlc (their_node_id: number, msg: number): void;
5395 handle_update_fulfill_htlc (their_node_id: number, msg: number): void;
5396 handle_update_fail_htlc (their_node_id: number, msg: number): void;
5397 handle_update_fail_malformed_htlc (their_node_id: number, msg: number): void;
5398 handle_commitment_signed (their_node_id: number, msg: number): void;
5399 handle_revoke_and_ack (their_node_id: number, msg: number): void;
5400 handle_update_fee (their_node_id: number, msg: number): void;
5401 handle_announcement_signatures (their_node_id: number, msg: number): void;
5402 peer_disconnected (their_node_id: number, no_connection_possible: boolean): void;
5403 peer_connected (their_node_id: number, msg: number): void;
5404 handle_channel_reestablish (their_node_id: number, msg: number): void;
5405 handle_channel_update (their_node_id: number, msg: number): void;
5406 handle_error (their_node_id: number, msg: number): void;
5410 export function LDKChannelMessageHandler_new(impl: LDKChannelMessageHandler, MessageSendEventsProvider: LDKMessageSendEventsProvider): number {
5411 if(!isWasmInitialized) {
5412 throw new Error("initializeWasm() must be awaited first!");
5414 var new_obj_idx = js_objs.length;
5415 for (var i = 0; i < js_objs.length; i++) {
5416 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5418 js_objs[i] = new WeakRef(impl);
5419 return wasm.TS_LDKChannelMessageHandler_new(i);
5421 // 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
5423 export function ChannelMessageHandler_handle_open_channel(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
5424 if(!isWasmInitialized) {
5425 throw new Error("initializeWasm() must be awaited first!");
5427 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_open_channel(this_arg, their_node_id, their_features, msg);
5428 // debug statements here
5430 // 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
5432 export function ChannelMessageHandler_handle_accept_channel(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
5433 if(!isWasmInitialized) {
5434 throw new Error("initializeWasm() must be awaited first!");
5436 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_accept_channel(this_arg, their_node_id, their_features, msg);
5437 // debug statements here
5439 // void ChannelMessageHandler_handle_funding_created LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg
5441 export function ChannelMessageHandler_handle_funding_created(this_arg: number, their_node_id: number, msg: number): void {
5442 if(!isWasmInitialized) {
5443 throw new Error("initializeWasm() must be awaited first!");
5445 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_created(this_arg, their_node_id, msg);
5446 // debug statements here
5448 // void ChannelMessageHandler_handle_funding_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg
5450 export function ChannelMessageHandler_handle_funding_signed(this_arg: number, their_node_id: number, msg: number): void {
5451 if(!isWasmInitialized) {
5452 throw new Error("initializeWasm() must be awaited first!");
5454 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_signed(this_arg, their_node_id, msg);
5455 // debug statements here
5457 // void ChannelMessageHandler_handle_funding_locked LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingLocked *NONNULL_PTR msg
5459 export function ChannelMessageHandler_handle_funding_locked(this_arg: number, their_node_id: number, msg: number): void {
5460 if(!isWasmInitialized) {
5461 throw new Error("initializeWasm() must be awaited first!");
5463 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_locked(this_arg, their_node_id, msg);
5464 // debug statements here
5466 // 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
5468 export function ChannelMessageHandler_handle_shutdown(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
5469 if(!isWasmInitialized) {
5470 throw new Error("initializeWasm() must be awaited first!");
5472 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_shutdown(this_arg, their_node_id, their_features, msg);
5473 // debug statements here
5475 // void ChannelMessageHandler_handle_closing_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg
5477 export function ChannelMessageHandler_handle_closing_signed(this_arg: number, their_node_id: number, msg: number): void {
5478 if(!isWasmInitialized) {
5479 throw new Error("initializeWasm() must be awaited first!");
5481 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_closing_signed(this_arg, their_node_id, msg);
5482 // debug statements here
5484 // void ChannelMessageHandler_handle_update_add_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg
5486 export function ChannelMessageHandler_handle_update_add_htlc(this_arg: number, their_node_id: number, msg: number): void {
5487 if(!isWasmInitialized) {
5488 throw new Error("initializeWasm() must be awaited first!");
5490 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_add_htlc(this_arg, their_node_id, msg);
5491 // debug statements here
5493 // void ChannelMessageHandler_handle_update_fulfill_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg
5495 export function ChannelMessageHandler_handle_update_fulfill_htlc(this_arg: number, their_node_id: number, msg: number): void {
5496 if(!isWasmInitialized) {
5497 throw new Error("initializeWasm() must be awaited first!");
5499 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fulfill_htlc(this_arg, their_node_id, msg);
5500 // debug statements here
5502 // void ChannelMessageHandler_handle_update_fail_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg
5504 export function ChannelMessageHandler_handle_update_fail_htlc(this_arg: number, their_node_id: number, msg: number): void {
5505 if(!isWasmInitialized) {
5506 throw new Error("initializeWasm() must be awaited first!");
5508 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_htlc(this_arg, their_node_id, msg);
5509 // debug statements here
5511 // void ChannelMessageHandler_handle_update_fail_malformed_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg
5513 export function ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg: number, their_node_id: number, msg: number): void {
5514 if(!isWasmInitialized) {
5515 throw new Error("initializeWasm() must be awaited first!");
5517 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg, their_node_id, msg);
5518 // debug statements here
5520 // void ChannelMessageHandler_handle_commitment_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg
5522 export function ChannelMessageHandler_handle_commitment_signed(this_arg: number, their_node_id: number, msg: number): void {
5523 if(!isWasmInitialized) {
5524 throw new Error("initializeWasm() must be awaited first!");
5526 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_commitment_signed(this_arg, their_node_id, msg);
5527 // debug statements here
5529 // void ChannelMessageHandler_handle_revoke_and_ack LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg
5531 export function ChannelMessageHandler_handle_revoke_and_ack(this_arg: number, their_node_id: number, msg: number): void {
5532 if(!isWasmInitialized) {
5533 throw new Error("initializeWasm() must be awaited first!");
5535 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_revoke_and_ack(this_arg, their_node_id, msg);
5536 // debug statements here
5538 // void ChannelMessageHandler_handle_update_fee LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg
5540 export function ChannelMessageHandler_handle_update_fee(this_arg: number, their_node_id: number, msg: number): void {
5541 if(!isWasmInitialized) {
5542 throw new Error("initializeWasm() must be awaited first!");
5544 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fee(this_arg, their_node_id, msg);
5545 // debug statements here
5547 // void ChannelMessageHandler_handle_announcement_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg
5549 export function ChannelMessageHandler_handle_announcement_signatures(this_arg: number, their_node_id: number, msg: number): void {
5550 if(!isWasmInitialized) {
5551 throw new Error("initializeWasm() must be awaited first!");
5553 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_announcement_signatures(this_arg, their_node_id, msg);
5554 // debug statements here
5556 // void ChannelMessageHandler_peer_disconnected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, bool no_connection_possible
5558 export function ChannelMessageHandler_peer_disconnected(this_arg: number, their_node_id: number, no_connection_possible: boolean): void {
5559 if(!isWasmInitialized) {
5560 throw new Error("initializeWasm() must be awaited first!");
5562 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_disconnected(this_arg, their_node_id, no_connection_possible);
5563 // debug statements here
5565 // void ChannelMessageHandler_peer_connected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg
5567 export function ChannelMessageHandler_peer_connected(this_arg: number, their_node_id: number, msg: number): void {
5568 if(!isWasmInitialized) {
5569 throw new Error("initializeWasm() must be awaited first!");
5571 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_connected(this_arg, their_node_id, msg);
5572 // debug statements here
5574 // void ChannelMessageHandler_handle_channel_reestablish LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg
5576 export function ChannelMessageHandler_handle_channel_reestablish(this_arg: number, their_node_id: number, msg: number): void {
5577 if(!isWasmInitialized) {
5578 throw new Error("initializeWasm() must be awaited first!");
5580 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_reestablish(this_arg, their_node_id, msg);
5581 // debug statements here
5583 // void ChannelMessageHandler_handle_channel_update LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg
5585 export function ChannelMessageHandler_handle_channel_update(this_arg: number, their_node_id: number, msg: number): void {
5586 if(!isWasmInitialized) {
5587 throw new Error("initializeWasm() must be awaited first!");
5589 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_update(this_arg, their_node_id, msg);
5590 // debug statements here
5592 // void ChannelMessageHandler_handle_error LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
5594 export function ChannelMessageHandler_handle_error(this_arg: number, their_node_id: number, msg: number): void {
5595 if(!isWasmInitialized) {
5596 throw new Error("initializeWasm() must be awaited first!");
5598 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_error(this_arg, their_node_id, msg);
5599 // debug statements here
5602 export interface LDKRoutingMessageHandler {
5603 handle_node_announcement (msg: number): number;
5604 handle_channel_announcement (msg: number): number;
5605 handle_channel_update (msg: number): number;
5606 get_next_channel_announcements (starting_point: bigint, batch_amount: number): number;
5607 get_next_node_announcements (starting_point: number, batch_amount: number): number;
5608 sync_routing_table (their_node_id: number, init: number): void;
5609 handle_reply_channel_range (their_node_id: number, msg: number): number;
5610 handle_reply_short_channel_ids_end (their_node_id: number, msg: number): number;
5611 handle_query_channel_range (their_node_id: number, msg: number): number;
5612 handle_query_short_channel_ids (their_node_id: number, msg: number): number;
5616 export function LDKRoutingMessageHandler_new(impl: LDKRoutingMessageHandler, MessageSendEventsProvider: LDKMessageSendEventsProvider): number {
5617 if(!isWasmInitialized) {
5618 throw new Error("initializeWasm() must be awaited first!");
5620 var new_obj_idx = js_objs.length;
5621 for (var i = 0; i < js_objs.length; i++) {
5622 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5624 js_objs[i] = new WeakRef(impl);
5625 return wasm.TS_LDKRoutingMessageHandler_new(i);
5627 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg
5629 export function RoutingMessageHandler_handle_node_announcement(this_arg: number, msg: number): number {
5630 if(!isWasmInitialized) {
5631 throw new Error("initializeWasm() must be awaited first!");
5633 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_node_announcement(this_arg, msg);
5634 return nativeResponseValue;
5636 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg
5638 export function RoutingMessageHandler_handle_channel_announcement(this_arg: number, msg: number): number {
5639 if(!isWasmInitialized) {
5640 throw new Error("initializeWasm() must be awaited first!");
5642 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_announcement(this_arg, msg);
5643 return nativeResponseValue;
5645 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_update LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg
5647 export function RoutingMessageHandler_handle_channel_update(this_arg: number, msg: number): number {
5648 if(!isWasmInitialized) {
5649 throw new Error("initializeWasm() must be awaited first!");
5651 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_update(this_arg, msg);
5652 return nativeResponseValue;
5654 // LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler_get_next_channel_announcements LDKRoutingMessageHandler *NONNULL_PTR this_arg, uint64_t starting_point, uint8_t batch_amount
5656 export function RoutingMessageHandler_get_next_channel_announcements(this_arg: number, starting_point: bigint, batch_amount: number): number {
5657 if(!isWasmInitialized) {
5658 throw new Error("initializeWasm() must be awaited first!");
5660 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_channel_announcements(this_arg, starting_point, batch_amount);
5661 return nativeResponseValue;
5663 // LDKCVec_NodeAnnouncementZ RoutingMessageHandler_get_next_node_announcements LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey starting_point, uint8_t batch_amount
5665 export function RoutingMessageHandler_get_next_node_announcements(this_arg: number, starting_point: number, batch_amount: number): number {
5666 if(!isWasmInitialized) {
5667 throw new Error("initializeWasm() must be awaited first!");
5669 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_node_announcements(this_arg, starting_point, batch_amount);
5670 return nativeResponseValue;
5672 // void RoutingMessageHandler_sync_routing_table LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init
5674 export function RoutingMessageHandler_sync_routing_table(this_arg: number, their_node_id: number, init: number): void {
5675 if(!isWasmInitialized) {
5676 throw new Error("initializeWasm() must be awaited first!");
5678 const nativeResponseValue = wasm.TS_RoutingMessageHandler_sync_routing_table(this_arg, their_node_id, init);
5679 // debug statements here
5681 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg
5683 export function RoutingMessageHandler_handle_reply_channel_range(this_arg: number, their_node_id: number, msg: number): number {
5684 if(!isWasmInitialized) {
5685 throw new Error("initializeWasm() must be awaited first!");
5687 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_channel_range(this_arg, their_node_id, msg);
5688 return nativeResponseValue;
5690 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_short_channel_ids_end LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg
5692 export function RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg: number, their_node_id: number, msg: number): number {
5693 if(!isWasmInitialized) {
5694 throw new Error("initializeWasm() must be awaited first!");
5696 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg, their_node_id, msg);
5697 return nativeResponseValue;
5699 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg
5701 export function RoutingMessageHandler_handle_query_channel_range(this_arg: number, their_node_id: number, msg: number): number {
5702 if(!isWasmInitialized) {
5703 throw new Error("initializeWasm() must be awaited first!");
5705 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_channel_range(this_arg, their_node_id, msg);
5706 return nativeResponseValue;
5708 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_short_channel_ids LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg
5710 export function RoutingMessageHandler_handle_query_short_channel_ids(this_arg: number, their_node_id: number, msg: number): number {
5711 if(!isWasmInitialized) {
5712 throw new Error("initializeWasm() must be awaited first!");
5714 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_short_channel_ids(this_arg, their_node_id, msg);
5715 return nativeResponseValue;
5718 export interface LDKCustomMessageReader {
5719 read (message_type: number, buffer: number): number;
5723 export function LDKCustomMessageReader_new(impl: LDKCustomMessageReader): number {
5724 if(!isWasmInitialized) {
5725 throw new Error("initializeWasm() must be awaited first!");
5727 var new_obj_idx = js_objs.length;
5728 for (var i = 0; i < js_objs.length; i++) {
5729 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5731 js_objs[i] = new WeakRef(impl);
5732 return wasm.TS_LDKCustomMessageReader_new(i);
5734 // LDKCResult_COption_TypeZDecodeErrorZ CustomMessageReader_read LDKCustomMessageReader *NONNULL_PTR this_arg, uint16_t message_type, struct LDKu8slice buffer
5736 export function CustomMessageReader_read(this_arg: number, message_type: number, buffer: number): number {
5737 if(!isWasmInitialized) {
5738 throw new Error("initializeWasm() must be awaited first!");
5740 const nativeResponseValue = wasm.TS_CustomMessageReader_read(this_arg, message_type, buffer);
5741 return nativeResponseValue;
5744 export interface LDKCustomMessageHandler {
5745 handle_custom_message (msg: number, sender_node_id: number): number;
5746 get_and_clear_pending_msg (): number;
5750 export function LDKCustomMessageHandler_new(impl: LDKCustomMessageHandler, CustomMessageReader: LDKCustomMessageReader): number {
5751 if(!isWasmInitialized) {
5752 throw new Error("initializeWasm() must be awaited first!");
5754 var new_obj_idx = js_objs.length;
5755 for (var i = 0; i < js_objs.length; i++) {
5756 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5758 js_objs[i] = new WeakRef(impl);
5759 return wasm.TS_LDKCustomMessageHandler_new(i);
5761 // LDKCResult_NoneLightningErrorZ CustomMessageHandler_handle_custom_message LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKType msg, struct LDKPublicKey sender_node_id
5763 export function CustomMessageHandler_handle_custom_message(this_arg: number, msg: number, sender_node_id: number): number {
5764 if(!isWasmInitialized) {
5765 throw new Error("initializeWasm() must be awaited first!");
5767 const nativeResponseValue = wasm.TS_CustomMessageHandler_handle_custom_message(this_arg, msg, sender_node_id);
5768 return nativeResponseValue;
5770 // LDKCVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler_get_and_clear_pending_msg LDKCustomMessageHandler *NONNULL_PTR this_arg
5772 export function CustomMessageHandler_get_and_clear_pending_msg(this_arg: number): number {
5773 if(!isWasmInitialized) {
5774 throw new Error("initializeWasm() must be awaited first!");
5776 const nativeResponseValue = wasm.TS_CustomMessageHandler_get_and_clear_pending_msg(this_arg);
5777 return nativeResponseValue;
5780 export interface LDKSocketDescriptor {
5781 send_data (data: number, resume_read: boolean): number;
5782 disconnect_socket (): void;
5783 eq (other_arg: number): boolean;
5788 export function LDKSocketDescriptor_new(impl: LDKSocketDescriptor): number {
5789 if(!isWasmInitialized) {
5790 throw new Error("initializeWasm() must be awaited first!");
5792 var new_obj_idx = js_objs.length;
5793 for (var i = 0; i < js_objs.length; i++) {
5794 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5796 js_objs[i] = new WeakRef(impl);
5797 return wasm.TS_LDKSocketDescriptor_new(i);
5799 // uintptr_t SocketDescriptor_send_data LDKSocketDescriptor *NONNULL_PTR this_arg, struct LDKu8slice data, bool resume_read
5801 export function SocketDescriptor_send_data(this_arg: number, data: number, resume_read: boolean): number {
5802 if(!isWasmInitialized) {
5803 throw new Error("initializeWasm() must be awaited first!");
5805 const nativeResponseValue = wasm.TS_SocketDescriptor_send_data(this_arg, data, resume_read);
5806 return nativeResponseValue;
5808 // void SocketDescriptor_disconnect_socket LDKSocketDescriptor *NONNULL_PTR this_arg
5810 export function SocketDescriptor_disconnect_socket(this_arg: number): void {
5811 if(!isWasmInitialized) {
5812 throw new Error("initializeWasm() must be awaited first!");
5814 const nativeResponseValue = wasm.TS_SocketDescriptor_disconnect_socket(this_arg);
5815 // debug statements here
5817 // uint64_t SocketDescriptor_hash LDKSocketDescriptor *NONNULL_PTR this_arg
5819 export function SocketDescriptor_hash(this_arg: number): bigint {
5820 if(!isWasmInitialized) {
5821 throw new Error("initializeWasm() must be awaited first!");
5823 const nativeResponseValue = wasm.TS_SocketDescriptor_hash(this_arg);
5824 return nativeResponseValue;
5827 export class LDKEffectiveCapacity {
5828 protected constructor() {}
5831 export function LDKEffectiveCapacity_ty_from_ptr(ptr: number): number {
5832 if(!isWasmInitialized) {
5833 throw new Error("initializeWasm() must be awaited first!");
5835 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ty_from_ptr(ptr);
5836 return nativeResponseValue;
5839 export function LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr: number): bigint {
5840 if(!isWasmInitialized) {
5841 throw new Error("initializeWasm() must be awaited first!");
5843 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr);
5844 return nativeResponseValue;
5847 export function LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr: number): bigint {
5848 if(!isWasmInitialized) {
5849 throw new Error("initializeWasm() must be awaited first!");
5851 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr);
5852 return nativeResponseValue;
5855 export function LDKEffectiveCapacity_Total_get_capacity_msat(ptr: number): bigint {
5856 if(!isWasmInitialized) {
5857 throw new Error("initializeWasm() must be awaited first!");
5859 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_capacity_msat(ptr);
5860 return nativeResponseValue;
5863 export interface LDKScore {
5864 channel_penalty_msat (short_channel_id: bigint, send_amt_msat: bigint, capacity_msat: bigint, source: number, target: number): bigint;
5865 payment_path_failed (path: number, short_channel_id: bigint): void;
5866 payment_path_successful (path: number): void;
5871 export function LDKScore_new(impl: LDKScore): number {
5872 if(!isWasmInitialized) {
5873 throw new Error("initializeWasm() must be awaited first!");
5875 var new_obj_idx = js_objs.length;
5876 for (var i = 0; i < js_objs.length; i++) {
5877 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5879 js_objs[i] = new WeakRef(impl);
5880 return wasm.TS_LDKScore_new(i);
5882 // 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
5884 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 {
5885 if(!isWasmInitialized) {
5886 throw new Error("initializeWasm() must be awaited first!");
5888 const nativeResponseValue = wasm.TS_Score_channel_penalty_msat(this_arg, short_channel_id, send_amt_msat, capacity_msat, source, target);
5889 return nativeResponseValue;
5891 // void Score_payment_path_failed LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
5893 export function Score_payment_path_failed(this_arg: number, path: number, short_channel_id: bigint): void {
5894 if(!isWasmInitialized) {
5895 throw new Error("initializeWasm() must be awaited first!");
5897 const nativeResponseValue = wasm.TS_Score_payment_path_failed(this_arg, path, short_channel_id);
5898 // debug statements here
5900 // void Score_payment_path_successful LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
5902 export function Score_payment_path_successful(this_arg: number, path: number): void {
5903 if(!isWasmInitialized) {
5904 throw new Error("initializeWasm() must be awaited first!");
5906 const nativeResponseValue = wasm.TS_Score_payment_path_successful(this_arg, path);
5907 // debug statements here
5909 // LDKCVec_u8Z Score_write LDKScore *NONNULL_PTR this_arg
5911 export function Score_write(this_arg: number): number {
5912 if(!isWasmInitialized) {
5913 throw new Error("initializeWasm() must be awaited first!");
5915 const nativeResponseValue = wasm.TS_Score_write(this_arg);
5916 return nativeResponseValue;
5919 export interface LDKLockableScore {
5924 export function LDKLockableScore_new(impl: LDKLockableScore): number {
5925 if(!isWasmInitialized) {
5926 throw new Error("initializeWasm() must be awaited first!");
5928 var new_obj_idx = js_objs.length;
5929 for (var i = 0; i < js_objs.length; i++) {
5930 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5932 js_objs[i] = new WeakRef(impl);
5933 return wasm.TS_LDKLockableScore_new(i);
5935 // LDKScore LockableScore_lock LDKLockableScore *NONNULL_PTR this_arg
5937 export function LockableScore_lock(this_arg: number): number {
5938 if(!isWasmInitialized) {
5939 throw new Error("initializeWasm() must be awaited first!");
5941 const nativeResponseValue = wasm.TS_LockableScore_lock(this_arg);
5942 return nativeResponseValue;
5945 export class LDKFallback {
5946 protected constructor() {}
5949 export function LDKFallback_ty_from_ptr(ptr: number): number {
5950 if(!isWasmInitialized) {
5951 throw new Error("initializeWasm() must be awaited first!");
5953 const nativeResponseValue = wasm.TS_LDKFallback_ty_from_ptr(ptr);
5954 return nativeResponseValue;
5957 export function LDKFallback_SegWitProgram_get_version(ptr: number): number {
5958 if(!isWasmInitialized) {
5959 throw new Error("initializeWasm() must be awaited first!");
5961 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_version(ptr);
5962 return nativeResponseValue;
5965 export function LDKFallback_SegWitProgram_get_program(ptr: number): number {
5966 if(!isWasmInitialized) {
5967 throw new Error("initializeWasm() must be awaited first!");
5969 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_program(ptr);
5970 return nativeResponseValue;
5973 export function LDKFallback_PubKeyHash_get_pub_key_hash(ptr: number): number {
5974 if(!isWasmInitialized) {
5975 throw new Error("initializeWasm() must be awaited first!");
5977 const nativeResponseValue = wasm.TS_LDKFallback_PubKeyHash_get_pub_key_hash(ptr);
5978 return nativeResponseValue;
5981 export function LDKFallback_ScriptHash_get_script_hash(ptr: number): number {
5982 if(!isWasmInitialized) {
5983 throw new Error("initializeWasm() must be awaited first!");
5985 const nativeResponseValue = wasm.TS_LDKFallback_ScriptHash_get_script_hash(ptr);
5986 return nativeResponseValue;
5989 export interface LDKPayer {
5991 first_hops (): number;
5992 send_payment (route: number, payment_hash: number, payment_secret: number): number;
5993 send_spontaneous_payment (route: number, payment_preimage: number): number;
5994 retry_payment (route: number, payment_id: number): number;
5995 abandon_payment (payment_id: number): void;
5999 export function LDKPayer_new(impl: LDKPayer): number {
6000 if(!isWasmInitialized) {
6001 throw new Error("initializeWasm() must be awaited first!");
6003 var new_obj_idx = js_objs.length;
6004 for (var i = 0; i < js_objs.length; i++) {
6005 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6007 js_objs[i] = new WeakRef(impl);
6008 return wasm.TS_LDKPayer_new(i);
6010 // LDKPublicKey Payer_node_id LDKPayer *NONNULL_PTR this_arg
6012 export function Payer_node_id(this_arg: number): number {
6013 if(!isWasmInitialized) {
6014 throw new Error("initializeWasm() must be awaited first!");
6016 const nativeResponseValue = wasm.TS_Payer_node_id(this_arg);
6017 return nativeResponseValue;
6019 // LDKCVec_ChannelDetailsZ Payer_first_hops LDKPayer *NONNULL_PTR this_arg
6021 export function Payer_first_hops(this_arg: number): number {
6022 if(!isWasmInitialized) {
6023 throw new Error("initializeWasm() must be awaited first!");
6025 const nativeResponseValue = wasm.TS_Payer_first_hops(this_arg);
6026 return nativeResponseValue;
6028 // LDKCResult_PaymentIdPaymentSendFailureZ Payer_send_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret
6030 export function Payer_send_payment(this_arg: number, route: number, payment_hash: number, payment_secret: number): number {
6031 if(!isWasmInitialized) {
6032 throw new Error("initializeWasm() must be awaited first!");
6034 const nativeResponseValue = wasm.TS_Payer_send_payment(this_arg, route, payment_hash, payment_secret);
6035 return nativeResponseValue;
6037 // LDKCResult_PaymentIdPaymentSendFailureZ Payer_send_spontaneous_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage
6039 export function Payer_send_spontaneous_payment(this_arg: number, route: number, payment_preimage: number): number {
6040 if(!isWasmInitialized) {
6041 throw new Error("initializeWasm() must be awaited first!");
6043 const nativeResponseValue = wasm.TS_Payer_send_spontaneous_payment(this_arg, route, payment_preimage);
6044 return nativeResponseValue;
6046 // LDKCResult_NonePaymentSendFailureZ Payer_retry_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_id
6048 export function Payer_retry_payment(this_arg: number, route: number, payment_id: number): number {
6049 if(!isWasmInitialized) {
6050 throw new Error("initializeWasm() must be awaited first!");
6052 const nativeResponseValue = wasm.TS_Payer_retry_payment(this_arg, route, payment_id);
6053 return nativeResponseValue;
6055 // void Payer_abandon_payment LDKPayer *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id
6057 export function Payer_abandon_payment(this_arg: number, payment_id: number): void {
6058 if(!isWasmInitialized) {
6059 throw new Error("initializeWasm() must be awaited first!");
6061 const nativeResponseValue = wasm.TS_Payer_abandon_payment(this_arg, payment_id);
6062 // debug statements here
6065 export interface LDKRouter {
6066 find_route (payer: number, route_params: number, payment_hash: number, first_hops: number, scorer: number): number;
6070 export function LDKRouter_new(impl: LDKRouter): number {
6071 if(!isWasmInitialized) {
6072 throw new Error("initializeWasm() must be awaited first!");
6074 var new_obj_idx = js_objs.length;
6075 for (var i = 0; i < js_objs.length; i++) {
6076 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6078 js_objs[i] = new WeakRef(impl);
6079 return wasm.TS_LDKRouter_new(i);
6081 // 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
6083 export function Router_find_route(this_arg: number, payer: number, route_params: number, payment_hash: number, first_hops: number, scorer: number): number {
6084 if(!isWasmInitialized) {
6085 throw new Error("initializeWasm() must be awaited first!");
6087 const nativeResponseValue = wasm.TS_Router_find_route(this_arg, payer, route_params, payment_hash, first_hops, scorer);
6088 return nativeResponseValue;
6090 // struct LDKStr _ldk_get_compiled_version(void);
6092 export function _ldk_get_compiled_version(): number {
6093 if(!isWasmInitialized) {
6094 throw new Error("initializeWasm() must be awaited first!");
6096 const nativeResponseValue = wasm.TS__ldk_get_compiled_version();
6097 return nativeResponseValue;
6099 // struct LDKStr _ldk_c_bindings_get_compiled_version(void);
6101 export function _ldk_c_bindings_get_compiled_version(): number {
6102 if(!isWasmInitialized) {
6103 throw new Error("initializeWasm() must be awaited first!");
6105 const nativeResponseValue = wasm.TS__ldk_c_bindings_get_compiled_version();
6106 return nativeResponseValue;
6108 // void Transaction_free(struct LDKTransaction _res);
6110 export function Transaction_free(_res: number): void {
6111 if(!isWasmInitialized) {
6112 throw new Error("initializeWasm() must be awaited first!");
6114 const nativeResponseValue = wasm.TS_Transaction_free(_res);
6115 // debug statements here
6117 // struct LDKTxOut TxOut_new(struct LDKCVec_u8Z script_pubkey, uint64_t value);
6119 export function TxOut_new(script_pubkey: number, value: bigint): number {
6120 if(!isWasmInitialized) {
6121 throw new Error("initializeWasm() must be awaited first!");
6123 const nativeResponseValue = wasm.TS_TxOut_new(script_pubkey, value);
6124 return nativeResponseValue;
6126 // void TxOut_free(struct LDKTxOut _res);
6128 export function TxOut_free(_res: number): void {
6129 if(!isWasmInitialized) {
6130 throw new Error("initializeWasm() must be awaited first!");
6132 const nativeResponseValue = wasm.TS_TxOut_free(_res);
6133 // debug statements here
6135 // uintptr_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg);
6137 export function TxOut_clone_ptr(arg: number): number {
6138 if(!isWasmInitialized) {
6139 throw new Error("initializeWasm() must be awaited first!");
6141 const nativeResponseValue = wasm.TS_TxOut_clone_ptr(arg);
6142 return nativeResponseValue;
6144 // struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
6146 export function TxOut_clone(orig: number): number {
6147 if(!isWasmInitialized) {
6148 throw new Error("initializeWasm() must be awaited first!");
6150 const nativeResponseValue = wasm.TS_TxOut_clone(orig);
6151 return nativeResponseValue;
6153 // void Str_free(struct LDKStr _res);
6155 export function Str_free(_res: number): void {
6156 if(!isWasmInitialized) {
6157 throw new Error("initializeWasm() must be awaited first!");
6159 const nativeResponseValue = wasm.TS_Str_free(_res);
6160 // debug statements here
6162 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_ok(void);
6164 export function CResult_NoneNoneZ_ok(): number {
6165 if(!isWasmInitialized) {
6166 throw new Error("initializeWasm() must be awaited first!");
6168 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_ok();
6169 return nativeResponseValue;
6171 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_err(void);
6173 export function CResult_NoneNoneZ_err(): number {
6174 if(!isWasmInitialized) {
6175 throw new Error("initializeWasm() must be awaited first!");
6177 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_err();
6178 return nativeResponseValue;
6180 // bool CResult_NoneNoneZ_is_ok(const struct LDKCResult_NoneNoneZ *NONNULL_PTR o);
6182 export function CResult_NoneNoneZ_is_ok(o: number): boolean {
6183 if(!isWasmInitialized) {
6184 throw new Error("initializeWasm() must be awaited first!");
6186 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_is_ok(o);
6187 return nativeResponseValue;
6189 // void CResult_NoneNoneZ_free(struct LDKCResult_NoneNoneZ _res);
6191 export function CResult_NoneNoneZ_free(_res: number): void {
6192 if(!isWasmInitialized) {
6193 throw new Error("initializeWasm() must be awaited first!");
6195 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_free(_res);
6196 // debug statements here
6198 // uintptr_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg);
6200 export function CResult_NoneNoneZ_clone_ptr(arg: number): number {
6201 if(!isWasmInitialized) {
6202 throw new Error("initializeWasm() must be awaited first!");
6204 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone_ptr(arg);
6205 return nativeResponseValue;
6207 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_clone(const struct LDKCResult_NoneNoneZ *NONNULL_PTR orig);
6209 export function CResult_NoneNoneZ_clone(orig: number): number {
6210 if(!isWasmInitialized) {
6211 throw new Error("initializeWasm() must be awaited first!");
6213 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone(orig);
6214 return nativeResponseValue;
6216 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(struct LDKCounterpartyCommitmentSecrets o);
6218 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o: number): number {
6219 if(!isWasmInitialized) {
6220 throw new Error("initializeWasm() must be awaited first!");
6222 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o);
6223 return nativeResponseValue;
6225 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(struct LDKDecodeError e);
6227 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e: number): number {
6228 if(!isWasmInitialized) {
6229 throw new Error("initializeWasm() must be awaited first!");
6231 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e);
6232 return nativeResponseValue;
6234 // bool CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR o);
6236 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o: number): boolean {
6237 if(!isWasmInitialized) {
6238 throw new Error("initializeWasm() must be awaited first!");
6240 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o);
6241 return nativeResponseValue;
6243 // void CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ _res);
6245 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res: number): void {
6246 if(!isWasmInitialized) {
6247 throw new Error("initializeWasm() must be awaited first!");
6249 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res);
6250 // debug statements here
6252 // uintptr_t CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR arg);
6254 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg: number): number {
6255 if(!isWasmInitialized) {
6256 throw new Error("initializeWasm() must be awaited first!");
6258 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg);
6259 return nativeResponseValue;
6261 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR orig);
6263 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig: number): number {
6264 if(!isWasmInitialized) {
6265 throw new Error("initializeWasm() must be awaited first!");
6267 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig);
6268 return nativeResponseValue;
6270 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_ok(struct LDKSecretKey o);
6272 export function CResult_SecretKeyErrorZ_ok(o: number): number {
6273 if(!isWasmInitialized) {
6274 throw new Error("initializeWasm() must be awaited first!");
6276 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_ok(o);
6277 return nativeResponseValue;
6279 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_err(enum LDKSecp256k1Error e);
6281 export function CResult_SecretKeyErrorZ_err(e: Secp256k1Error): number {
6282 if(!isWasmInitialized) {
6283 throw new Error("initializeWasm() must be awaited first!");
6285 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_err(e);
6286 return nativeResponseValue;
6288 // bool CResult_SecretKeyErrorZ_is_ok(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR o);
6290 export function CResult_SecretKeyErrorZ_is_ok(o: number): boolean {
6291 if(!isWasmInitialized) {
6292 throw new Error("initializeWasm() must be awaited first!");
6294 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_is_ok(o);
6295 return nativeResponseValue;
6297 // void CResult_SecretKeyErrorZ_free(struct LDKCResult_SecretKeyErrorZ _res);
6299 export function CResult_SecretKeyErrorZ_free(_res: number): void {
6300 if(!isWasmInitialized) {
6301 throw new Error("initializeWasm() must be awaited first!");
6303 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_free(_res);
6304 // debug statements here
6306 // uintptr_t CResult_SecretKeyErrorZ_clone_ptr(LDKCResult_SecretKeyErrorZ *NONNULL_PTR arg);
6308 export function CResult_SecretKeyErrorZ_clone_ptr(arg: number): number {
6309 if(!isWasmInitialized) {
6310 throw new Error("initializeWasm() must be awaited first!");
6312 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_clone_ptr(arg);
6313 return nativeResponseValue;
6315 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_clone(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR orig);
6317 export function CResult_SecretKeyErrorZ_clone(orig: number): number {
6318 if(!isWasmInitialized) {
6319 throw new Error("initializeWasm() must be awaited first!");
6321 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_clone(orig);
6322 return nativeResponseValue;
6324 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_ok(struct LDKPublicKey o);
6326 export function CResult_PublicKeyErrorZ_ok(o: number): number {
6327 if(!isWasmInitialized) {
6328 throw new Error("initializeWasm() must be awaited first!");
6330 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_ok(o);
6331 return nativeResponseValue;
6333 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_err(enum LDKSecp256k1Error e);
6335 export function CResult_PublicKeyErrorZ_err(e: Secp256k1Error): number {
6336 if(!isWasmInitialized) {
6337 throw new Error("initializeWasm() must be awaited first!");
6339 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_err(e);
6340 return nativeResponseValue;
6342 // bool CResult_PublicKeyErrorZ_is_ok(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR o);
6344 export function CResult_PublicKeyErrorZ_is_ok(o: number): boolean {
6345 if(!isWasmInitialized) {
6346 throw new Error("initializeWasm() must be awaited first!");
6348 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_is_ok(o);
6349 return nativeResponseValue;
6351 // void CResult_PublicKeyErrorZ_free(struct LDKCResult_PublicKeyErrorZ _res);
6353 export function CResult_PublicKeyErrorZ_free(_res: number): void {
6354 if(!isWasmInitialized) {
6355 throw new Error("initializeWasm() must be awaited first!");
6357 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_free(_res);
6358 // debug statements here
6360 // uintptr_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg);
6362 export function CResult_PublicKeyErrorZ_clone_ptr(arg: number): number {
6363 if(!isWasmInitialized) {
6364 throw new Error("initializeWasm() must be awaited first!");
6366 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone_ptr(arg);
6367 return nativeResponseValue;
6369 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_clone(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR orig);
6371 export function CResult_PublicKeyErrorZ_clone(orig: number): number {
6372 if(!isWasmInitialized) {
6373 throw new Error("initializeWasm() must be awaited first!");
6375 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone(orig);
6376 return nativeResponseValue;
6378 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_ok(struct LDKTxCreationKeys o);
6380 export function CResult_TxCreationKeysDecodeErrorZ_ok(o: number): number {
6381 if(!isWasmInitialized) {
6382 throw new Error("initializeWasm() must be awaited first!");
6384 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_ok(o);
6385 return nativeResponseValue;
6387 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_err(struct LDKDecodeError e);
6389 export function CResult_TxCreationKeysDecodeErrorZ_err(e: number): number {
6390 if(!isWasmInitialized) {
6391 throw new Error("initializeWasm() must be awaited first!");
6393 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_err(e);
6394 return nativeResponseValue;
6396 // bool CResult_TxCreationKeysDecodeErrorZ_is_ok(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR o);
6398 export function CResult_TxCreationKeysDecodeErrorZ_is_ok(o: number): boolean {
6399 if(!isWasmInitialized) {
6400 throw new Error("initializeWasm() must be awaited first!");
6402 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(o);
6403 return nativeResponseValue;
6405 // void CResult_TxCreationKeysDecodeErrorZ_free(struct LDKCResult_TxCreationKeysDecodeErrorZ _res);
6407 export function CResult_TxCreationKeysDecodeErrorZ_free(_res: number): void {
6408 if(!isWasmInitialized) {
6409 throw new Error("initializeWasm() must be awaited first!");
6411 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_free(_res);
6412 // debug statements here
6414 // uintptr_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg);
6416 export function CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg: number): number {
6417 if(!isWasmInitialized) {
6418 throw new Error("initializeWasm() must be awaited first!");
6420 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg);
6421 return nativeResponseValue;
6423 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_clone(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR orig);
6425 export function CResult_TxCreationKeysDecodeErrorZ_clone(orig: number): number {
6426 if(!isWasmInitialized) {
6427 throw new Error("initializeWasm() must be awaited first!");
6429 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone(orig);
6430 return nativeResponseValue;
6432 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_ok(struct LDKChannelPublicKeys o);
6434 export function CResult_ChannelPublicKeysDecodeErrorZ_ok(o: number): number {
6435 if(!isWasmInitialized) {
6436 throw new Error("initializeWasm() must be awaited first!");
6438 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_ok(o);
6439 return nativeResponseValue;
6441 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_err(struct LDKDecodeError e);
6443 export function CResult_ChannelPublicKeysDecodeErrorZ_err(e: number): number {
6444 if(!isWasmInitialized) {
6445 throw new Error("initializeWasm() must be awaited first!");
6447 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_err(e);
6448 return nativeResponseValue;
6450 // bool CResult_ChannelPublicKeysDecodeErrorZ_is_ok(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR o);
6452 export function CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o: number): boolean {
6453 if(!isWasmInitialized) {
6454 throw new Error("initializeWasm() must be awaited first!");
6456 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o);
6457 return nativeResponseValue;
6459 // void CResult_ChannelPublicKeysDecodeErrorZ_free(struct LDKCResult_ChannelPublicKeysDecodeErrorZ _res);
6461 export function CResult_ChannelPublicKeysDecodeErrorZ_free(_res: number): void {
6462 if(!isWasmInitialized) {
6463 throw new Error("initializeWasm() must be awaited first!");
6465 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_free(_res);
6466 // debug statements here
6468 // uintptr_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg);
6470 export function CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg: number): number {
6471 if(!isWasmInitialized) {
6472 throw new Error("initializeWasm() must be awaited first!");
6474 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg);
6475 return nativeResponseValue;
6477 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_clone(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR orig);
6479 export function CResult_ChannelPublicKeysDecodeErrorZ_clone(orig: number): number {
6480 if(!isWasmInitialized) {
6481 throw new Error("initializeWasm() must be awaited first!");
6483 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(orig);
6484 return nativeResponseValue;
6486 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_ok(struct LDKTxCreationKeys o);
6488 export function CResult_TxCreationKeysErrorZ_ok(o: number): number {
6489 if(!isWasmInitialized) {
6490 throw new Error("initializeWasm() must be awaited first!");
6492 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_ok(o);
6493 return nativeResponseValue;
6495 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_err(enum LDKSecp256k1Error e);
6497 export function CResult_TxCreationKeysErrorZ_err(e: Secp256k1Error): number {
6498 if(!isWasmInitialized) {
6499 throw new Error("initializeWasm() must be awaited first!");
6501 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_err(e);
6502 return nativeResponseValue;
6504 // bool CResult_TxCreationKeysErrorZ_is_ok(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR o);
6506 export function CResult_TxCreationKeysErrorZ_is_ok(o: number): boolean {
6507 if(!isWasmInitialized) {
6508 throw new Error("initializeWasm() must be awaited first!");
6510 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_is_ok(o);
6511 return nativeResponseValue;
6513 // void CResult_TxCreationKeysErrorZ_free(struct LDKCResult_TxCreationKeysErrorZ _res);
6515 export function CResult_TxCreationKeysErrorZ_free(_res: number): void {
6516 if(!isWasmInitialized) {
6517 throw new Error("initializeWasm() must be awaited first!");
6519 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_free(_res);
6520 // debug statements here
6522 // uintptr_t CResult_TxCreationKeysErrorZ_clone_ptr(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR arg);
6524 export function CResult_TxCreationKeysErrorZ_clone_ptr(arg: number): number {
6525 if(!isWasmInitialized) {
6526 throw new Error("initializeWasm() must be awaited first!");
6528 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone_ptr(arg);
6529 return nativeResponseValue;
6531 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_clone(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR orig);
6533 export function CResult_TxCreationKeysErrorZ_clone(orig: number): number {
6534 if(!isWasmInitialized) {
6535 throw new Error("initializeWasm() must be awaited first!");
6537 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone(orig);
6538 return nativeResponseValue;
6540 // struct LDKCOption_u32Z COption_u32Z_some(uint32_t o);
6542 export function COption_u32Z_some(o: number): number {
6543 if(!isWasmInitialized) {
6544 throw new Error("initializeWasm() must be awaited first!");
6546 const nativeResponseValue = wasm.TS_COption_u32Z_some(o);
6547 return nativeResponseValue;
6549 // struct LDKCOption_u32Z COption_u32Z_none(void);
6551 export function COption_u32Z_none(): number {
6552 if(!isWasmInitialized) {
6553 throw new Error("initializeWasm() must be awaited first!");
6555 const nativeResponseValue = wasm.TS_COption_u32Z_none();
6556 return nativeResponseValue;
6558 // void COption_u32Z_free(struct LDKCOption_u32Z _res);
6560 export function COption_u32Z_free(_res: number): void {
6561 if(!isWasmInitialized) {
6562 throw new Error("initializeWasm() must be awaited first!");
6564 const nativeResponseValue = wasm.TS_COption_u32Z_free(_res);
6565 // debug statements here
6567 // uintptr_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg);
6569 export function COption_u32Z_clone_ptr(arg: number): number {
6570 if(!isWasmInitialized) {
6571 throw new Error("initializeWasm() must be awaited first!");
6573 const nativeResponseValue = wasm.TS_COption_u32Z_clone_ptr(arg);
6574 return nativeResponseValue;
6576 // struct LDKCOption_u32Z COption_u32Z_clone(const struct LDKCOption_u32Z *NONNULL_PTR orig);
6578 export function COption_u32Z_clone(orig: number): number {
6579 if(!isWasmInitialized) {
6580 throw new Error("initializeWasm() must be awaited first!");
6582 const nativeResponseValue = wasm.TS_COption_u32Z_clone(orig);
6583 return nativeResponseValue;
6585 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(struct LDKHTLCOutputInCommitment o);
6587 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o: number): number {
6588 if(!isWasmInitialized) {
6589 throw new Error("initializeWasm() must be awaited first!");
6591 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o);
6592 return nativeResponseValue;
6594 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_err(struct LDKDecodeError e);
6596 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e: number): number {
6597 if(!isWasmInitialized) {
6598 throw new Error("initializeWasm() must be awaited first!");
6600 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e);
6601 return nativeResponseValue;
6603 // bool CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR o);
6605 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o: number): boolean {
6606 if(!isWasmInitialized) {
6607 throw new Error("initializeWasm() must be awaited first!");
6609 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o);
6610 return nativeResponseValue;
6612 // void CResult_HTLCOutputInCommitmentDecodeErrorZ_free(struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res);
6614 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res: number): void {
6615 if(!isWasmInitialized) {
6616 throw new Error("initializeWasm() must be awaited first!");
6618 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res);
6619 // debug statements here
6621 // uintptr_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg);
6623 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg: number): number {
6624 if(!isWasmInitialized) {
6625 throw new Error("initializeWasm() must be awaited first!");
6627 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg);
6628 return nativeResponseValue;
6630 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR orig);
6632 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig: number): number {
6633 if(!isWasmInitialized) {
6634 throw new Error("initializeWasm() must be awaited first!");
6636 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig);
6637 return nativeResponseValue;
6639 // enum LDKCOption_NoneZ COption_NoneZ_some(void);
6641 export function COption_NoneZ_some(): COption_NoneZ {
6642 if(!isWasmInitialized) {
6643 throw new Error("initializeWasm() must be awaited first!");
6645 const nativeResponseValue = wasm.TS_COption_NoneZ_some();
6646 return nativeResponseValue;
6648 // enum LDKCOption_NoneZ COption_NoneZ_none(void);
6650 export function COption_NoneZ_none(): COption_NoneZ {
6651 if(!isWasmInitialized) {
6652 throw new Error("initializeWasm() must be awaited first!");
6654 const nativeResponseValue = wasm.TS_COption_NoneZ_none();
6655 return nativeResponseValue;
6657 // void COption_NoneZ_free(enum LDKCOption_NoneZ _res);
6659 export function COption_NoneZ_free(_res: COption_NoneZ): void {
6660 if(!isWasmInitialized) {
6661 throw new Error("initializeWasm() must be awaited first!");
6663 const nativeResponseValue = wasm.TS_COption_NoneZ_free(_res);
6664 // debug statements here
6666 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(struct LDKCounterpartyChannelTransactionParameters o);
6668 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o: number): number {
6669 if(!isWasmInitialized) {
6670 throw new Error("initializeWasm() must be awaited first!");
6672 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o);
6673 return nativeResponseValue;
6675 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
6677 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e: number): number {
6678 if(!isWasmInitialized) {
6679 throw new Error("initializeWasm() must be awaited first!");
6681 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e);
6682 return nativeResponseValue;
6684 // bool CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
6686 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o: number): boolean {
6687 if(!isWasmInitialized) {
6688 throw new Error("initializeWasm() must be awaited first!");
6690 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o);
6691 return nativeResponseValue;
6693 // void CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res);
6695 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res: number): void {
6696 if(!isWasmInitialized) {
6697 throw new Error("initializeWasm() must be awaited first!");
6699 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res);
6700 // debug statements here
6702 // uintptr_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
6704 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: number): number {
6705 if(!isWasmInitialized) {
6706 throw new Error("initializeWasm() must be awaited first!");
6708 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
6709 return nativeResponseValue;
6711 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
6713 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig: number): number {
6714 if(!isWasmInitialized) {
6715 throw new Error("initializeWasm() must be awaited first!");
6717 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig);
6718 return nativeResponseValue;
6720 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_ok(struct LDKChannelTransactionParameters o);
6722 export function CResult_ChannelTransactionParametersDecodeErrorZ_ok(o: number): number {
6723 if(!isWasmInitialized) {
6724 throw new Error("initializeWasm() must be awaited first!");
6726 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok(o);
6727 return nativeResponseValue;
6729 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
6731 export function CResult_ChannelTransactionParametersDecodeErrorZ_err(e: number): number {
6732 if(!isWasmInitialized) {
6733 throw new Error("initializeWasm() must be awaited first!");
6735 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_err(e);
6736 return nativeResponseValue;
6738 // bool CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
6740 export function CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o: number): boolean {
6741 if(!isWasmInitialized) {
6742 throw new Error("initializeWasm() must be awaited first!");
6744 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o);
6745 return nativeResponseValue;
6747 // void CResult_ChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_ChannelTransactionParametersDecodeErrorZ _res);
6749 export function CResult_ChannelTransactionParametersDecodeErrorZ_free(_res: number): void {
6750 if(!isWasmInitialized) {
6751 throw new Error("initializeWasm() must be awaited first!");
6753 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(_res);
6754 // debug statements here
6756 // uintptr_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
6758 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: number): number {
6759 if(!isWasmInitialized) {
6760 throw new Error("initializeWasm() must be awaited first!");
6762 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
6763 return nativeResponseValue;
6765 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
6767 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig: number): number {
6768 if(!isWasmInitialized) {
6769 throw new Error("initializeWasm() must be awaited first!");
6771 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig);
6772 return nativeResponseValue;
6774 // void CVec_SignatureZ_free(struct LDKCVec_SignatureZ _res);
6776 export function CVec_SignatureZ_free(_res: number): void {
6777 if(!isWasmInitialized) {
6778 throw new Error("initializeWasm() must be awaited first!");
6780 const nativeResponseValue = wasm.TS_CVec_SignatureZ_free(_res);
6781 // debug statements here
6783 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_ok(struct LDKHolderCommitmentTransaction o);
6785 export function CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o: number): number {
6786 if(!isWasmInitialized) {
6787 throw new Error("initializeWasm() must be awaited first!");
6789 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o);
6790 return nativeResponseValue;
6792 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
6794 export function CResult_HolderCommitmentTransactionDecodeErrorZ_err(e: number): number {
6795 if(!isWasmInitialized) {
6796 throw new Error("initializeWasm() must be awaited first!");
6798 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err(e);
6799 return nativeResponseValue;
6801 // bool CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
6803 export function CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
6804 if(!isWasmInitialized) {
6805 throw new Error("initializeWasm() must be awaited first!");
6807 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o);
6808 return nativeResponseValue;
6810 // void CResult_HolderCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res);
6812 export function CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res: number): void {
6813 if(!isWasmInitialized) {
6814 throw new Error("initializeWasm() must be awaited first!");
6816 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res);
6817 // debug statements here
6819 // uintptr_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
6821 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
6822 if(!isWasmInitialized) {
6823 throw new Error("initializeWasm() must be awaited first!");
6825 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
6826 return nativeResponseValue;
6828 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
6830 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig: number): number {
6831 if(!isWasmInitialized) {
6832 throw new Error("initializeWasm() must be awaited first!");
6834 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig);
6835 return nativeResponseValue;
6837 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(struct LDKBuiltCommitmentTransaction o);
6839 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o: number): number {
6840 if(!isWasmInitialized) {
6841 throw new Error("initializeWasm() must be awaited first!");
6843 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o);
6844 return nativeResponseValue;
6846 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
6848 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e: number): number {
6849 if(!isWasmInitialized) {
6850 throw new Error("initializeWasm() must be awaited first!");
6852 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e);
6853 return nativeResponseValue;
6855 // bool CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
6857 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
6858 if(!isWasmInitialized) {
6859 throw new Error("initializeWasm() must be awaited first!");
6861 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o);
6862 return nativeResponseValue;
6864 // void CResult_BuiltCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res);
6866 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res: number): void {
6867 if(!isWasmInitialized) {
6868 throw new Error("initializeWasm() must be awaited first!");
6870 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res);
6871 // debug statements here
6873 // uintptr_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
6875 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
6876 if(!isWasmInitialized) {
6877 throw new Error("initializeWasm() must be awaited first!");
6879 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
6880 return nativeResponseValue;
6882 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
6884 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig: number): number {
6885 if(!isWasmInitialized) {
6886 throw new Error("initializeWasm() must be awaited first!");
6888 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig);
6889 return nativeResponseValue;
6891 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_ok(struct LDKTrustedClosingTransaction o);
6893 export function CResult_TrustedClosingTransactionNoneZ_ok(o: number): number {
6894 if(!isWasmInitialized) {
6895 throw new Error("initializeWasm() must be awaited first!");
6897 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_ok(o);
6898 return nativeResponseValue;
6900 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_err(void);
6902 export function CResult_TrustedClosingTransactionNoneZ_err(): number {
6903 if(!isWasmInitialized) {
6904 throw new Error("initializeWasm() must be awaited first!");
6906 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_err();
6907 return nativeResponseValue;
6909 // bool CResult_TrustedClosingTransactionNoneZ_is_ok(const struct LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR o);
6911 export function CResult_TrustedClosingTransactionNoneZ_is_ok(o: number): boolean {
6912 if(!isWasmInitialized) {
6913 throw new Error("initializeWasm() must be awaited first!");
6915 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_is_ok(o);
6916 return nativeResponseValue;
6918 // void CResult_TrustedClosingTransactionNoneZ_free(struct LDKCResult_TrustedClosingTransactionNoneZ _res);
6920 export function CResult_TrustedClosingTransactionNoneZ_free(_res: number): void {
6921 if(!isWasmInitialized) {
6922 throw new Error("initializeWasm() must be awaited first!");
6924 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_free(_res);
6925 // debug statements here
6927 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_ok(struct LDKCommitmentTransaction o);
6929 export function CResult_CommitmentTransactionDecodeErrorZ_ok(o: number): number {
6930 if(!isWasmInitialized) {
6931 throw new Error("initializeWasm() must be awaited first!");
6933 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_ok(o);
6934 return nativeResponseValue;
6936 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
6938 export function CResult_CommitmentTransactionDecodeErrorZ_err(e: number): number {
6939 if(!isWasmInitialized) {
6940 throw new Error("initializeWasm() must be awaited first!");
6942 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_err(e);
6943 return nativeResponseValue;
6945 // bool CResult_CommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
6947 export function CResult_CommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
6948 if(!isWasmInitialized) {
6949 throw new Error("initializeWasm() must be awaited first!");
6951 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(o);
6952 return nativeResponseValue;
6954 // void CResult_CommitmentTransactionDecodeErrorZ_free(struct LDKCResult_CommitmentTransactionDecodeErrorZ _res);
6956 export function CResult_CommitmentTransactionDecodeErrorZ_free(_res: number): void {
6957 if(!isWasmInitialized) {
6958 throw new Error("initializeWasm() must be awaited first!");
6960 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_free(_res);
6961 // debug statements here
6963 // uintptr_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
6965 export function CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
6966 if(!isWasmInitialized) {
6967 throw new Error("initializeWasm() must be awaited first!");
6969 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg);
6970 return nativeResponseValue;
6972 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
6974 export function CResult_CommitmentTransactionDecodeErrorZ_clone(orig: number): number {
6975 if(!isWasmInitialized) {
6976 throw new Error("initializeWasm() must be awaited first!");
6978 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone(orig);
6979 return nativeResponseValue;
6981 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_ok(struct LDKTrustedCommitmentTransaction o);
6983 export function CResult_TrustedCommitmentTransactionNoneZ_ok(o: number): number {
6984 if(!isWasmInitialized) {
6985 throw new Error("initializeWasm() must be awaited first!");
6987 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_ok(o);
6988 return nativeResponseValue;
6990 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_err(void);
6992 export function CResult_TrustedCommitmentTransactionNoneZ_err(): number {
6993 if(!isWasmInitialized) {
6994 throw new Error("initializeWasm() must be awaited first!");
6996 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_err();
6997 return nativeResponseValue;
6999 // bool CResult_TrustedCommitmentTransactionNoneZ_is_ok(const struct LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR o);
7001 export function CResult_TrustedCommitmentTransactionNoneZ_is_ok(o: number): boolean {
7002 if(!isWasmInitialized) {
7003 throw new Error("initializeWasm() must be awaited first!");
7005 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(o);
7006 return nativeResponseValue;
7008 // void CResult_TrustedCommitmentTransactionNoneZ_free(struct LDKCResult_TrustedCommitmentTransactionNoneZ _res);
7010 export function CResult_TrustedCommitmentTransactionNoneZ_free(_res: number): void {
7011 if(!isWasmInitialized) {
7012 throw new Error("initializeWasm() must be awaited first!");
7014 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_free(_res);
7015 // debug statements here
7017 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_ok(struct LDKCVec_SignatureZ o);
7019 export function CResult_CVec_SignatureZNoneZ_ok(o: number): number {
7020 if(!isWasmInitialized) {
7021 throw new Error("initializeWasm() must be awaited first!");
7023 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_ok(o);
7024 return nativeResponseValue;
7026 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_err(void);
7028 export function CResult_CVec_SignatureZNoneZ_err(): number {
7029 if(!isWasmInitialized) {
7030 throw new Error("initializeWasm() must be awaited first!");
7032 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_err();
7033 return nativeResponseValue;
7035 // bool CResult_CVec_SignatureZNoneZ_is_ok(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR o);
7037 export function CResult_CVec_SignatureZNoneZ_is_ok(o: number): boolean {
7038 if(!isWasmInitialized) {
7039 throw new Error("initializeWasm() must be awaited first!");
7041 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_is_ok(o);
7042 return nativeResponseValue;
7044 // void CResult_CVec_SignatureZNoneZ_free(struct LDKCResult_CVec_SignatureZNoneZ _res);
7046 export function CResult_CVec_SignatureZNoneZ_free(_res: number): void {
7047 if(!isWasmInitialized) {
7048 throw new Error("initializeWasm() must be awaited first!");
7050 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_free(_res);
7051 // debug statements here
7053 // uintptr_t CResult_CVec_SignatureZNoneZ_clone_ptr(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR arg);
7055 export function CResult_CVec_SignatureZNoneZ_clone_ptr(arg: number): number {
7056 if(!isWasmInitialized) {
7057 throw new Error("initializeWasm() must be awaited first!");
7059 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone_ptr(arg);
7060 return nativeResponseValue;
7062 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_clone(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR orig);
7064 export function CResult_CVec_SignatureZNoneZ_clone(orig: number): number {
7065 if(!isWasmInitialized) {
7066 throw new Error("initializeWasm() must be awaited first!");
7068 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone(orig);
7069 return nativeResponseValue;
7071 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_ok(struct LDKShutdownScript o);
7073 export function CResult_ShutdownScriptDecodeErrorZ_ok(o: number): number {
7074 if(!isWasmInitialized) {
7075 throw new Error("initializeWasm() must be awaited first!");
7077 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_ok(o);
7078 return nativeResponseValue;
7080 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_err(struct LDKDecodeError e);
7082 export function CResult_ShutdownScriptDecodeErrorZ_err(e: number): number {
7083 if(!isWasmInitialized) {
7084 throw new Error("initializeWasm() must be awaited first!");
7086 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_err(e);
7087 return nativeResponseValue;
7089 // bool CResult_ShutdownScriptDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR o);
7091 export function CResult_ShutdownScriptDecodeErrorZ_is_ok(o: number): boolean {
7092 if(!isWasmInitialized) {
7093 throw new Error("initializeWasm() must be awaited first!");
7095 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(o);
7096 return nativeResponseValue;
7098 // void CResult_ShutdownScriptDecodeErrorZ_free(struct LDKCResult_ShutdownScriptDecodeErrorZ _res);
7100 export function CResult_ShutdownScriptDecodeErrorZ_free(_res: number): void {
7101 if(!isWasmInitialized) {
7102 throw new Error("initializeWasm() must be awaited first!");
7104 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_free(_res);
7105 // debug statements here
7107 // uintptr_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg);
7109 export function CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg: number): number {
7110 if(!isWasmInitialized) {
7111 throw new Error("initializeWasm() must be awaited first!");
7113 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg);
7114 return nativeResponseValue;
7116 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_clone(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR orig);
7118 export function CResult_ShutdownScriptDecodeErrorZ_clone(orig: number): number {
7119 if(!isWasmInitialized) {
7120 throw new Error("initializeWasm() must be awaited first!");
7122 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone(orig);
7123 return nativeResponseValue;
7125 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_ok(struct LDKShutdownScript o);
7127 export function CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o: number): number {
7128 if(!isWasmInitialized) {
7129 throw new Error("initializeWasm() must be awaited first!");
7131 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o);
7132 return nativeResponseValue;
7134 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_err(struct LDKInvalidShutdownScript e);
7136 export function CResult_ShutdownScriptInvalidShutdownScriptZ_err(e: number): number {
7137 if(!isWasmInitialized) {
7138 throw new Error("initializeWasm() must be awaited first!");
7140 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err(e);
7141 return nativeResponseValue;
7143 // bool CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR o);
7145 export function CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o: number): boolean {
7146 if(!isWasmInitialized) {
7147 throw new Error("initializeWasm() must be awaited first!");
7149 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o);
7150 return nativeResponseValue;
7152 // void CResult_ShutdownScriptInvalidShutdownScriptZ_free(struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res);
7154 export function CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res: number): void {
7155 if(!isWasmInitialized) {
7156 throw new Error("initializeWasm() must be awaited first!");
7158 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res);
7159 // debug statements here
7161 // uintptr_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg);
7163 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg: number): number {
7164 if(!isWasmInitialized) {
7165 throw new Error("initializeWasm() must be awaited first!");
7167 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg);
7168 return nativeResponseValue;
7170 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_clone(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR orig);
7172 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig: number): number {
7173 if(!isWasmInitialized) {
7174 throw new Error("initializeWasm() must be awaited first!");
7176 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig);
7177 return nativeResponseValue;
7179 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_ok(struct LDKRouteHop o);
7181 export function CResult_RouteHopDecodeErrorZ_ok(o: number): number {
7182 if(!isWasmInitialized) {
7183 throw new Error("initializeWasm() must be awaited first!");
7185 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_ok(o);
7186 return nativeResponseValue;
7188 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_err(struct LDKDecodeError e);
7190 export function CResult_RouteHopDecodeErrorZ_err(e: number): number {
7191 if(!isWasmInitialized) {
7192 throw new Error("initializeWasm() must be awaited first!");
7194 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_err(e);
7195 return nativeResponseValue;
7197 // bool CResult_RouteHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR o);
7199 export function CResult_RouteHopDecodeErrorZ_is_ok(o: number): boolean {
7200 if(!isWasmInitialized) {
7201 throw new Error("initializeWasm() must be awaited first!");
7203 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_is_ok(o);
7204 return nativeResponseValue;
7206 // void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
7208 export function CResult_RouteHopDecodeErrorZ_free(_res: number): void {
7209 if(!isWasmInitialized) {
7210 throw new Error("initializeWasm() must be awaited first!");
7212 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_free(_res);
7213 // debug statements here
7215 // uintptr_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg);
7217 export function CResult_RouteHopDecodeErrorZ_clone_ptr(arg: number): number {
7218 if(!isWasmInitialized) {
7219 throw new Error("initializeWasm() must be awaited first!");
7221 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone_ptr(arg);
7222 return nativeResponseValue;
7224 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
7226 export function CResult_RouteHopDecodeErrorZ_clone(orig: number): number {
7227 if(!isWasmInitialized) {
7228 throw new Error("initializeWasm() must be awaited first!");
7230 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone(orig);
7231 return nativeResponseValue;
7233 // void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
7235 export function CVec_RouteHopZ_free(_res: number): void {
7236 if(!isWasmInitialized) {
7237 throw new Error("initializeWasm() must be awaited first!");
7239 const nativeResponseValue = wasm.TS_CVec_RouteHopZ_free(_res);
7240 // debug statements here
7242 // void CVec_CVec_RouteHopZZ_free(struct LDKCVec_CVec_RouteHopZZ _res);
7244 export function CVec_CVec_RouteHopZZ_free(_res: number): void {
7245 if(!isWasmInitialized) {
7246 throw new Error("initializeWasm() must be awaited first!");
7248 const nativeResponseValue = wasm.TS_CVec_CVec_RouteHopZZ_free(_res);
7249 // debug statements here
7251 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
7253 export function CResult_RouteDecodeErrorZ_ok(o: number): number {
7254 if(!isWasmInitialized) {
7255 throw new Error("initializeWasm() must be awaited first!");
7257 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_ok(o);
7258 return nativeResponseValue;
7260 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
7262 export function CResult_RouteDecodeErrorZ_err(e: number): number {
7263 if(!isWasmInitialized) {
7264 throw new Error("initializeWasm() must be awaited first!");
7266 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_err(e);
7267 return nativeResponseValue;
7269 // bool CResult_RouteDecodeErrorZ_is_ok(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR o);
7271 export function CResult_RouteDecodeErrorZ_is_ok(o: number): boolean {
7272 if(!isWasmInitialized) {
7273 throw new Error("initializeWasm() must be awaited first!");
7275 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_is_ok(o);
7276 return nativeResponseValue;
7278 // void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
7280 export function CResult_RouteDecodeErrorZ_free(_res: number): void {
7281 if(!isWasmInitialized) {
7282 throw new Error("initializeWasm() must be awaited first!");
7284 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_free(_res);
7285 // debug statements here
7287 // uintptr_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg);
7289 export function CResult_RouteDecodeErrorZ_clone_ptr(arg: number): number {
7290 if(!isWasmInitialized) {
7291 throw new Error("initializeWasm() must be awaited first!");
7293 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone_ptr(arg);
7294 return nativeResponseValue;
7296 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
7298 export function CResult_RouteDecodeErrorZ_clone(orig: number): number {
7299 if(!isWasmInitialized) {
7300 throw new Error("initializeWasm() must be awaited first!");
7302 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone(orig);
7303 return nativeResponseValue;
7305 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_ok(struct LDKRouteParameters o);
7307 export function CResult_RouteParametersDecodeErrorZ_ok(o: number): number {
7308 if(!isWasmInitialized) {
7309 throw new Error("initializeWasm() must be awaited first!");
7311 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_ok(o);
7312 return nativeResponseValue;
7314 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_err(struct LDKDecodeError e);
7316 export function CResult_RouteParametersDecodeErrorZ_err(e: number): number {
7317 if(!isWasmInitialized) {
7318 throw new Error("initializeWasm() must be awaited first!");
7320 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_err(e);
7321 return nativeResponseValue;
7323 // bool CResult_RouteParametersDecodeErrorZ_is_ok(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR o);
7325 export function CResult_RouteParametersDecodeErrorZ_is_ok(o: number): boolean {
7326 if(!isWasmInitialized) {
7327 throw new Error("initializeWasm() must be awaited first!");
7329 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_is_ok(o);
7330 return nativeResponseValue;
7332 // void CResult_RouteParametersDecodeErrorZ_free(struct LDKCResult_RouteParametersDecodeErrorZ _res);
7334 export function CResult_RouteParametersDecodeErrorZ_free(_res: number): void {
7335 if(!isWasmInitialized) {
7336 throw new Error("initializeWasm() must be awaited first!");
7338 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_free(_res);
7339 // debug statements here
7341 // uintptr_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg);
7343 export function CResult_RouteParametersDecodeErrorZ_clone_ptr(arg: number): number {
7344 if(!isWasmInitialized) {
7345 throw new Error("initializeWasm() must be awaited first!");
7347 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(arg);
7348 return nativeResponseValue;
7350 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_clone(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR orig);
7352 export function CResult_RouteParametersDecodeErrorZ_clone(orig: number): number {
7353 if(!isWasmInitialized) {
7354 throw new Error("initializeWasm() must be awaited first!");
7356 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone(orig);
7357 return nativeResponseValue;
7359 // void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
7361 export function CVec_RouteHintZ_free(_res: number): void {
7362 if(!isWasmInitialized) {
7363 throw new Error("initializeWasm() must be awaited first!");
7365 const nativeResponseValue = wasm.TS_CVec_RouteHintZ_free(_res);
7366 // debug statements here
7368 // struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
7370 export function COption_u64Z_some(o: bigint): number {
7371 if(!isWasmInitialized) {
7372 throw new Error("initializeWasm() must be awaited first!");
7374 const nativeResponseValue = wasm.TS_COption_u64Z_some(o);
7375 return nativeResponseValue;
7377 // struct LDKCOption_u64Z COption_u64Z_none(void);
7379 export function COption_u64Z_none(): number {
7380 if(!isWasmInitialized) {
7381 throw new Error("initializeWasm() must be awaited first!");
7383 const nativeResponseValue = wasm.TS_COption_u64Z_none();
7384 return nativeResponseValue;
7386 // void COption_u64Z_free(struct LDKCOption_u64Z _res);
7388 export function COption_u64Z_free(_res: number): void {
7389 if(!isWasmInitialized) {
7390 throw new Error("initializeWasm() must be awaited first!");
7392 const nativeResponseValue = wasm.TS_COption_u64Z_free(_res);
7393 // debug statements here
7395 // uintptr_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg);
7397 export function COption_u64Z_clone_ptr(arg: number): number {
7398 if(!isWasmInitialized) {
7399 throw new Error("initializeWasm() must be awaited first!");
7401 const nativeResponseValue = wasm.TS_COption_u64Z_clone_ptr(arg);
7402 return nativeResponseValue;
7404 // struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
7406 export function COption_u64Z_clone(orig: number): number {
7407 if(!isWasmInitialized) {
7408 throw new Error("initializeWasm() must be awaited first!");
7410 const nativeResponseValue = wasm.TS_COption_u64Z_clone(orig);
7411 return nativeResponseValue;
7413 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_ok(struct LDKPaymentParameters o);
7415 export function CResult_PaymentParametersDecodeErrorZ_ok(o: number): number {
7416 if(!isWasmInitialized) {
7417 throw new Error("initializeWasm() must be awaited first!");
7419 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_ok(o);
7420 return nativeResponseValue;
7422 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_err(struct LDKDecodeError e);
7424 export function CResult_PaymentParametersDecodeErrorZ_err(e: number): number {
7425 if(!isWasmInitialized) {
7426 throw new Error("initializeWasm() must be awaited first!");
7428 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_err(e);
7429 return nativeResponseValue;
7431 // bool CResult_PaymentParametersDecodeErrorZ_is_ok(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR o);
7433 export function CResult_PaymentParametersDecodeErrorZ_is_ok(o: number): boolean {
7434 if(!isWasmInitialized) {
7435 throw new Error("initializeWasm() must be awaited first!");
7437 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_is_ok(o);
7438 return nativeResponseValue;
7440 // void CResult_PaymentParametersDecodeErrorZ_free(struct LDKCResult_PaymentParametersDecodeErrorZ _res);
7442 export function CResult_PaymentParametersDecodeErrorZ_free(_res: number): void {
7443 if(!isWasmInitialized) {
7444 throw new Error("initializeWasm() must be awaited first!");
7446 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_free(_res);
7447 // debug statements here
7449 // uintptr_t CResult_PaymentParametersDecodeErrorZ_clone_ptr(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR arg);
7451 export function CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg: number): number {
7452 if(!isWasmInitialized) {
7453 throw new Error("initializeWasm() must be awaited first!");
7455 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg);
7456 return nativeResponseValue;
7458 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_clone(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR orig);
7460 export function CResult_PaymentParametersDecodeErrorZ_clone(orig: number): number {
7461 if(!isWasmInitialized) {
7462 throw new Error("initializeWasm() must be awaited first!");
7464 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone(orig);
7465 return nativeResponseValue;
7467 // void CVec_RouteHintHopZ_free(struct LDKCVec_RouteHintHopZ _res);
7469 export function CVec_RouteHintHopZ_free(_res: number): void {
7470 if(!isWasmInitialized) {
7471 throw new Error("initializeWasm() must be awaited first!");
7473 const nativeResponseValue = wasm.TS_CVec_RouteHintHopZ_free(_res);
7474 // debug statements here
7476 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_ok(struct LDKRouteHint o);
7478 export function CResult_RouteHintDecodeErrorZ_ok(o: number): number {
7479 if(!isWasmInitialized) {
7480 throw new Error("initializeWasm() must be awaited first!");
7482 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_ok(o);
7483 return nativeResponseValue;
7485 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_err(struct LDKDecodeError e);
7487 export function CResult_RouteHintDecodeErrorZ_err(e: number): number {
7488 if(!isWasmInitialized) {
7489 throw new Error("initializeWasm() must be awaited first!");
7491 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_err(e);
7492 return nativeResponseValue;
7494 // bool CResult_RouteHintDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR o);
7496 export function CResult_RouteHintDecodeErrorZ_is_ok(o: number): boolean {
7497 if(!isWasmInitialized) {
7498 throw new Error("initializeWasm() must be awaited first!");
7500 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_is_ok(o);
7501 return nativeResponseValue;
7503 // void CResult_RouteHintDecodeErrorZ_free(struct LDKCResult_RouteHintDecodeErrorZ _res);
7505 export function CResult_RouteHintDecodeErrorZ_free(_res: number): void {
7506 if(!isWasmInitialized) {
7507 throw new Error("initializeWasm() must be awaited first!");
7509 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_free(_res);
7510 // debug statements here
7512 // uintptr_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg);
7514 export function CResult_RouteHintDecodeErrorZ_clone_ptr(arg: number): number {
7515 if(!isWasmInitialized) {
7516 throw new Error("initializeWasm() must be awaited first!");
7518 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone_ptr(arg);
7519 return nativeResponseValue;
7521 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_clone(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR orig);
7523 export function CResult_RouteHintDecodeErrorZ_clone(orig: number): number {
7524 if(!isWasmInitialized) {
7525 throw new Error("initializeWasm() must be awaited first!");
7527 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone(orig);
7528 return nativeResponseValue;
7530 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_ok(struct LDKRouteHintHop o);
7532 export function CResult_RouteHintHopDecodeErrorZ_ok(o: number): number {
7533 if(!isWasmInitialized) {
7534 throw new Error("initializeWasm() must be awaited first!");
7536 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_ok(o);
7537 return nativeResponseValue;
7539 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_err(struct LDKDecodeError e);
7541 export function CResult_RouteHintHopDecodeErrorZ_err(e: number): number {
7542 if(!isWasmInitialized) {
7543 throw new Error("initializeWasm() must be awaited first!");
7545 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_err(e);
7546 return nativeResponseValue;
7548 // bool CResult_RouteHintHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR o);
7550 export function CResult_RouteHintHopDecodeErrorZ_is_ok(o: number): boolean {
7551 if(!isWasmInitialized) {
7552 throw new Error("initializeWasm() must be awaited first!");
7554 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_is_ok(o);
7555 return nativeResponseValue;
7557 // void CResult_RouteHintHopDecodeErrorZ_free(struct LDKCResult_RouteHintHopDecodeErrorZ _res);
7559 export function CResult_RouteHintHopDecodeErrorZ_free(_res: number): void {
7560 if(!isWasmInitialized) {
7561 throw new Error("initializeWasm() must be awaited first!");
7563 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_free(_res);
7564 // debug statements here
7566 // uintptr_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg);
7568 export function CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg: number): number {
7569 if(!isWasmInitialized) {
7570 throw new Error("initializeWasm() must be awaited first!");
7572 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg);
7573 return nativeResponseValue;
7575 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_clone(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR orig);
7577 export function CResult_RouteHintHopDecodeErrorZ_clone(orig: number): number {
7578 if(!isWasmInitialized) {
7579 throw new Error("initializeWasm() must be awaited first!");
7581 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone(orig);
7582 return nativeResponseValue;
7584 // void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
7586 export function CVec_ChannelDetailsZ_free(_res: number): void {
7587 if(!isWasmInitialized) {
7588 throw new Error("initializeWasm() must be awaited first!");
7590 const nativeResponseValue = wasm.TS_CVec_ChannelDetailsZ_free(_res);
7591 // debug statements here
7593 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
7595 export function CResult_RouteLightningErrorZ_ok(o: number): number {
7596 if(!isWasmInitialized) {
7597 throw new Error("initializeWasm() must be awaited first!");
7599 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_ok(o);
7600 return nativeResponseValue;
7602 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
7604 export function CResult_RouteLightningErrorZ_err(e: number): number {
7605 if(!isWasmInitialized) {
7606 throw new Error("initializeWasm() must be awaited first!");
7608 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_err(e);
7609 return nativeResponseValue;
7611 // bool CResult_RouteLightningErrorZ_is_ok(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR o);
7613 export function CResult_RouteLightningErrorZ_is_ok(o: number): boolean {
7614 if(!isWasmInitialized) {
7615 throw new Error("initializeWasm() must be awaited first!");
7617 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_is_ok(o);
7618 return nativeResponseValue;
7620 // void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
7622 export function CResult_RouteLightningErrorZ_free(_res: number): void {
7623 if(!isWasmInitialized) {
7624 throw new Error("initializeWasm() must be awaited first!");
7626 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_free(_res);
7627 // debug statements here
7629 // uintptr_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg);
7631 export function CResult_RouteLightningErrorZ_clone_ptr(arg: number): number {
7632 if(!isWasmInitialized) {
7633 throw new Error("initializeWasm() must be awaited first!");
7635 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone_ptr(arg);
7636 return nativeResponseValue;
7638 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
7640 export function CResult_RouteLightningErrorZ_clone(orig: number): number {
7641 if(!isWasmInitialized) {
7642 throw new Error("initializeWasm() must be awaited first!");
7644 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone(orig);
7645 return nativeResponseValue;
7647 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_ok(struct LDKTxOut o);
7649 export function CResult_TxOutAccessErrorZ_ok(o: number): number {
7650 if(!isWasmInitialized) {
7651 throw new Error("initializeWasm() must be awaited first!");
7653 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_ok(o);
7654 return nativeResponseValue;
7656 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_err(enum LDKAccessError e);
7658 export function CResult_TxOutAccessErrorZ_err(e: AccessError): number {
7659 if(!isWasmInitialized) {
7660 throw new Error("initializeWasm() must be awaited first!");
7662 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_err(e);
7663 return nativeResponseValue;
7665 // bool CResult_TxOutAccessErrorZ_is_ok(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR o);
7667 export function CResult_TxOutAccessErrorZ_is_ok(o: number): boolean {
7668 if(!isWasmInitialized) {
7669 throw new Error("initializeWasm() must be awaited first!");
7671 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_is_ok(o);
7672 return nativeResponseValue;
7674 // void CResult_TxOutAccessErrorZ_free(struct LDKCResult_TxOutAccessErrorZ _res);
7676 export function CResult_TxOutAccessErrorZ_free(_res: number): void {
7677 if(!isWasmInitialized) {
7678 throw new Error("initializeWasm() must be awaited first!");
7680 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_free(_res);
7681 // debug statements here
7683 // uintptr_t CResult_TxOutAccessErrorZ_clone_ptr(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR arg);
7685 export function CResult_TxOutAccessErrorZ_clone_ptr(arg: number): number {
7686 if(!isWasmInitialized) {
7687 throw new Error("initializeWasm() must be awaited first!");
7689 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone_ptr(arg);
7690 return nativeResponseValue;
7692 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_clone(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR orig);
7694 export function CResult_TxOutAccessErrorZ_clone(orig: number): number {
7695 if(!isWasmInitialized) {
7696 throw new Error("initializeWasm() must be awaited first!");
7698 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone(orig);
7699 return nativeResponseValue;
7701 // uintptr_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg);
7703 export function C2Tuple_usizeTransactionZ_clone_ptr(arg: number): number {
7704 if(!isWasmInitialized) {
7705 throw new Error("initializeWasm() must be awaited first!");
7707 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone_ptr(arg);
7708 return nativeResponseValue;
7710 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_clone(const struct LDKC2Tuple_usizeTransactionZ *NONNULL_PTR orig);
7712 export function C2Tuple_usizeTransactionZ_clone(orig: number): number {
7713 if(!isWasmInitialized) {
7714 throw new Error("initializeWasm() must be awaited first!");
7716 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone(orig);
7717 return nativeResponseValue;
7719 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
7721 export function C2Tuple_usizeTransactionZ_new(a: number, b: number): number {
7722 if(!isWasmInitialized) {
7723 throw new Error("initializeWasm() must be awaited first!");
7725 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_new(a, b);
7726 return nativeResponseValue;
7728 // void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
7730 export function C2Tuple_usizeTransactionZ_free(_res: number): void {
7731 if(!isWasmInitialized) {
7732 throw new Error("initializeWasm() must be awaited first!");
7734 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_free(_res);
7735 // debug statements here
7737 // void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
7739 export function CVec_C2Tuple_usizeTransactionZZ_free(_res: number): void {
7740 if(!isWasmInitialized) {
7741 throw new Error("initializeWasm() must be awaited first!");
7743 const nativeResponseValue = wasm.TS_CVec_C2Tuple_usizeTransactionZZ_free(_res);
7744 // debug statements here
7746 // void CVec_TxidZ_free(struct LDKCVec_TxidZ _res);
7748 export function CVec_TxidZ_free(_res: number): void {
7749 if(!isWasmInitialized) {
7750 throw new Error("initializeWasm() must be awaited first!");
7752 const nativeResponseValue = wasm.TS_CVec_TxidZ_free(_res);
7753 // debug statements here
7755 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_ok(void);
7757 export function CResult_NoneChannelMonitorUpdateErrZ_ok(): number {
7758 if(!isWasmInitialized) {
7759 throw new Error("initializeWasm() must be awaited first!");
7761 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_ok();
7762 return nativeResponseValue;
7764 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_err(enum LDKChannelMonitorUpdateErr e);
7766 export function CResult_NoneChannelMonitorUpdateErrZ_err(e: ChannelMonitorUpdateErr): number {
7767 if(!isWasmInitialized) {
7768 throw new Error("initializeWasm() must be awaited first!");
7770 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_err(e);
7771 return nativeResponseValue;
7773 // bool CResult_NoneChannelMonitorUpdateErrZ_is_ok(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR o);
7775 export function CResult_NoneChannelMonitorUpdateErrZ_is_ok(o: number): boolean {
7776 if(!isWasmInitialized) {
7777 throw new Error("initializeWasm() must be awaited first!");
7779 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_is_ok(o);
7780 return nativeResponseValue;
7782 // void CResult_NoneChannelMonitorUpdateErrZ_free(struct LDKCResult_NoneChannelMonitorUpdateErrZ _res);
7784 export function CResult_NoneChannelMonitorUpdateErrZ_free(_res: number): void {
7785 if(!isWasmInitialized) {
7786 throw new Error("initializeWasm() must be awaited first!");
7788 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_free(_res);
7789 // debug statements here
7791 // uintptr_t CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR arg);
7793 export function CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg: number): number {
7794 if(!isWasmInitialized) {
7795 throw new Error("initializeWasm() must be awaited first!");
7797 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg);
7798 return nativeResponseValue;
7800 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_clone(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR orig);
7802 export function CResult_NoneChannelMonitorUpdateErrZ_clone(orig: number): number {
7803 if(!isWasmInitialized) {
7804 throw new Error("initializeWasm() must be awaited first!");
7806 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_clone(orig);
7807 return nativeResponseValue;
7809 // void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
7811 export function CVec_MonitorEventZ_free(_res: number): void {
7812 if(!isWasmInitialized) {
7813 throw new Error("initializeWasm() must be awaited first!");
7815 const nativeResponseValue = wasm.TS_CVec_MonitorEventZ_free(_res);
7816 // debug statements here
7818 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_some(struct LDKC2Tuple_usizeTransactionZ o);
7820 export function COption_C2Tuple_usizeTransactionZZ_some(o: number): number {
7821 if(!isWasmInitialized) {
7822 throw new Error("initializeWasm() must be awaited first!");
7824 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_some(o);
7825 return nativeResponseValue;
7827 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_none(void);
7829 export function COption_C2Tuple_usizeTransactionZZ_none(): number {
7830 if(!isWasmInitialized) {
7831 throw new Error("initializeWasm() must be awaited first!");
7833 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_none();
7834 return nativeResponseValue;
7836 // void COption_C2Tuple_usizeTransactionZZ_free(struct LDKCOption_C2Tuple_usizeTransactionZZ _res);
7838 export function COption_C2Tuple_usizeTransactionZZ_free(_res: number): void {
7839 if(!isWasmInitialized) {
7840 throw new Error("initializeWasm() must be awaited first!");
7842 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_free(_res);
7843 // debug statements here
7845 // uintptr_t COption_C2Tuple_usizeTransactionZZ_clone_ptr(LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR arg);
7847 export function COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg: number): number {
7848 if(!isWasmInitialized) {
7849 throw new Error("initializeWasm() must be awaited first!");
7851 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg);
7852 return nativeResponseValue;
7854 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_clone(const struct LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR orig);
7856 export function COption_C2Tuple_usizeTransactionZZ_clone(orig: number): number {
7857 if(!isWasmInitialized) {
7858 throw new Error("initializeWasm() must be awaited first!");
7860 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_clone(orig);
7861 return nativeResponseValue;
7863 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_some(struct LDKClosureReason o);
7865 export function COption_ClosureReasonZ_some(o: number): number {
7866 if(!isWasmInitialized) {
7867 throw new Error("initializeWasm() must be awaited first!");
7869 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_some(o);
7870 return nativeResponseValue;
7872 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_none(void);
7874 export function COption_ClosureReasonZ_none(): number {
7875 if(!isWasmInitialized) {
7876 throw new Error("initializeWasm() must be awaited first!");
7878 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_none();
7879 return nativeResponseValue;
7881 // void COption_ClosureReasonZ_free(struct LDKCOption_ClosureReasonZ _res);
7883 export function COption_ClosureReasonZ_free(_res: number): void {
7884 if(!isWasmInitialized) {
7885 throw new Error("initializeWasm() must be awaited first!");
7887 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_free(_res);
7888 // debug statements here
7890 // uintptr_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg);
7892 export function COption_ClosureReasonZ_clone_ptr(arg: number): number {
7893 if(!isWasmInitialized) {
7894 throw new Error("initializeWasm() must be awaited first!");
7896 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone_ptr(arg);
7897 return nativeResponseValue;
7899 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_clone(const struct LDKCOption_ClosureReasonZ *NONNULL_PTR orig);
7901 export function COption_ClosureReasonZ_clone(orig: number): number {
7902 if(!isWasmInitialized) {
7903 throw new Error("initializeWasm() must be awaited first!");
7905 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone(orig);
7906 return nativeResponseValue;
7908 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_ok(struct LDKCOption_ClosureReasonZ o);
7910 export function CResult_COption_ClosureReasonZDecodeErrorZ_ok(o: number): number {
7911 if(!isWasmInitialized) {
7912 throw new Error("initializeWasm() must be awaited first!");
7914 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(o);
7915 return nativeResponseValue;
7917 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_err(struct LDKDecodeError e);
7919 export function CResult_COption_ClosureReasonZDecodeErrorZ_err(e: number): number {
7920 if(!isWasmInitialized) {
7921 throw new Error("initializeWasm() must be awaited first!");
7923 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(e);
7924 return nativeResponseValue;
7926 // bool CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR o);
7928 export function CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o: number): boolean {
7929 if(!isWasmInitialized) {
7930 throw new Error("initializeWasm() must be awaited first!");
7932 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o);
7933 return nativeResponseValue;
7935 // void CResult_COption_ClosureReasonZDecodeErrorZ_free(struct LDKCResult_COption_ClosureReasonZDecodeErrorZ _res);
7937 export function CResult_COption_ClosureReasonZDecodeErrorZ_free(_res: number): void {
7938 if(!isWasmInitialized) {
7939 throw new Error("initializeWasm() must be awaited first!");
7941 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(_res);
7942 // debug statements here
7944 // uintptr_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg);
7946 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg: number): number {
7947 if(!isWasmInitialized) {
7948 throw new Error("initializeWasm() must be awaited first!");
7950 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg);
7951 return nativeResponseValue;
7953 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_clone(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR orig);
7955 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig: number): number {
7956 if(!isWasmInitialized) {
7957 throw new Error("initializeWasm() must be awaited first!");
7959 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig);
7960 return nativeResponseValue;
7962 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_some(struct LDKNetworkUpdate o);
7964 export function COption_NetworkUpdateZ_some(o: number): number {
7965 if(!isWasmInitialized) {
7966 throw new Error("initializeWasm() must be awaited first!");
7968 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_some(o);
7969 return nativeResponseValue;
7971 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_none(void);
7973 export function COption_NetworkUpdateZ_none(): number {
7974 if(!isWasmInitialized) {
7975 throw new Error("initializeWasm() must be awaited first!");
7977 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_none();
7978 return nativeResponseValue;
7980 // void COption_NetworkUpdateZ_free(struct LDKCOption_NetworkUpdateZ _res);
7982 export function COption_NetworkUpdateZ_free(_res: number): void {
7983 if(!isWasmInitialized) {
7984 throw new Error("initializeWasm() must be awaited first!");
7986 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_free(_res);
7987 // debug statements here
7989 // uintptr_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg);
7991 export function COption_NetworkUpdateZ_clone_ptr(arg: number): number {
7992 if(!isWasmInitialized) {
7993 throw new Error("initializeWasm() must be awaited first!");
7995 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone_ptr(arg);
7996 return nativeResponseValue;
7998 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_clone(const struct LDKCOption_NetworkUpdateZ *NONNULL_PTR orig);
8000 export function COption_NetworkUpdateZ_clone(orig: number): number {
8001 if(!isWasmInitialized) {
8002 throw new Error("initializeWasm() must be awaited first!");
8004 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone(orig);
8005 return nativeResponseValue;
8007 // void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
8009 export function CVec_SpendableOutputDescriptorZ_free(_res: number): void {
8010 if(!isWasmInitialized) {
8011 throw new Error("initializeWasm() must be awaited first!");
8013 const nativeResponseValue = wasm.TS_CVec_SpendableOutputDescriptorZ_free(_res);
8014 // debug statements here
8016 // struct LDKCOption_EventZ COption_EventZ_some(struct LDKEvent o);
8018 export function COption_EventZ_some(o: number): number {
8019 if(!isWasmInitialized) {
8020 throw new Error("initializeWasm() must be awaited first!");
8022 const nativeResponseValue = wasm.TS_COption_EventZ_some(o);
8023 return nativeResponseValue;
8025 // struct LDKCOption_EventZ COption_EventZ_none(void);
8027 export function COption_EventZ_none(): number {
8028 if(!isWasmInitialized) {
8029 throw new Error("initializeWasm() must be awaited first!");
8031 const nativeResponseValue = wasm.TS_COption_EventZ_none();
8032 return nativeResponseValue;
8034 // void COption_EventZ_free(struct LDKCOption_EventZ _res);
8036 export function COption_EventZ_free(_res: number): void {
8037 if(!isWasmInitialized) {
8038 throw new Error("initializeWasm() must be awaited first!");
8040 const nativeResponseValue = wasm.TS_COption_EventZ_free(_res);
8041 // debug statements here
8043 // uintptr_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg);
8045 export function COption_EventZ_clone_ptr(arg: number): number {
8046 if(!isWasmInitialized) {
8047 throw new Error("initializeWasm() must be awaited first!");
8049 const nativeResponseValue = wasm.TS_COption_EventZ_clone_ptr(arg);
8050 return nativeResponseValue;
8052 // struct LDKCOption_EventZ COption_EventZ_clone(const struct LDKCOption_EventZ *NONNULL_PTR orig);
8054 export function COption_EventZ_clone(orig: number): number {
8055 if(!isWasmInitialized) {
8056 throw new Error("initializeWasm() must be awaited first!");
8058 const nativeResponseValue = wasm.TS_COption_EventZ_clone(orig);
8059 return nativeResponseValue;
8061 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_ok(struct LDKCOption_EventZ o);
8063 export function CResult_COption_EventZDecodeErrorZ_ok(o: number): number {
8064 if(!isWasmInitialized) {
8065 throw new Error("initializeWasm() must be awaited first!");
8067 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_ok(o);
8068 return nativeResponseValue;
8070 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_err(struct LDKDecodeError e);
8072 export function CResult_COption_EventZDecodeErrorZ_err(e: number): number {
8073 if(!isWasmInitialized) {
8074 throw new Error("initializeWasm() must be awaited first!");
8076 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_err(e);
8077 return nativeResponseValue;
8079 // bool CResult_COption_EventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR o);
8081 export function CResult_COption_EventZDecodeErrorZ_is_ok(o: number): boolean {
8082 if(!isWasmInitialized) {
8083 throw new Error("initializeWasm() must be awaited first!");
8085 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_is_ok(o);
8086 return nativeResponseValue;
8088 // void CResult_COption_EventZDecodeErrorZ_free(struct LDKCResult_COption_EventZDecodeErrorZ _res);
8090 export function CResult_COption_EventZDecodeErrorZ_free(_res: number): void {
8091 if(!isWasmInitialized) {
8092 throw new Error("initializeWasm() must be awaited first!");
8094 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_free(_res);
8095 // debug statements here
8097 // uintptr_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg);
8099 export function CResult_COption_EventZDecodeErrorZ_clone_ptr(arg: number): number {
8100 if(!isWasmInitialized) {
8101 throw new Error("initializeWasm() must be awaited first!");
8103 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(arg);
8104 return nativeResponseValue;
8106 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_clone(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR orig);
8108 export function CResult_COption_EventZDecodeErrorZ_clone(orig: number): number {
8109 if(!isWasmInitialized) {
8110 throw new Error("initializeWasm() must be awaited first!");
8112 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone(orig);
8113 return nativeResponseValue;
8115 // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
8117 export function CVec_MessageSendEventZ_free(_res: number): void {
8118 if(!isWasmInitialized) {
8119 throw new Error("initializeWasm() must be awaited first!");
8121 const nativeResponseValue = wasm.TS_CVec_MessageSendEventZ_free(_res);
8122 // debug statements here
8124 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_ok(struct LDKFixedPenaltyScorer o);
8126 export function CResult_FixedPenaltyScorerDecodeErrorZ_ok(o: number): number {
8127 if(!isWasmInitialized) {
8128 throw new Error("initializeWasm() must be awaited first!");
8130 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok(o);
8131 return nativeResponseValue;
8133 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_err(struct LDKDecodeError e);
8135 export function CResult_FixedPenaltyScorerDecodeErrorZ_err(e: number): number {
8136 if(!isWasmInitialized) {
8137 throw new Error("initializeWasm() must be awaited first!");
8139 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_err(e);
8140 return nativeResponseValue;
8142 // bool CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR o);
8144 export function CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o: number): boolean {
8145 if(!isWasmInitialized) {
8146 throw new Error("initializeWasm() must be awaited first!");
8148 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o);
8149 return nativeResponseValue;
8151 // void CResult_FixedPenaltyScorerDecodeErrorZ_free(struct LDKCResult_FixedPenaltyScorerDecodeErrorZ _res);
8153 export function CResult_FixedPenaltyScorerDecodeErrorZ_free(_res: number): void {
8154 if(!isWasmInitialized) {
8155 throw new Error("initializeWasm() must be awaited first!");
8157 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_free(_res);
8158 // debug statements here
8160 // uintptr_t CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR arg);
8162 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg: number): number {
8163 if(!isWasmInitialized) {
8164 throw new Error("initializeWasm() must be awaited first!");
8166 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg);
8167 return nativeResponseValue;
8169 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_clone(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR orig);
8171 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig: number): number {
8172 if(!isWasmInitialized) {
8173 throw new Error("initializeWasm() must be awaited first!");
8175 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig);
8176 return nativeResponseValue;
8178 // struct LDKCResult_ScoringParametersDecodeErrorZ CResult_ScoringParametersDecodeErrorZ_ok(struct LDKScoringParameters o);
8180 export function CResult_ScoringParametersDecodeErrorZ_ok(o: number): number {
8181 if(!isWasmInitialized) {
8182 throw new Error("initializeWasm() must be awaited first!");
8184 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_ok(o);
8185 return nativeResponseValue;
8187 // struct LDKCResult_ScoringParametersDecodeErrorZ CResult_ScoringParametersDecodeErrorZ_err(struct LDKDecodeError e);
8189 export function CResult_ScoringParametersDecodeErrorZ_err(e: number): number {
8190 if(!isWasmInitialized) {
8191 throw new Error("initializeWasm() must be awaited first!");
8193 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_err(e);
8194 return nativeResponseValue;
8196 // bool CResult_ScoringParametersDecodeErrorZ_is_ok(const struct LDKCResult_ScoringParametersDecodeErrorZ *NONNULL_PTR o);
8198 export function CResult_ScoringParametersDecodeErrorZ_is_ok(o: number): boolean {
8199 if(!isWasmInitialized) {
8200 throw new Error("initializeWasm() must be awaited first!");
8202 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_is_ok(o);
8203 return nativeResponseValue;
8205 // void CResult_ScoringParametersDecodeErrorZ_free(struct LDKCResult_ScoringParametersDecodeErrorZ _res);
8207 export function CResult_ScoringParametersDecodeErrorZ_free(_res: number): void {
8208 if(!isWasmInitialized) {
8209 throw new Error("initializeWasm() must be awaited first!");
8211 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_free(_res);
8212 // debug statements here
8214 // uintptr_t CResult_ScoringParametersDecodeErrorZ_clone_ptr(LDKCResult_ScoringParametersDecodeErrorZ *NONNULL_PTR arg);
8216 export function CResult_ScoringParametersDecodeErrorZ_clone_ptr(arg: number): number {
8217 if(!isWasmInitialized) {
8218 throw new Error("initializeWasm() must be awaited first!");
8220 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_clone_ptr(arg);
8221 return nativeResponseValue;
8223 // struct LDKCResult_ScoringParametersDecodeErrorZ CResult_ScoringParametersDecodeErrorZ_clone(const struct LDKCResult_ScoringParametersDecodeErrorZ *NONNULL_PTR orig);
8225 export function CResult_ScoringParametersDecodeErrorZ_clone(orig: number): number {
8226 if(!isWasmInitialized) {
8227 throw new Error("initializeWasm() must be awaited first!");
8229 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_clone(orig);
8230 return nativeResponseValue;
8232 // struct LDKCResult_ScorerDecodeErrorZ CResult_ScorerDecodeErrorZ_ok(struct LDKScorer o);
8234 export function CResult_ScorerDecodeErrorZ_ok(o: number): number {
8235 if(!isWasmInitialized) {
8236 throw new Error("initializeWasm() must be awaited first!");
8238 const nativeResponseValue = wasm.TS_CResult_ScorerDecodeErrorZ_ok(o);
8239 return nativeResponseValue;
8241 // struct LDKCResult_ScorerDecodeErrorZ CResult_ScorerDecodeErrorZ_err(struct LDKDecodeError e);
8243 export function CResult_ScorerDecodeErrorZ_err(e: number): number {
8244 if(!isWasmInitialized) {
8245 throw new Error("initializeWasm() must be awaited first!");
8247 const nativeResponseValue = wasm.TS_CResult_ScorerDecodeErrorZ_err(e);
8248 return nativeResponseValue;
8250 // bool CResult_ScorerDecodeErrorZ_is_ok(const struct LDKCResult_ScorerDecodeErrorZ *NONNULL_PTR o);
8252 export function CResult_ScorerDecodeErrorZ_is_ok(o: number): boolean {
8253 if(!isWasmInitialized) {
8254 throw new Error("initializeWasm() must be awaited first!");
8256 const nativeResponseValue = wasm.TS_CResult_ScorerDecodeErrorZ_is_ok(o);
8257 return nativeResponseValue;
8259 // void CResult_ScorerDecodeErrorZ_free(struct LDKCResult_ScorerDecodeErrorZ _res);
8261 export function CResult_ScorerDecodeErrorZ_free(_res: number): void {
8262 if(!isWasmInitialized) {
8263 throw new Error("initializeWasm() must be awaited first!");
8265 const nativeResponseValue = wasm.TS_CResult_ScorerDecodeErrorZ_free(_res);
8266 // debug statements here
8268 // struct LDKCResult_ProbabilisticScoringParametersDecodeErrorZ CResult_ProbabilisticScoringParametersDecodeErrorZ_ok(struct LDKProbabilisticScoringParameters o);
8270 export function CResult_ProbabilisticScoringParametersDecodeErrorZ_ok(o: number): number {
8271 if(!isWasmInitialized) {
8272 throw new Error("initializeWasm() must be awaited first!");
8274 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScoringParametersDecodeErrorZ_ok(o);
8275 return nativeResponseValue;
8277 // struct LDKCResult_ProbabilisticScoringParametersDecodeErrorZ CResult_ProbabilisticScoringParametersDecodeErrorZ_err(struct LDKDecodeError e);
8279 export function CResult_ProbabilisticScoringParametersDecodeErrorZ_err(e: number): number {
8280 if(!isWasmInitialized) {
8281 throw new Error("initializeWasm() must be awaited first!");
8283 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScoringParametersDecodeErrorZ_err(e);
8284 return nativeResponseValue;
8286 // bool CResult_ProbabilisticScoringParametersDecodeErrorZ_is_ok(const struct LDKCResult_ProbabilisticScoringParametersDecodeErrorZ *NONNULL_PTR o);
8288 export function CResult_ProbabilisticScoringParametersDecodeErrorZ_is_ok(o: number): boolean {
8289 if(!isWasmInitialized) {
8290 throw new Error("initializeWasm() must be awaited first!");
8292 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScoringParametersDecodeErrorZ_is_ok(o);
8293 return nativeResponseValue;
8295 // void CResult_ProbabilisticScoringParametersDecodeErrorZ_free(struct LDKCResult_ProbabilisticScoringParametersDecodeErrorZ _res);
8297 export function CResult_ProbabilisticScoringParametersDecodeErrorZ_free(_res: number): void {
8298 if(!isWasmInitialized) {
8299 throw new Error("initializeWasm() must be awaited first!");
8301 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScoringParametersDecodeErrorZ_free(_res);
8302 // debug statements here
8304 // uintptr_t CResult_ProbabilisticScoringParametersDecodeErrorZ_clone_ptr(LDKCResult_ProbabilisticScoringParametersDecodeErrorZ *NONNULL_PTR arg);
8306 export function CResult_ProbabilisticScoringParametersDecodeErrorZ_clone_ptr(arg: number): number {
8307 if(!isWasmInitialized) {
8308 throw new Error("initializeWasm() must be awaited first!");
8310 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScoringParametersDecodeErrorZ_clone_ptr(arg);
8311 return nativeResponseValue;
8313 // struct LDKCResult_ProbabilisticScoringParametersDecodeErrorZ CResult_ProbabilisticScoringParametersDecodeErrorZ_clone(const struct LDKCResult_ProbabilisticScoringParametersDecodeErrorZ *NONNULL_PTR orig);
8315 export function CResult_ProbabilisticScoringParametersDecodeErrorZ_clone(orig: number): number {
8316 if(!isWasmInitialized) {
8317 throw new Error("initializeWasm() must be awaited first!");
8319 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScoringParametersDecodeErrorZ_clone(orig);
8320 return nativeResponseValue;
8322 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
8324 export function CResult_InitFeaturesDecodeErrorZ_ok(o: number): number {
8325 if(!isWasmInitialized) {
8326 throw new Error("initializeWasm() must be awaited first!");
8328 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_ok(o);
8329 return nativeResponseValue;
8331 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8333 export function CResult_InitFeaturesDecodeErrorZ_err(e: number): number {
8334 if(!isWasmInitialized) {
8335 throw new Error("initializeWasm() must be awaited first!");
8337 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_err(e);
8338 return nativeResponseValue;
8340 // bool CResult_InitFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR o);
8342 export function CResult_InitFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8343 if(!isWasmInitialized) {
8344 throw new Error("initializeWasm() must be awaited first!");
8346 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_is_ok(o);
8347 return nativeResponseValue;
8349 // void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
8351 export function CResult_InitFeaturesDecodeErrorZ_free(_res: number): void {
8352 if(!isWasmInitialized) {
8353 throw new Error("initializeWasm() must be awaited first!");
8355 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_free(_res);
8356 // debug statements here
8358 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
8360 export function CResult_ChannelFeaturesDecodeErrorZ_ok(o: number): number {
8361 if(!isWasmInitialized) {
8362 throw new Error("initializeWasm() must be awaited first!");
8364 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_ok(o);
8365 return nativeResponseValue;
8367 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8369 export function CResult_ChannelFeaturesDecodeErrorZ_err(e: number): number {
8370 if(!isWasmInitialized) {
8371 throw new Error("initializeWasm() must be awaited first!");
8373 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_err(e);
8374 return nativeResponseValue;
8376 // bool CResult_ChannelFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR o);
8378 export function CResult_ChannelFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8379 if(!isWasmInitialized) {
8380 throw new Error("initializeWasm() must be awaited first!");
8382 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(o);
8383 return nativeResponseValue;
8385 // void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
8387 export function CResult_ChannelFeaturesDecodeErrorZ_free(_res: number): void {
8388 if(!isWasmInitialized) {
8389 throw new Error("initializeWasm() must be awaited first!");
8391 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_free(_res);
8392 // debug statements here
8394 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
8396 export function CResult_NodeFeaturesDecodeErrorZ_ok(o: number): number {
8397 if(!isWasmInitialized) {
8398 throw new Error("initializeWasm() must be awaited first!");
8400 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_ok(o);
8401 return nativeResponseValue;
8403 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8405 export function CResult_NodeFeaturesDecodeErrorZ_err(e: number): number {
8406 if(!isWasmInitialized) {
8407 throw new Error("initializeWasm() must be awaited first!");
8409 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_err(e);
8410 return nativeResponseValue;
8412 // bool CResult_NodeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR o);
8414 export function CResult_NodeFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8415 if(!isWasmInitialized) {
8416 throw new Error("initializeWasm() must be awaited first!");
8418 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(o);
8419 return nativeResponseValue;
8421 // void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
8423 export function CResult_NodeFeaturesDecodeErrorZ_free(_res: number): void {
8424 if(!isWasmInitialized) {
8425 throw new Error("initializeWasm() must be awaited first!");
8427 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_free(_res);
8428 // debug statements here
8430 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_ok(struct LDKInvoiceFeatures o);
8432 export function CResult_InvoiceFeaturesDecodeErrorZ_ok(o: number): number {
8433 if(!isWasmInitialized) {
8434 throw new Error("initializeWasm() must be awaited first!");
8436 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_ok(o);
8437 return nativeResponseValue;
8439 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8441 export function CResult_InvoiceFeaturesDecodeErrorZ_err(e: number): number {
8442 if(!isWasmInitialized) {
8443 throw new Error("initializeWasm() must be awaited first!");
8445 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_err(e);
8446 return nativeResponseValue;
8448 // bool CResult_InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
8450 export function CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8451 if(!isWasmInitialized) {
8452 throw new Error("initializeWasm() must be awaited first!");
8454 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o);
8455 return nativeResponseValue;
8457 // void CResult_InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_InvoiceFeaturesDecodeErrorZ _res);
8459 export function CResult_InvoiceFeaturesDecodeErrorZ_free(_res: number): void {
8460 if(!isWasmInitialized) {
8461 throw new Error("initializeWasm() must be awaited first!");
8463 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_free(_res);
8464 // debug statements here
8466 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_ok(struct LDKChannelTypeFeatures o);
8468 export function CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o: number): number {
8469 if(!isWasmInitialized) {
8470 throw new Error("initializeWasm() must be awaited first!");
8472 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o);
8473 return nativeResponseValue;
8475 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8477 export function CResult_ChannelTypeFeaturesDecodeErrorZ_err(e: number): number {
8478 if(!isWasmInitialized) {
8479 throw new Error("initializeWasm() must be awaited first!");
8481 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(e);
8482 return nativeResponseValue;
8484 // bool CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR o);
8486 export function CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8487 if(!isWasmInitialized) {
8488 throw new Error("initializeWasm() must be awaited first!");
8490 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o);
8491 return nativeResponseValue;
8493 // void CResult_ChannelTypeFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res);
8495 export function CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res: number): void {
8496 if(!isWasmInitialized) {
8497 throw new Error("initializeWasm() must be awaited first!");
8499 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res);
8500 // debug statements here
8502 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKDelayedPaymentOutputDescriptor o);
8504 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o: number): number {
8505 if(!isWasmInitialized) {
8506 throw new Error("initializeWasm() must be awaited first!");
8508 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o);
8509 return nativeResponseValue;
8511 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
8513 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e: number): number {
8514 if(!isWasmInitialized) {
8515 throw new Error("initializeWasm() must be awaited first!");
8517 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e);
8518 return nativeResponseValue;
8520 // bool CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
8522 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
8523 if(!isWasmInitialized) {
8524 throw new Error("initializeWasm() must be awaited first!");
8526 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
8527 return nativeResponseValue;
8529 // void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res);
8531 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res: number): void {
8532 if(!isWasmInitialized) {
8533 throw new Error("initializeWasm() must be awaited first!");
8535 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res);
8536 // debug statements here
8538 // uintptr_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
8540 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
8541 if(!isWasmInitialized) {
8542 throw new Error("initializeWasm() must be awaited first!");
8544 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
8545 return nativeResponseValue;
8547 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
8549 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig: number): number {
8550 if(!isWasmInitialized) {
8551 throw new Error("initializeWasm() must be awaited first!");
8553 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig);
8554 return nativeResponseValue;
8556 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKStaticPaymentOutputDescriptor o);
8558 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o: number): number {
8559 if(!isWasmInitialized) {
8560 throw new Error("initializeWasm() must be awaited first!");
8562 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o);
8563 return nativeResponseValue;
8565 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
8567 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e: number): number {
8568 if(!isWasmInitialized) {
8569 throw new Error("initializeWasm() must be awaited first!");
8571 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e);
8572 return nativeResponseValue;
8574 // bool CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
8576 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
8577 if(!isWasmInitialized) {
8578 throw new Error("initializeWasm() must be awaited first!");
8580 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
8581 return nativeResponseValue;
8583 // void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res);
8585 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res: number): void {
8586 if(!isWasmInitialized) {
8587 throw new Error("initializeWasm() must be awaited first!");
8589 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res);
8590 // debug statements here
8592 // uintptr_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
8594 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
8595 if(!isWasmInitialized) {
8596 throw new Error("initializeWasm() must be awaited first!");
8598 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
8599 return nativeResponseValue;
8601 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
8603 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig: number): number {
8604 if(!isWasmInitialized) {
8605 throw new Error("initializeWasm() must be awaited first!");
8607 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig);
8608 return nativeResponseValue;
8610 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
8612 export function CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o: number): number {
8613 if(!isWasmInitialized) {
8614 throw new Error("initializeWasm() must be awaited first!");
8616 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o);
8617 return nativeResponseValue;
8619 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
8621 export function CResult_SpendableOutputDescriptorDecodeErrorZ_err(e: number): number {
8622 if(!isWasmInitialized) {
8623 throw new Error("initializeWasm() must be awaited first!");
8625 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(e);
8626 return nativeResponseValue;
8628 // bool CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
8630 export function CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
8631 if(!isWasmInitialized) {
8632 throw new Error("initializeWasm() must be awaited first!");
8634 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o);
8635 return nativeResponseValue;
8637 // void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
8639 export function CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: number): void {
8640 if(!isWasmInitialized) {
8641 throw new Error("initializeWasm() must be awaited first!");
8643 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res);
8644 // debug statements here
8646 // uintptr_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
8648 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
8649 if(!isWasmInitialized) {
8650 throw new Error("initializeWasm() must be awaited first!");
8652 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg);
8653 return nativeResponseValue;
8655 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
8657 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: number): number {
8658 if(!isWasmInitialized) {
8659 throw new Error("initializeWasm() must be awaited first!");
8661 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig);
8662 return nativeResponseValue;
8664 // void CVec_PaymentPreimageZ_free(struct LDKCVec_PaymentPreimageZ _res);
8666 export function CVec_PaymentPreimageZ_free(_res: number): void {
8667 if(!isWasmInitialized) {
8668 throw new Error("initializeWasm() must be awaited first!");
8670 const nativeResponseValue = wasm.TS_CVec_PaymentPreimageZ_free(_res);
8671 // debug statements here
8673 // uintptr_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg);
8675 export function C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg: number): number {
8676 if(!isWasmInitialized) {
8677 throw new Error("initializeWasm() must be awaited first!");
8679 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg);
8680 return nativeResponseValue;
8682 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_clone(const struct LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR orig);
8684 export function C2Tuple_SignatureCVec_SignatureZZ_clone(orig: number): number {
8685 if(!isWasmInitialized) {
8686 throw new Error("initializeWasm() must be awaited first!");
8688 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone(orig);
8689 return nativeResponseValue;
8691 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_new(struct LDKSignature a, struct LDKCVec_SignatureZ b);
8693 export function C2Tuple_SignatureCVec_SignatureZZ_new(a: number, b: number): number {
8694 if(!isWasmInitialized) {
8695 throw new Error("initializeWasm() must be awaited first!");
8697 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_new(a, b);
8698 return nativeResponseValue;
8700 // void C2Tuple_SignatureCVec_SignatureZZ_free(struct LDKC2Tuple_SignatureCVec_SignatureZZ _res);
8702 export function C2Tuple_SignatureCVec_SignatureZZ_free(_res: number): void {
8703 if(!isWasmInitialized) {
8704 throw new Error("initializeWasm() must be awaited first!");
8706 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_free(_res);
8707 // debug statements here
8709 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(struct LDKC2Tuple_SignatureCVec_SignatureZZ o);
8711 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o: number): number {
8712 if(!isWasmInitialized) {
8713 throw new Error("initializeWasm() must be awaited first!");
8715 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o);
8716 return nativeResponseValue;
8718 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(void);
8720 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(): number {
8721 if(!isWasmInitialized) {
8722 throw new Error("initializeWasm() must be awaited first!");
8724 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
8725 return nativeResponseValue;
8727 // bool CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR o);
8729 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o: number): boolean {
8730 if(!isWasmInitialized) {
8731 throw new Error("initializeWasm() must be awaited first!");
8733 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o);
8734 return nativeResponseValue;
8736 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res);
8738 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res: number): void {
8739 if(!isWasmInitialized) {
8740 throw new Error("initializeWasm() must be awaited first!");
8742 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res);
8743 // debug statements here
8745 // uintptr_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg);
8747 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg: number): number {
8748 if(!isWasmInitialized) {
8749 throw new Error("initializeWasm() must be awaited first!");
8751 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg);
8752 return nativeResponseValue;
8754 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR orig);
8756 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig: number): number {
8757 if(!isWasmInitialized) {
8758 throw new Error("initializeWasm() must be awaited first!");
8760 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig);
8761 return nativeResponseValue;
8763 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_ok(struct LDKSignature o);
8765 export function CResult_SignatureNoneZ_ok(o: number): number {
8766 if(!isWasmInitialized) {
8767 throw new Error("initializeWasm() must be awaited first!");
8769 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_ok(o);
8770 return nativeResponseValue;
8772 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_err(void);
8774 export function CResult_SignatureNoneZ_err(): number {
8775 if(!isWasmInitialized) {
8776 throw new Error("initializeWasm() must be awaited first!");
8778 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_err();
8779 return nativeResponseValue;
8781 // bool CResult_SignatureNoneZ_is_ok(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR o);
8783 export function CResult_SignatureNoneZ_is_ok(o: number): boolean {
8784 if(!isWasmInitialized) {
8785 throw new Error("initializeWasm() must be awaited first!");
8787 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_is_ok(o);
8788 return nativeResponseValue;
8790 // void CResult_SignatureNoneZ_free(struct LDKCResult_SignatureNoneZ _res);
8792 export function CResult_SignatureNoneZ_free(_res: number): void {
8793 if(!isWasmInitialized) {
8794 throw new Error("initializeWasm() must be awaited first!");
8796 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_free(_res);
8797 // debug statements here
8799 // uintptr_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg);
8801 export function CResult_SignatureNoneZ_clone_ptr(arg: number): number {
8802 if(!isWasmInitialized) {
8803 throw new Error("initializeWasm() must be awaited first!");
8805 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone_ptr(arg);
8806 return nativeResponseValue;
8808 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_clone(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR orig);
8810 export function CResult_SignatureNoneZ_clone(orig: number): number {
8811 if(!isWasmInitialized) {
8812 throw new Error("initializeWasm() must be awaited first!");
8814 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone(orig);
8815 return nativeResponseValue;
8817 // uintptr_t C2Tuple_SignatureSignatureZ_clone_ptr(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR arg);
8819 export function C2Tuple_SignatureSignatureZ_clone_ptr(arg: number): number {
8820 if(!isWasmInitialized) {
8821 throw new Error("initializeWasm() must be awaited first!");
8823 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_clone_ptr(arg);
8824 return nativeResponseValue;
8826 // struct LDKC2Tuple_SignatureSignatureZ C2Tuple_SignatureSignatureZ_clone(const struct LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR orig);
8828 export function C2Tuple_SignatureSignatureZ_clone(orig: number): number {
8829 if(!isWasmInitialized) {
8830 throw new Error("initializeWasm() must be awaited first!");
8832 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_clone(orig);
8833 return nativeResponseValue;
8835 // struct LDKC2Tuple_SignatureSignatureZ C2Tuple_SignatureSignatureZ_new(struct LDKSignature a, struct LDKSignature b);
8837 export function C2Tuple_SignatureSignatureZ_new(a: number, b: number): number {
8838 if(!isWasmInitialized) {
8839 throw new Error("initializeWasm() must be awaited first!");
8841 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_new(a, b);
8842 return nativeResponseValue;
8844 // void C2Tuple_SignatureSignatureZ_free(struct LDKC2Tuple_SignatureSignatureZ _res);
8846 export function C2Tuple_SignatureSignatureZ_free(_res: number): void {
8847 if(!isWasmInitialized) {
8848 throw new Error("initializeWasm() must be awaited first!");
8850 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_free(_res);
8851 // debug statements here
8853 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_ok(struct LDKC2Tuple_SignatureSignatureZ o);
8855 export function CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o: number): number {
8856 if(!isWasmInitialized) {
8857 throw new Error("initializeWasm() must be awaited first!");
8859 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o);
8860 return nativeResponseValue;
8862 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_err(void);
8864 export function CResult_C2Tuple_SignatureSignatureZNoneZ_err(): number {
8865 if(!isWasmInitialized) {
8866 throw new Error("initializeWasm() must be awaited first!");
8868 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_err();
8869 return nativeResponseValue;
8871 // bool CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR o);
8873 export function CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o: number): boolean {
8874 if(!isWasmInitialized) {
8875 throw new Error("initializeWasm() must be awaited first!");
8877 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o);
8878 return nativeResponseValue;
8880 // void CResult_C2Tuple_SignatureSignatureZNoneZ_free(struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ _res);
8882 export function CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res: number): void {
8883 if(!isWasmInitialized) {
8884 throw new Error("initializeWasm() must be awaited first!");
8886 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res);
8887 // debug statements here
8889 // uintptr_t CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR arg);
8891 export function CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg: number): number {
8892 if(!isWasmInitialized) {
8893 throw new Error("initializeWasm() must be awaited first!");
8895 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg);
8896 return nativeResponseValue;
8898 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR orig);
8900 export function CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig: number): number {
8901 if(!isWasmInitialized) {
8902 throw new Error("initializeWasm() must be awaited first!");
8904 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig);
8905 return nativeResponseValue;
8907 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_ok(struct LDKSecretKey o);
8909 export function CResult_SecretKeyNoneZ_ok(o: number): number {
8910 if(!isWasmInitialized) {
8911 throw new Error("initializeWasm() must be awaited first!");
8913 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_ok(o);
8914 return nativeResponseValue;
8916 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_err(void);
8918 export function CResult_SecretKeyNoneZ_err(): number {
8919 if(!isWasmInitialized) {
8920 throw new Error("initializeWasm() must be awaited first!");
8922 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_err();
8923 return nativeResponseValue;
8925 // bool CResult_SecretKeyNoneZ_is_ok(const struct LDKCResult_SecretKeyNoneZ *NONNULL_PTR o);
8927 export function CResult_SecretKeyNoneZ_is_ok(o: number): boolean {
8928 if(!isWasmInitialized) {
8929 throw new Error("initializeWasm() must be awaited first!");
8931 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_is_ok(o);
8932 return nativeResponseValue;
8934 // void CResult_SecretKeyNoneZ_free(struct LDKCResult_SecretKeyNoneZ _res);
8936 export function CResult_SecretKeyNoneZ_free(_res: number): void {
8937 if(!isWasmInitialized) {
8938 throw new Error("initializeWasm() must be awaited first!");
8940 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_free(_res);
8941 // debug statements here
8943 // uintptr_t CResult_SecretKeyNoneZ_clone_ptr(LDKCResult_SecretKeyNoneZ *NONNULL_PTR arg);
8945 export function CResult_SecretKeyNoneZ_clone_ptr(arg: number): number {
8946 if(!isWasmInitialized) {
8947 throw new Error("initializeWasm() must be awaited first!");
8949 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_clone_ptr(arg);
8950 return nativeResponseValue;
8952 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_clone(const struct LDKCResult_SecretKeyNoneZ *NONNULL_PTR orig);
8954 export function CResult_SecretKeyNoneZ_clone(orig: number): number {
8955 if(!isWasmInitialized) {
8956 throw new Error("initializeWasm() must be awaited first!");
8958 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_clone(orig);
8959 return nativeResponseValue;
8961 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_ok(struct LDKSign o);
8963 export function CResult_SignDecodeErrorZ_ok(o: number): number {
8964 if(!isWasmInitialized) {
8965 throw new Error("initializeWasm() must be awaited first!");
8967 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_ok(o);
8968 return nativeResponseValue;
8970 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_err(struct LDKDecodeError e);
8972 export function CResult_SignDecodeErrorZ_err(e: number): number {
8973 if(!isWasmInitialized) {
8974 throw new Error("initializeWasm() must be awaited first!");
8976 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_err(e);
8977 return nativeResponseValue;
8979 // bool CResult_SignDecodeErrorZ_is_ok(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR o);
8981 export function CResult_SignDecodeErrorZ_is_ok(o: number): boolean {
8982 if(!isWasmInitialized) {
8983 throw new Error("initializeWasm() must be awaited first!");
8985 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_is_ok(o);
8986 return nativeResponseValue;
8988 // void CResult_SignDecodeErrorZ_free(struct LDKCResult_SignDecodeErrorZ _res);
8990 export function CResult_SignDecodeErrorZ_free(_res: number): void {
8991 if(!isWasmInitialized) {
8992 throw new Error("initializeWasm() must be awaited first!");
8994 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_free(_res);
8995 // debug statements here
8997 // uintptr_t CResult_SignDecodeErrorZ_clone_ptr(LDKCResult_SignDecodeErrorZ *NONNULL_PTR arg);
8999 export function CResult_SignDecodeErrorZ_clone_ptr(arg: number): number {
9000 if(!isWasmInitialized) {
9001 throw new Error("initializeWasm() must be awaited first!");
9003 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone_ptr(arg);
9004 return nativeResponseValue;
9006 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_clone(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR orig);
9008 export function CResult_SignDecodeErrorZ_clone(orig: number): number {
9009 if(!isWasmInitialized) {
9010 throw new Error("initializeWasm() must be awaited first!");
9012 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone(orig);
9013 return nativeResponseValue;
9015 // void CVec_u5Z_free(struct LDKCVec_u5Z _res);
9017 export function CVec_u5Z_free(_res: number): void {
9018 if(!isWasmInitialized) {
9019 throw new Error("initializeWasm() must be awaited first!");
9021 const nativeResponseValue = wasm.TS_CVec_u5Z_free(_res);
9022 // debug statements here
9024 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_ok(struct LDKRecoverableSignature o);
9026 export function CResult_RecoverableSignatureNoneZ_ok(o: number): number {
9027 if(!isWasmInitialized) {
9028 throw new Error("initializeWasm() must be awaited first!");
9030 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_ok(o);
9031 return nativeResponseValue;
9033 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_err(void);
9035 export function CResult_RecoverableSignatureNoneZ_err(): number {
9036 if(!isWasmInitialized) {
9037 throw new Error("initializeWasm() must be awaited first!");
9039 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_err();
9040 return nativeResponseValue;
9042 // bool CResult_RecoverableSignatureNoneZ_is_ok(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR o);
9044 export function CResult_RecoverableSignatureNoneZ_is_ok(o: number): boolean {
9045 if(!isWasmInitialized) {
9046 throw new Error("initializeWasm() must be awaited first!");
9048 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_is_ok(o);
9049 return nativeResponseValue;
9051 // void CResult_RecoverableSignatureNoneZ_free(struct LDKCResult_RecoverableSignatureNoneZ _res);
9053 export function CResult_RecoverableSignatureNoneZ_free(_res: number): void {
9054 if(!isWasmInitialized) {
9055 throw new Error("initializeWasm() must be awaited first!");
9057 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_free(_res);
9058 // debug statements here
9060 // uintptr_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg);
9062 export function CResult_RecoverableSignatureNoneZ_clone_ptr(arg: number): number {
9063 if(!isWasmInitialized) {
9064 throw new Error("initializeWasm() must be awaited first!");
9066 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone_ptr(arg);
9067 return nativeResponseValue;
9069 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_clone(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR orig);
9071 export function CResult_RecoverableSignatureNoneZ_clone(orig: number): number {
9072 if(!isWasmInitialized) {
9073 throw new Error("initializeWasm() must be awaited first!");
9075 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone(orig);
9076 return nativeResponseValue;
9078 // void CVec_u8Z_free(struct LDKCVec_u8Z _res);
9080 export function CVec_u8Z_free(_res: number): void {
9081 if(!isWasmInitialized) {
9082 throw new Error("initializeWasm() must be awaited first!");
9084 const nativeResponseValue = wasm.TS_CVec_u8Z_free(_res);
9085 // debug statements here
9087 // void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
9089 export function CVec_CVec_u8ZZ_free(_res: number): void {
9090 if(!isWasmInitialized) {
9091 throw new Error("initializeWasm() must be awaited first!");
9093 const nativeResponseValue = wasm.TS_CVec_CVec_u8ZZ_free(_res);
9094 // debug statements here
9096 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_ok(struct LDKCVec_CVec_u8ZZ o);
9098 export function CResult_CVec_CVec_u8ZZNoneZ_ok(o: number): number {
9099 if(!isWasmInitialized) {
9100 throw new Error("initializeWasm() must be awaited first!");
9102 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_ok(o);
9103 return nativeResponseValue;
9105 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
9107 export function CResult_CVec_CVec_u8ZZNoneZ_err(): number {
9108 if(!isWasmInitialized) {
9109 throw new Error("initializeWasm() must be awaited first!");
9111 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_err();
9112 return nativeResponseValue;
9114 // bool CResult_CVec_CVec_u8ZZNoneZ_is_ok(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR o);
9116 export function CResult_CVec_CVec_u8ZZNoneZ_is_ok(o: number): boolean {
9117 if(!isWasmInitialized) {
9118 throw new Error("initializeWasm() must be awaited first!");
9120 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(o);
9121 return nativeResponseValue;
9123 // void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
9125 export function CResult_CVec_CVec_u8ZZNoneZ_free(_res: number): void {
9126 if(!isWasmInitialized) {
9127 throw new Error("initializeWasm() must be awaited first!");
9129 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_free(_res);
9130 // debug statements here
9132 // uintptr_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg);
9134 export function CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg: number): number {
9135 if(!isWasmInitialized) {
9136 throw new Error("initializeWasm() must be awaited first!");
9138 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg);
9139 return nativeResponseValue;
9141 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
9143 export function CResult_CVec_CVec_u8ZZNoneZ_clone(orig: number): number {
9144 if(!isWasmInitialized) {
9145 throw new Error("initializeWasm() must be awaited first!");
9147 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone(orig);
9148 return nativeResponseValue;
9150 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
9152 export function CResult_InMemorySignerDecodeErrorZ_ok(o: number): number {
9153 if(!isWasmInitialized) {
9154 throw new Error("initializeWasm() must be awaited first!");
9156 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_ok(o);
9157 return nativeResponseValue;
9159 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
9161 export function CResult_InMemorySignerDecodeErrorZ_err(e: number): number {
9162 if(!isWasmInitialized) {
9163 throw new Error("initializeWasm() must be awaited first!");
9165 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_err(e);
9166 return nativeResponseValue;
9168 // bool CResult_InMemorySignerDecodeErrorZ_is_ok(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR o);
9170 export function CResult_InMemorySignerDecodeErrorZ_is_ok(o: number): boolean {
9171 if(!isWasmInitialized) {
9172 throw new Error("initializeWasm() must be awaited first!");
9174 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_is_ok(o);
9175 return nativeResponseValue;
9177 // void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
9179 export function CResult_InMemorySignerDecodeErrorZ_free(_res: number): void {
9180 if(!isWasmInitialized) {
9181 throw new Error("initializeWasm() must be awaited first!");
9183 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_free(_res);
9184 // debug statements here
9186 // uintptr_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg);
9188 export function CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg: number): number {
9189 if(!isWasmInitialized) {
9190 throw new Error("initializeWasm() must be awaited first!");
9192 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg);
9193 return nativeResponseValue;
9195 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
9197 export function CResult_InMemorySignerDecodeErrorZ_clone(orig: number): number {
9198 if(!isWasmInitialized) {
9199 throw new Error("initializeWasm() must be awaited first!");
9201 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone(orig);
9202 return nativeResponseValue;
9204 // void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
9206 export function CVec_TxOutZ_free(_res: number): void {
9207 if(!isWasmInitialized) {
9208 throw new Error("initializeWasm() must be awaited first!");
9210 const nativeResponseValue = wasm.TS_CVec_TxOutZ_free(_res);
9211 // debug statements here
9213 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
9215 export function CResult_TransactionNoneZ_ok(o: number): number {
9216 if(!isWasmInitialized) {
9217 throw new Error("initializeWasm() must be awaited first!");
9219 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_ok(o);
9220 return nativeResponseValue;
9222 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
9224 export function CResult_TransactionNoneZ_err(): number {
9225 if(!isWasmInitialized) {
9226 throw new Error("initializeWasm() must be awaited first!");
9228 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_err();
9229 return nativeResponseValue;
9231 // bool CResult_TransactionNoneZ_is_ok(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR o);
9233 export function CResult_TransactionNoneZ_is_ok(o: number): boolean {
9234 if(!isWasmInitialized) {
9235 throw new Error("initializeWasm() must be awaited first!");
9237 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_is_ok(o);
9238 return nativeResponseValue;
9240 // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
9242 export function CResult_TransactionNoneZ_free(_res: number): void {
9243 if(!isWasmInitialized) {
9244 throw new Error("initializeWasm() must be awaited first!");
9246 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_free(_res);
9247 // debug statements here
9249 // uintptr_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg);
9251 export function CResult_TransactionNoneZ_clone_ptr(arg: number): number {
9252 if(!isWasmInitialized) {
9253 throw new Error("initializeWasm() must be awaited first!");
9255 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone_ptr(arg);
9256 return nativeResponseValue;
9258 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_clone(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR orig);
9260 export function CResult_TransactionNoneZ_clone(orig: number): number {
9261 if(!isWasmInitialized) {
9262 throw new Error("initializeWasm() must be awaited first!");
9264 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone(orig);
9265 return nativeResponseValue;
9267 // struct LDKCOption_u16Z COption_u16Z_some(uint16_t o);
9269 export function COption_u16Z_some(o: number): number {
9270 if(!isWasmInitialized) {
9271 throw new Error("initializeWasm() must be awaited first!");
9273 const nativeResponseValue = wasm.TS_COption_u16Z_some(o);
9274 return nativeResponseValue;
9276 // struct LDKCOption_u16Z COption_u16Z_none(void);
9278 export function COption_u16Z_none(): number {
9279 if(!isWasmInitialized) {
9280 throw new Error("initializeWasm() must be awaited first!");
9282 const nativeResponseValue = wasm.TS_COption_u16Z_none();
9283 return nativeResponseValue;
9285 // void COption_u16Z_free(struct LDKCOption_u16Z _res);
9287 export function COption_u16Z_free(_res: number): void {
9288 if(!isWasmInitialized) {
9289 throw new Error("initializeWasm() must be awaited first!");
9291 const nativeResponseValue = wasm.TS_COption_u16Z_free(_res);
9292 // debug statements here
9294 // uintptr_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg);
9296 export function COption_u16Z_clone_ptr(arg: number): number {
9297 if(!isWasmInitialized) {
9298 throw new Error("initializeWasm() must be awaited first!");
9300 const nativeResponseValue = wasm.TS_COption_u16Z_clone_ptr(arg);
9301 return nativeResponseValue;
9303 // struct LDKCOption_u16Z COption_u16Z_clone(const struct LDKCOption_u16Z *NONNULL_PTR orig);
9305 export function COption_u16Z_clone(orig: number): number {
9306 if(!isWasmInitialized) {
9307 throw new Error("initializeWasm() must be awaited first!");
9309 const nativeResponseValue = wasm.TS_COption_u16Z_clone(orig);
9310 return nativeResponseValue;
9312 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
9314 export function CResult_NoneAPIErrorZ_ok(): number {
9315 if(!isWasmInitialized) {
9316 throw new Error("initializeWasm() must be awaited first!");
9318 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_ok();
9319 return nativeResponseValue;
9321 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
9323 export function CResult_NoneAPIErrorZ_err(e: number): number {
9324 if(!isWasmInitialized) {
9325 throw new Error("initializeWasm() must be awaited first!");
9327 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_err(e);
9328 return nativeResponseValue;
9330 // bool CResult_NoneAPIErrorZ_is_ok(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR o);
9332 export function CResult_NoneAPIErrorZ_is_ok(o: number): boolean {
9333 if(!isWasmInitialized) {
9334 throw new Error("initializeWasm() must be awaited first!");
9336 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_is_ok(o);
9337 return nativeResponseValue;
9339 // void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
9341 export function CResult_NoneAPIErrorZ_free(_res: number): void {
9342 if(!isWasmInitialized) {
9343 throw new Error("initializeWasm() must be awaited first!");
9345 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_free(_res);
9346 // debug statements here
9348 // uintptr_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg);
9350 export function CResult_NoneAPIErrorZ_clone_ptr(arg: number): number {
9351 if(!isWasmInitialized) {
9352 throw new Error("initializeWasm() must be awaited first!");
9354 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone_ptr(arg);
9355 return nativeResponseValue;
9357 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
9359 export function CResult_NoneAPIErrorZ_clone(orig: number): number {
9360 if(!isWasmInitialized) {
9361 throw new Error("initializeWasm() must be awaited first!");
9363 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone(orig);
9364 return nativeResponseValue;
9366 // void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
9368 export function CVec_CResult_NoneAPIErrorZZ_free(_res: number): void {
9369 if(!isWasmInitialized) {
9370 throw new Error("initializeWasm() must be awaited first!");
9372 const nativeResponseValue = wasm.TS_CVec_CResult_NoneAPIErrorZZ_free(_res);
9373 // debug statements here
9375 // void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
9377 export function CVec_APIErrorZ_free(_res: number): void {
9378 if(!isWasmInitialized) {
9379 throw new Error("initializeWasm() must be awaited first!");
9381 const nativeResponseValue = wasm.TS_CVec_APIErrorZ_free(_res);
9382 // debug statements here
9384 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_ok(struct LDKThirtyTwoBytes o);
9386 export function CResult__u832APIErrorZ_ok(o: number): number {
9387 if(!isWasmInitialized) {
9388 throw new Error("initializeWasm() must be awaited first!");
9390 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_ok(o);
9391 return nativeResponseValue;
9393 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_err(struct LDKAPIError e);
9395 export function CResult__u832APIErrorZ_err(e: number): number {
9396 if(!isWasmInitialized) {
9397 throw new Error("initializeWasm() must be awaited first!");
9399 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_err(e);
9400 return nativeResponseValue;
9402 // bool CResult__u832APIErrorZ_is_ok(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR o);
9404 export function CResult__u832APIErrorZ_is_ok(o: number): boolean {
9405 if(!isWasmInitialized) {
9406 throw new Error("initializeWasm() must be awaited first!");
9408 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_is_ok(o);
9409 return nativeResponseValue;
9411 // void CResult__u832APIErrorZ_free(struct LDKCResult__u832APIErrorZ _res);
9413 export function CResult__u832APIErrorZ_free(_res: number): void {
9414 if(!isWasmInitialized) {
9415 throw new Error("initializeWasm() must be awaited first!");
9417 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_free(_res);
9418 // debug statements here
9420 // uintptr_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg);
9422 export function CResult__u832APIErrorZ_clone_ptr(arg: number): number {
9423 if(!isWasmInitialized) {
9424 throw new Error("initializeWasm() must be awaited first!");
9426 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone_ptr(arg);
9427 return nativeResponseValue;
9429 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_clone(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR orig);
9431 export function CResult__u832APIErrorZ_clone(orig: number): number {
9432 if(!isWasmInitialized) {
9433 throw new Error("initializeWasm() must be awaited first!");
9435 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone(orig);
9436 return nativeResponseValue;
9438 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_ok(struct LDKThirtyTwoBytes o);
9440 export function CResult_PaymentIdPaymentSendFailureZ_ok(o: number): number {
9441 if(!isWasmInitialized) {
9442 throw new Error("initializeWasm() must be awaited first!");
9444 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_ok(o);
9445 return nativeResponseValue;
9447 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
9449 export function CResult_PaymentIdPaymentSendFailureZ_err(e: number): number {
9450 if(!isWasmInitialized) {
9451 throw new Error("initializeWasm() must be awaited first!");
9453 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_err(e);
9454 return nativeResponseValue;
9456 // bool CResult_PaymentIdPaymentSendFailureZ_is_ok(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR o);
9458 export function CResult_PaymentIdPaymentSendFailureZ_is_ok(o: number): boolean {
9459 if(!isWasmInitialized) {
9460 throw new Error("initializeWasm() must be awaited first!");
9462 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_is_ok(o);
9463 return nativeResponseValue;
9465 // void CResult_PaymentIdPaymentSendFailureZ_free(struct LDKCResult_PaymentIdPaymentSendFailureZ _res);
9467 export function CResult_PaymentIdPaymentSendFailureZ_free(_res: number): void {
9468 if(!isWasmInitialized) {
9469 throw new Error("initializeWasm() must be awaited first!");
9471 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_free(_res);
9472 // debug statements here
9474 // uintptr_t CResult_PaymentIdPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR arg);
9476 export function CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg: number): number {
9477 if(!isWasmInitialized) {
9478 throw new Error("initializeWasm() must be awaited first!");
9480 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg);
9481 return nativeResponseValue;
9483 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_clone(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR orig);
9485 export function CResult_PaymentIdPaymentSendFailureZ_clone(orig: number): number {
9486 if(!isWasmInitialized) {
9487 throw new Error("initializeWasm() must be awaited first!");
9489 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone(orig);
9490 return nativeResponseValue;
9492 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
9494 export function CResult_NonePaymentSendFailureZ_ok(): number {
9495 if(!isWasmInitialized) {
9496 throw new Error("initializeWasm() must be awaited first!");
9498 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_ok();
9499 return nativeResponseValue;
9501 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
9503 export function CResult_NonePaymentSendFailureZ_err(e: number): number {
9504 if(!isWasmInitialized) {
9505 throw new Error("initializeWasm() must be awaited first!");
9507 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_err(e);
9508 return nativeResponseValue;
9510 // bool CResult_NonePaymentSendFailureZ_is_ok(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR o);
9512 export function CResult_NonePaymentSendFailureZ_is_ok(o: number): boolean {
9513 if(!isWasmInitialized) {
9514 throw new Error("initializeWasm() must be awaited first!");
9516 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_is_ok(o);
9517 return nativeResponseValue;
9519 // void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
9521 export function CResult_NonePaymentSendFailureZ_free(_res: number): void {
9522 if(!isWasmInitialized) {
9523 throw new Error("initializeWasm() must be awaited first!");
9525 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_free(_res);
9526 // debug statements here
9528 // uintptr_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg);
9530 export function CResult_NonePaymentSendFailureZ_clone_ptr(arg: number): number {
9531 if(!isWasmInitialized) {
9532 throw new Error("initializeWasm() must be awaited first!");
9534 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone_ptr(arg);
9535 return nativeResponseValue;
9537 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
9539 export function CResult_NonePaymentSendFailureZ_clone(orig: number): number {
9540 if(!isWasmInitialized) {
9541 throw new Error("initializeWasm() must be awaited first!");
9543 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone(orig);
9544 return nativeResponseValue;
9546 // uintptr_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg);
9548 export function C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg: number): number {
9549 if(!isWasmInitialized) {
9550 throw new Error("initializeWasm() must be awaited first!");
9552 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg);
9553 return nativeResponseValue;
9555 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_clone(const struct LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR orig);
9557 export function C2Tuple_PaymentHashPaymentIdZ_clone(orig: number): number {
9558 if(!isWasmInitialized) {
9559 throw new Error("initializeWasm() must be awaited first!");
9561 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone(orig);
9562 return nativeResponseValue;
9564 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
9566 export function C2Tuple_PaymentHashPaymentIdZ_new(a: number, b: number): number {
9567 if(!isWasmInitialized) {
9568 throw new Error("initializeWasm() must be awaited first!");
9570 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_new(a, b);
9571 return nativeResponseValue;
9573 // void C2Tuple_PaymentHashPaymentIdZ_free(struct LDKC2Tuple_PaymentHashPaymentIdZ _res);
9575 export function C2Tuple_PaymentHashPaymentIdZ_free(_res: number): void {
9576 if(!isWasmInitialized) {
9577 throw new Error("initializeWasm() must be awaited first!");
9579 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_free(_res);
9580 // debug statements here
9582 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(struct LDKC2Tuple_PaymentHashPaymentIdZ o);
9584 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o: number): number {
9585 if(!isWasmInitialized) {
9586 throw new Error("initializeWasm() must be awaited first!");
9588 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o);
9589 return nativeResponseValue;
9591 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
9593 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e: number): number {
9594 if(!isWasmInitialized) {
9595 throw new Error("initializeWasm() must be awaited first!");
9597 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e);
9598 return nativeResponseValue;
9600 // bool CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR o);
9602 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o: number): boolean {
9603 if(!isWasmInitialized) {
9604 throw new Error("initializeWasm() must be awaited first!");
9606 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o);
9607 return nativeResponseValue;
9609 // void CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ _res);
9611 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res: number): void {
9612 if(!isWasmInitialized) {
9613 throw new Error("initializeWasm() must be awaited first!");
9615 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res);
9616 // debug statements here
9618 // uintptr_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg);
9620 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg: number): number {
9621 if(!isWasmInitialized) {
9622 throw new Error("initializeWasm() must be awaited first!");
9624 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg);
9625 return nativeResponseValue;
9627 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR orig);
9629 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig: number): number {
9630 if(!isWasmInitialized) {
9631 throw new Error("initializeWasm() must be awaited first!");
9633 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig);
9634 return nativeResponseValue;
9636 // void CVec_NetAddressZ_free(struct LDKCVec_NetAddressZ _res);
9638 export function CVec_NetAddressZ_free(_res: number): void {
9639 if(!isWasmInitialized) {
9640 throw new Error("initializeWasm() must be awaited first!");
9642 const nativeResponseValue = wasm.TS_CVec_NetAddressZ_free(_res);
9643 // debug statements here
9645 // uintptr_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg);
9647 export function C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg: number): number {
9648 if(!isWasmInitialized) {
9649 throw new Error("initializeWasm() must be awaited first!");
9651 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg);
9652 return nativeResponseValue;
9654 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_clone(const struct LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR orig);
9656 export function C2Tuple_PaymentHashPaymentSecretZ_clone(orig: number): number {
9657 if(!isWasmInitialized) {
9658 throw new Error("initializeWasm() must be awaited first!");
9660 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone(orig);
9661 return nativeResponseValue;
9663 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
9665 export function C2Tuple_PaymentHashPaymentSecretZ_new(a: number, b: number): number {
9666 if(!isWasmInitialized) {
9667 throw new Error("initializeWasm() must be awaited first!");
9669 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_new(a, b);
9670 return nativeResponseValue;
9672 // void C2Tuple_PaymentHashPaymentSecretZ_free(struct LDKC2Tuple_PaymentHashPaymentSecretZ _res);
9674 export function C2Tuple_PaymentHashPaymentSecretZ_free(_res: number): void {
9675 if(!isWasmInitialized) {
9676 throw new Error("initializeWasm() must be awaited first!");
9678 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_free(_res);
9679 // debug statements here
9681 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
9683 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o: number): number {
9684 if(!isWasmInitialized) {
9685 throw new Error("initializeWasm() must be awaited first!");
9687 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o);
9688 return nativeResponseValue;
9690 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(void);
9692 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(): number {
9693 if(!isWasmInitialized) {
9694 throw new Error("initializeWasm() must be awaited first!");
9696 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err();
9697 return nativeResponseValue;
9699 // bool CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR o);
9701 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o: number): boolean {
9702 if(!isWasmInitialized) {
9703 throw new Error("initializeWasm() must be awaited first!");
9705 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o);
9706 return nativeResponseValue;
9708 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ _res);
9710 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res: number): void {
9711 if(!isWasmInitialized) {
9712 throw new Error("initializeWasm() must be awaited first!");
9714 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res);
9715 // debug statements here
9717 // uintptr_t CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR arg);
9719 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg: number): number {
9720 if(!isWasmInitialized) {
9721 throw new Error("initializeWasm() must be awaited first!");
9723 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg);
9724 return nativeResponseValue;
9726 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR orig);
9728 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig: number): number {
9729 if(!isWasmInitialized) {
9730 throw new Error("initializeWasm() must be awaited first!");
9732 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig);
9733 return nativeResponseValue;
9735 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
9737 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o: number): number {
9738 if(!isWasmInitialized) {
9739 throw new Error("initializeWasm() must be awaited first!");
9741 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o);
9742 return nativeResponseValue;
9744 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(struct LDKAPIError e);
9746 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e: number): number {
9747 if(!isWasmInitialized) {
9748 throw new Error("initializeWasm() must be awaited first!");
9750 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e);
9751 return nativeResponseValue;
9753 // bool CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR o);
9755 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o: number): boolean {
9756 if(!isWasmInitialized) {
9757 throw new Error("initializeWasm() must be awaited first!");
9759 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o);
9760 return nativeResponseValue;
9762 // void CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ _res);
9764 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res: number): void {
9765 if(!isWasmInitialized) {
9766 throw new Error("initializeWasm() must be awaited first!");
9768 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res);
9769 // debug statements here
9771 // uintptr_t CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR arg);
9773 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg: number): number {
9774 if(!isWasmInitialized) {
9775 throw new Error("initializeWasm() must be awaited first!");
9777 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg);
9778 return nativeResponseValue;
9780 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR orig);
9782 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig: number): number {
9783 if(!isWasmInitialized) {
9784 throw new Error("initializeWasm() must be awaited first!");
9786 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig);
9787 return nativeResponseValue;
9789 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_ok(struct LDKThirtyTwoBytes o);
9791 export function CResult_PaymentSecretNoneZ_ok(o: number): number {
9792 if(!isWasmInitialized) {
9793 throw new Error("initializeWasm() must be awaited first!");
9795 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_ok(o);
9796 return nativeResponseValue;
9798 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_err(void);
9800 export function CResult_PaymentSecretNoneZ_err(): number {
9801 if(!isWasmInitialized) {
9802 throw new Error("initializeWasm() must be awaited first!");
9804 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_err();
9805 return nativeResponseValue;
9807 // bool CResult_PaymentSecretNoneZ_is_ok(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR o);
9809 export function CResult_PaymentSecretNoneZ_is_ok(o: number): boolean {
9810 if(!isWasmInitialized) {
9811 throw new Error("initializeWasm() must be awaited first!");
9813 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_is_ok(o);
9814 return nativeResponseValue;
9816 // void CResult_PaymentSecretNoneZ_free(struct LDKCResult_PaymentSecretNoneZ _res);
9818 export function CResult_PaymentSecretNoneZ_free(_res: number): void {
9819 if(!isWasmInitialized) {
9820 throw new Error("initializeWasm() must be awaited first!");
9822 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_free(_res);
9823 // debug statements here
9825 // uintptr_t CResult_PaymentSecretNoneZ_clone_ptr(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR arg);
9827 export function CResult_PaymentSecretNoneZ_clone_ptr(arg: number): number {
9828 if(!isWasmInitialized) {
9829 throw new Error("initializeWasm() must be awaited first!");
9831 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone_ptr(arg);
9832 return nativeResponseValue;
9834 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_clone(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR orig);
9836 export function CResult_PaymentSecretNoneZ_clone(orig: number): number {
9837 if(!isWasmInitialized) {
9838 throw new Error("initializeWasm() must be awaited first!");
9840 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone(orig);
9841 return nativeResponseValue;
9843 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
9845 export function CResult_PaymentSecretAPIErrorZ_ok(o: number): number {
9846 if(!isWasmInitialized) {
9847 throw new Error("initializeWasm() must be awaited first!");
9849 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_ok(o);
9850 return nativeResponseValue;
9852 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_err(struct LDKAPIError e);
9854 export function CResult_PaymentSecretAPIErrorZ_err(e: number): number {
9855 if(!isWasmInitialized) {
9856 throw new Error("initializeWasm() must be awaited first!");
9858 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_err(e);
9859 return nativeResponseValue;
9861 // bool CResult_PaymentSecretAPIErrorZ_is_ok(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR o);
9863 export function CResult_PaymentSecretAPIErrorZ_is_ok(o: number): boolean {
9864 if(!isWasmInitialized) {
9865 throw new Error("initializeWasm() must be awaited first!");
9867 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_is_ok(o);
9868 return nativeResponseValue;
9870 // void CResult_PaymentSecretAPIErrorZ_free(struct LDKCResult_PaymentSecretAPIErrorZ _res);
9872 export function CResult_PaymentSecretAPIErrorZ_free(_res: number): void {
9873 if(!isWasmInitialized) {
9874 throw new Error("initializeWasm() must be awaited first!");
9876 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_free(_res);
9877 // debug statements here
9879 // uintptr_t CResult_PaymentSecretAPIErrorZ_clone_ptr(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR arg);
9881 export function CResult_PaymentSecretAPIErrorZ_clone_ptr(arg: number): number {
9882 if(!isWasmInitialized) {
9883 throw new Error("initializeWasm() must be awaited first!");
9885 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone_ptr(arg);
9886 return nativeResponseValue;
9888 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_clone(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR orig);
9890 export function CResult_PaymentSecretAPIErrorZ_clone(orig: number): number {
9891 if(!isWasmInitialized) {
9892 throw new Error("initializeWasm() must be awaited first!");
9894 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone(orig);
9895 return nativeResponseValue;
9897 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
9899 export function CResult_PaymentPreimageAPIErrorZ_ok(o: number): number {
9900 if(!isWasmInitialized) {
9901 throw new Error("initializeWasm() must be awaited first!");
9903 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_ok(o);
9904 return nativeResponseValue;
9906 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_err(struct LDKAPIError e);
9908 export function CResult_PaymentPreimageAPIErrorZ_err(e: number): number {
9909 if(!isWasmInitialized) {
9910 throw new Error("initializeWasm() must be awaited first!");
9912 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_err(e);
9913 return nativeResponseValue;
9915 // bool CResult_PaymentPreimageAPIErrorZ_is_ok(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR o);
9917 export function CResult_PaymentPreimageAPIErrorZ_is_ok(o: number): boolean {
9918 if(!isWasmInitialized) {
9919 throw new Error("initializeWasm() must be awaited first!");
9921 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_is_ok(o);
9922 return nativeResponseValue;
9924 // void CResult_PaymentPreimageAPIErrorZ_free(struct LDKCResult_PaymentPreimageAPIErrorZ _res);
9926 export function CResult_PaymentPreimageAPIErrorZ_free(_res: number): void {
9927 if(!isWasmInitialized) {
9928 throw new Error("initializeWasm() must be awaited first!");
9930 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_free(_res);
9931 // debug statements here
9933 // uintptr_t CResult_PaymentPreimageAPIErrorZ_clone_ptr(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR arg);
9935 export function CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg: number): number {
9936 if(!isWasmInitialized) {
9937 throw new Error("initializeWasm() must be awaited first!");
9939 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg);
9940 return nativeResponseValue;
9942 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_clone(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR orig);
9944 export function CResult_PaymentPreimageAPIErrorZ_clone(orig: number): number {
9945 if(!isWasmInitialized) {
9946 throw new Error("initializeWasm() must be awaited first!");
9948 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone(orig);
9949 return nativeResponseValue;
9951 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(struct LDKCounterpartyForwardingInfo o);
9953 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o: number): number {
9954 if(!isWasmInitialized) {
9955 throw new Error("initializeWasm() must be awaited first!");
9957 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o);
9958 return nativeResponseValue;
9960 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_err(struct LDKDecodeError e);
9962 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e: number): number {
9963 if(!isWasmInitialized) {
9964 throw new Error("initializeWasm() must be awaited first!");
9966 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e);
9967 return nativeResponseValue;
9969 // bool CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR o);
9971 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o: number): boolean {
9972 if(!isWasmInitialized) {
9973 throw new Error("initializeWasm() must be awaited first!");
9975 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o);
9976 return nativeResponseValue;
9978 // void CResult_CounterpartyForwardingInfoDecodeErrorZ_free(struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ _res);
9980 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res: number): void {
9981 if(!isWasmInitialized) {
9982 throw new Error("initializeWasm() must be awaited first!");
9984 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res);
9985 // debug statements here
9987 // uintptr_t CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR arg);
9989 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg: number): number {
9990 if(!isWasmInitialized) {
9991 throw new Error("initializeWasm() must be awaited first!");
9993 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg);
9994 return nativeResponseValue;
9996 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR orig);
9998 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig: number): number {
9999 if(!isWasmInitialized) {
10000 throw new Error("initializeWasm() must be awaited first!");
10002 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig);
10003 return nativeResponseValue;
10005 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_ok(struct LDKChannelCounterparty o);
10007 export function CResult_ChannelCounterpartyDecodeErrorZ_ok(o: number): number {
10008 if(!isWasmInitialized) {
10009 throw new Error("initializeWasm() must be awaited first!");
10011 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_ok(o);
10012 return nativeResponseValue;
10014 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_err(struct LDKDecodeError e);
10016 export function CResult_ChannelCounterpartyDecodeErrorZ_err(e: number): number {
10017 if(!isWasmInitialized) {
10018 throw new Error("initializeWasm() must be awaited first!");
10020 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_err(e);
10021 return nativeResponseValue;
10023 // bool CResult_ChannelCounterpartyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR o);
10025 export function CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o: number): boolean {
10026 if(!isWasmInitialized) {
10027 throw new Error("initializeWasm() must be awaited first!");
10029 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o);
10030 return nativeResponseValue;
10032 // void CResult_ChannelCounterpartyDecodeErrorZ_free(struct LDKCResult_ChannelCounterpartyDecodeErrorZ _res);
10034 export function CResult_ChannelCounterpartyDecodeErrorZ_free(_res: number): void {
10035 if(!isWasmInitialized) {
10036 throw new Error("initializeWasm() must be awaited first!");
10038 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_free(_res);
10039 // debug statements here
10041 // uintptr_t CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR arg);
10043 export function CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg: number): number {
10044 if(!isWasmInitialized) {
10045 throw new Error("initializeWasm() must be awaited first!");
10047 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg);
10048 return nativeResponseValue;
10050 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_clone(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR orig);
10052 export function CResult_ChannelCounterpartyDecodeErrorZ_clone(orig: number): number {
10053 if(!isWasmInitialized) {
10054 throw new Error("initializeWasm() must be awaited first!");
10056 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone(orig);
10057 return nativeResponseValue;
10059 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_ok(struct LDKChannelDetails o);
10061 export function CResult_ChannelDetailsDecodeErrorZ_ok(o: number): number {
10062 if(!isWasmInitialized) {
10063 throw new Error("initializeWasm() must be awaited first!");
10065 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_ok(o);
10066 return nativeResponseValue;
10068 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_err(struct LDKDecodeError e);
10070 export function CResult_ChannelDetailsDecodeErrorZ_err(e: number): number {
10071 if(!isWasmInitialized) {
10072 throw new Error("initializeWasm() must be awaited first!");
10074 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_err(e);
10075 return nativeResponseValue;
10077 // bool CResult_ChannelDetailsDecodeErrorZ_is_ok(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR o);
10079 export function CResult_ChannelDetailsDecodeErrorZ_is_ok(o: number): boolean {
10080 if(!isWasmInitialized) {
10081 throw new Error("initializeWasm() must be awaited first!");
10083 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_is_ok(o);
10084 return nativeResponseValue;
10086 // void CResult_ChannelDetailsDecodeErrorZ_free(struct LDKCResult_ChannelDetailsDecodeErrorZ _res);
10088 export function CResult_ChannelDetailsDecodeErrorZ_free(_res: number): void {
10089 if(!isWasmInitialized) {
10090 throw new Error("initializeWasm() must be awaited first!");
10092 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_free(_res);
10093 // debug statements here
10095 // uintptr_t CResult_ChannelDetailsDecodeErrorZ_clone_ptr(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR arg);
10097 export function CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg: number): number {
10098 if(!isWasmInitialized) {
10099 throw new Error("initializeWasm() must be awaited first!");
10101 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg);
10102 return nativeResponseValue;
10104 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_clone(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR orig);
10106 export function CResult_ChannelDetailsDecodeErrorZ_clone(orig: number): number {
10107 if(!isWasmInitialized) {
10108 throw new Error("initializeWasm() must be awaited first!");
10110 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone(orig);
10111 return nativeResponseValue;
10113 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_ok(struct LDKPhantomRouteHints o);
10115 export function CResult_PhantomRouteHintsDecodeErrorZ_ok(o: number): number {
10116 if(!isWasmInitialized) {
10117 throw new Error("initializeWasm() must be awaited first!");
10119 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_ok(o);
10120 return nativeResponseValue;
10122 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_err(struct LDKDecodeError e);
10124 export function CResult_PhantomRouteHintsDecodeErrorZ_err(e: number): number {
10125 if(!isWasmInitialized) {
10126 throw new Error("initializeWasm() must be awaited first!");
10128 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_err(e);
10129 return nativeResponseValue;
10131 // bool CResult_PhantomRouteHintsDecodeErrorZ_is_ok(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR o);
10133 export function CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o: number): boolean {
10134 if(!isWasmInitialized) {
10135 throw new Error("initializeWasm() must be awaited first!");
10137 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o);
10138 return nativeResponseValue;
10140 // void CResult_PhantomRouteHintsDecodeErrorZ_free(struct LDKCResult_PhantomRouteHintsDecodeErrorZ _res);
10142 export function CResult_PhantomRouteHintsDecodeErrorZ_free(_res: number): void {
10143 if(!isWasmInitialized) {
10144 throw new Error("initializeWasm() must be awaited first!");
10146 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_free(_res);
10147 // debug statements here
10149 // uintptr_t CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR arg);
10151 export function CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg: number): number {
10152 if(!isWasmInitialized) {
10153 throw new Error("initializeWasm() must be awaited first!");
10155 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg);
10156 return nativeResponseValue;
10158 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_clone(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR orig);
10160 export function CResult_PhantomRouteHintsDecodeErrorZ_clone(orig: number): number {
10161 if(!isWasmInitialized) {
10162 throw new Error("initializeWasm() must be awaited first!");
10164 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone(orig);
10165 return nativeResponseValue;
10167 // void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
10169 export function CVec_ChannelMonitorZ_free(_res: number): void {
10170 if(!isWasmInitialized) {
10171 throw new Error("initializeWasm() must be awaited first!");
10173 const nativeResponseValue = wasm.TS_CVec_ChannelMonitorZ_free(_res);
10174 // debug statements here
10176 // struct LDKC2Tuple_BlockHashChannelManagerZ C2Tuple_BlockHashChannelManagerZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelManager b);
10178 export function C2Tuple_BlockHashChannelManagerZ_new(a: number, b: number): number {
10179 if(!isWasmInitialized) {
10180 throw new Error("initializeWasm() must be awaited first!");
10182 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_new(a, b);
10183 return nativeResponseValue;
10185 // void C2Tuple_BlockHashChannelManagerZ_free(struct LDKC2Tuple_BlockHashChannelManagerZ _res);
10187 export function C2Tuple_BlockHashChannelManagerZ_free(_res: number): void {
10188 if(!isWasmInitialized) {
10189 throw new Error("initializeWasm() must be awaited first!");
10191 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_free(_res);
10192 // debug statements here
10194 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelManagerZ o);
10196 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o: number): number {
10197 if(!isWasmInitialized) {
10198 throw new Error("initializeWasm() must be awaited first!");
10200 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o);
10201 return nativeResponseValue;
10203 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
10205 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e: number): number {
10206 if(!isWasmInitialized) {
10207 throw new Error("initializeWasm() must be awaited first!");
10209 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e);
10210 return nativeResponseValue;
10212 // bool CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR o);
10214 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o: number): boolean {
10215 if(!isWasmInitialized) {
10216 throw new Error("initializeWasm() must be awaited first!");
10218 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o);
10219 return nativeResponseValue;
10221 // void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res);
10223 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res: number): void {
10224 if(!isWasmInitialized) {
10225 throw new Error("initializeWasm() must be awaited first!");
10227 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res);
10228 // debug statements here
10230 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
10232 export function CResult_ChannelConfigDecodeErrorZ_ok(o: number): number {
10233 if(!isWasmInitialized) {
10234 throw new Error("initializeWasm() must be awaited first!");
10236 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_ok(o);
10237 return nativeResponseValue;
10239 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
10241 export function CResult_ChannelConfigDecodeErrorZ_err(e: number): number {
10242 if(!isWasmInitialized) {
10243 throw new Error("initializeWasm() must be awaited first!");
10245 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_err(e);
10246 return nativeResponseValue;
10248 // bool CResult_ChannelConfigDecodeErrorZ_is_ok(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR o);
10250 export function CResult_ChannelConfigDecodeErrorZ_is_ok(o: number): boolean {
10251 if(!isWasmInitialized) {
10252 throw new Error("initializeWasm() must be awaited first!");
10254 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_is_ok(o);
10255 return nativeResponseValue;
10257 // void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
10259 export function CResult_ChannelConfigDecodeErrorZ_free(_res: number): void {
10260 if(!isWasmInitialized) {
10261 throw new Error("initializeWasm() must be awaited first!");
10263 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_free(_res);
10264 // debug statements here
10266 // uintptr_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg);
10268 export function CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg: number): number {
10269 if(!isWasmInitialized) {
10270 throw new Error("initializeWasm() must be awaited first!");
10272 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg);
10273 return nativeResponseValue;
10275 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
10277 export function CResult_ChannelConfigDecodeErrorZ_clone(orig: number): number {
10278 if(!isWasmInitialized) {
10279 throw new Error("initializeWasm() must be awaited first!");
10281 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone(orig);
10282 return nativeResponseValue;
10284 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
10286 export function CResult_OutPointDecodeErrorZ_ok(o: number): number {
10287 if(!isWasmInitialized) {
10288 throw new Error("initializeWasm() must be awaited first!");
10290 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_ok(o);
10291 return nativeResponseValue;
10293 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
10295 export function CResult_OutPointDecodeErrorZ_err(e: number): number {
10296 if(!isWasmInitialized) {
10297 throw new Error("initializeWasm() must be awaited first!");
10299 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_err(e);
10300 return nativeResponseValue;
10302 // bool CResult_OutPointDecodeErrorZ_is_ok(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR o);
10304 export function CResult_OutPointDecodeErrorZ_is_ok(o: number): boolean {
10305 if(!isWasmInitialized) {
10306 throw new Error("initializeWasm() must be awaited first!");
10308 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_is_ok(o);
10309 return nativeResponseValue;
10311 // void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
10313 export function CResult_OutPointDecodeErrorZ_free(_res: number): void {
10314 if(!isWasmInitialized) {
10315 throw new Error("initializeWasm() must be awaited first!");
10317 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_free(_res);
10318 // debug statements here
10320 // uintptr_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg);
10322 export function CResult_OutPointDecodeErrorZ_clone_ptr(arg: number): number {
10323 if(!isWasmInitialized) {
10324 throw new Error("initializeWasm() must be awaited first!");
10326 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone_ptr(arg);
10327 return nativeResponseValue;
10329 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
10331 export function CResult_OutPointDecodeErrorZ_clone(orig: number): number {
10332 if(!isWasmInitialized) {
10333 throw new Error("initializeWasm() must be awaited first!");
10335 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone(orig);
10336 return nativeResponseValue;
10338 // struct LDKCOption_TypeZ COption_TypeZ_some(struct LDKType o);
10340 export function COption_TypeZ_some(o: number): number {
10341 if(!isWasmInitialized) {
10342 throw new Error("initializeWasm() must be awaited first!");
10344 const nativeResponseValue = wasm.TS_COption_TypeZ_some(o);
10345 return nativeResponseValue;
10347 // struct LDKCOption_TypeZ COption_TypeZ_none(void);
10349 export function COption_TypeZ_none(): number {
10350 if(!isWasmInitialized) {
10351 throw new Error("initializeWasm() must be awaited first!");
10353 const nativeResponseValue = wasm.TS_COption_TypeZ_none();
10354 return nativeResponseValue;
10356 // void COption_TypeZ_free(struct LDKCOption_TypeZ _res);
10358 export function COption_TypeZ_free(_res: number): void {
10359 if(!isWasmInitialized) {
10360 throw new Error("initializeWasm() must be awaited first!");
10362 const nativeResponseValue = wasm.TS_COption_TypeZ_free(_res);
10363 // debug statements here
10365 // uintptr_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg);
10367 export function COption_TypeZ_clone_ptr(arg: number): number {
10368 if(!isWasmInitialized) {
10369 throw new Error("initializeWasm() must be awaited first!");
10371 const nativeResponseValue = wasm.TS_COption_TypeZ_clone_ptr(arg);
10372 return nativeResponseValue;
10374 // struct LDKCOption_TypeZ COption_TypeZ_clone(const struct LDKCOption_TypeZ *NONNULL_PTR orig);
10376 export function COption_TypeZ_clone(orig: number): number {
10377 if(!isWasmInitialized) {
10378 throw new Error("initializeWasm() must be awaited first!");
10380 const nativeResponseValue = wasm.TS_COption_TypeZ_clone(orig);
10381 return nativeResponseValue;
10383 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_ok(struct LDKCOption_TypeZ o);
10385 export function CResult_COption_TypeZDecodeErrorZ_ok(o: number): number {
10386 if(!isWasmInitialized) {
10387 throw new Error("initializeWasm() must be awaited first!");
10389 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_ok(o);
10390 return nativeResponseValue;
10392 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_err(struct LDKDecodeError e);
10394 export function CResult_COption_TypeZDecodeErrorZ_err(e: number): number {
10395 if(!isWasmInitialized) {
10396 throw new Error("initializeWasm() must be awaited first!");
10398 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_err(e);
10399 return nativeResponseValue;
10401 // bool CResult_COption_TypeZDecodeErrorZ_is_ok(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR o);
10403 export function CResult_COption_TypeZDecodeErrorZ_is_ok(o: number): boolean {
10404 if(!isWasmInitialized) {
10405 throw new Error("initializeWasm() must be awaited first!");
10407 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_is_ok(o);
10408 return nativeResponseValue;
10410 // void CResult_COption_TypeZDecodeErrorZ_free(struct LDKCResult_COption_TypeZDecodeErrorZ _res);
10412 export function CResult_COption_TypeZDecodeErrorZ_free(_res: number): void {
10413 if(!isWasmInitialized) {
10414 throw new Error("initializeWasm() must be awaited first!");
10416 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_free(_res);
10417 // debug statements here
10419 // uintptr_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg);
10421 export function CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg: number): number {
10422 if(!isWasmInitialized) {
10423 throw new Error("initializeWasm() must be awaited first!");
10425 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg);
10426 return nativeResponseValue;
10428 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_clone(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR orig);
10430 export function CResult_COption_TypeZDecodeErrorZ_clone(orig: number): number {
10431 if(!isWasmInitialized) {
10432 throw new Error("initializeWasm() must be awaited first!");
10434 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone(orig);
10435 return nativeResponseValue;
10437 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_ok(struct LDKThirtyTwoBytes o);
10439 export function CResult_PaymentIdPaymentErrorZ_ok(o: number): number {
10440 if(!isWasmInitialized) {
10441 throw new Error("initializeWasm() must be awaited first!");
10443 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_ok(o);
10444 return nativeResponseValue;
10446 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_err(struct LDKPaymentError e);
10448 export function CResult_PaymentIdPaymentErrorZ_err(e: number): number {
10449 if(!isWasmInitialized) {
10450 throw new Error("initializeWasm() must be awaited first!");
10452 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_err(e);
10453 return nativeResponseValue;
10455 // bool CResult_PaymentIdPaymentErrorZ_is_ok(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR o);
10457 export function CResult_PaymentIdPaymentErrorZ_is_ok(o: number): boolean {
10458 if(!isWasmInitialized) {
10459 throw new Error("initializeWasm() must be awaited first!");
10461 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_is_ok(o);
10462 return nativeResponseValue;
10464 // void CResult_PaymentIdPaymentErrorZ_free(struct LDKCResult_PaymentIdPaymentErrorZ _res);
10466 export function CResult_PaymentIdPaymentErrorZ_free(_res: number): void {
10467 if(!isWasmInitialized) {
10468 throw new Error("initializeWasm() must be awaited first!");
10470 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_free(_res);
10471 // debug statements here
10473 // uintptr_t CResult_PaymentIdPaymentErrorZ_clone_ptr(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR arg);
10475 export function CResult_PaymentIdPaymentErrorZ_clone_ptr(arg: number): number {
10476 if(!isWasmInitialized) {
10477 throw new Error("initializeWasm() must be awaited first!");
10479 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone_ptr(arg);
10480 return nativeResponseValue;
10482 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_clone(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR orig);
10484 export function CResult_PaymentIdPaymentErrorZ_clone(orig: number): number {
10485 if(!isWasmInitialized) {
10486 throw new Error("initializeWasm() must be awaited first!");
10488 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone(orig);
10489 return nativeResponseValue;
10491 // struct LDKCResult_SiPrefixNoneZ CResult_SiPrefixNoneZ_ok(enum LDKSiPrefix o);
10493 export function CResult_SiPrefixNoneZ_ok(o: SiPrefix): number {
10494 if(!isWasmInitialized) {
10495 throw new Error("initializeWasm() must be awaited first!");
10497 const nativeResponseValue = wasm.TS_CResult_SiPrefixNoneZ_ok(o);
10498 return nativeResponseValue;
10500 // struct LDKCResult_SiPrefixNoneZ CResult_SiPrefixNoneZ_err(void);
10502 export function CResult_SiPrefixNoneZ_err(): number {
10503 if(!isWasmInitialized) {
10504 throw new Error("initializeWasm() must be awaited first!");
10506 const nativeResponseValue = wasm.TS_CResult_SiPrefixNoneZ_err();
10507 return nativeResponseValue;
10509 // bool CResult_SiPrefixNoneZ_is_ok(const struct LDKCResult_SiPrefixNoneZ *NONNULL_PTR o);
10511 export function CResult_SiPrefixNoneZ_is_ok(o: number): boolean {
10512 if(!isWasmInitialized) {
10513 throw new Error("initializeWasm() must be awaited first!");
10515 const nativeResponseValue = wasm.TS_CResult_SiPrefixNoneZ_is_ok(o);
10516 return nativeResponseValue;
10518 // void CResult_SiPrefixNoneZ_free(struct LDKCResult_SiPrefixNoneZ _res);
10520 export function CResult_SiPrefixNoneZ_free(_res: number): void {
10521 if(!isWasmInitialized) {
10522 throw new Error("initializeWasm() must be awaited first!");
10524 const nativeResponseValue = wasm.TS_CResult_SiPrefixNoneZ_free(_res);
10525 // debug statements here
10527 // uintptr_t CResult_SiPrefixNoneZ_clone_ptr(LDKCResult_SiPrefixNoneZ *NONNULL_PTR arg);
10529 export function CResult_SiPrefixNoneZ_clone_ptr(arg: number): number {
10530 if(!isWasmInitialized) {
10531 throw new Error("initializeWasm() must be awaited first!");
10533 const nativeResponseValue = wasm.TS_CResult_SiPrefixNoneZ_clone_ptr(arg);
10534 return nativeResponseValue;
10536 // struct LDKCResult_SiPrefixNoneZ CResult_SiPrefixNoneZ_clone(const struct LDKCResult_SiPrefixNoneZ *NONNULL_PTR orig);
10538 export function CResult_SiPrefixNoneZ_clone(orig: number): number {
10539 if(!isWasmInitialized) {
10540 throw new Error("initializeWasm() must be awaited first!");
10542 const nativeResponseValue = wasm.TS_CResult_SiPrefixNoneZ_clone(orig);
10543 return nativeResponseValue;
10545 // struct LDKCResult_InvoiceNoneZ CResult_InvoiceNoneZ_ok(struct LDKInvoice o);
10547 export function CResult_InvoiceNoneZ_ok(o: number): number {
10548 if(!isWasmInitialized) {
10549 throw new Error("initializeWasm() must be awaited first!");
10551 const nativeResponseValue = wasm.TS_CResult_InvoiceNoneZ_ok(o);
10552 return nativeResponseValue;
10554 // struct LDKCResult_InvoiceNoneZ CResult_InvoiceNoneZ_err(void);
10556 export function CResult_InvoiceNoneZ_err(): number {
10557 if(!isWasmInitialized) {
10558 throw new Error("initializeWasm() must be awaited first!");
10560 const nativeResponseValue = wasm.TS_CResult_InvoiceNoneZ_err();
10561 return nativeResponseValue;
10563 // bool CResult_InvoiceNoneZ_is_ok(const struct LDKCResult_InvoiceNoneZ *NONNULL_PTR o);
10565 export function CResult_InvoiceNoneZ_is_ok(o: number): boolean {
10566 if(!isWasmInitialized) {
10567 throw new Error("initializeWasm() must be awaited first!");
10569 const nativeResponseValue = wasm.TS_CResult_InvoiceNoneZ_is_ok(o);
10570 return nativeResponseValue;
10572 // void CResult_InvoiceNoneZ_free(struct LDKCResult_InvoiceNoneZ _res);
10574 export function CResult_InvoiceNoneZ_free(_res: number): void {
10575 if(!isWasmInitialized) {
10576 throw new Error("initializeWasm() must be awaited first!");
10578 const nativeResponseValue = wasm.TS_CResult_InvoiceNoneZ_free(_res);
10579 // debug statements here
10581 // uintptr_t CResult_InvoiceNoneZ_clone_ptr(LDKCResult_InvoiceNoneZ *NONNULL_PTR arg);
10583 export function CResult_InvoiceNoneZ_clone_ptr(arg: number): number {
10584 if(!isWasmInitialized) {
10585 throw new Error("initializeWasm() must be awaited first!");
10587 const nativeResponseValue = wasm.TS_CResult_InvoiceNoneZ_clone_ptr(arg);
10588 return nativeResponseValue;
10590 // struct LDKCResult_InvoiceNoneZ CResult_InvoiceNoneZ_clone(const struct LDKCResult_InvoiceNoneZ *NONNULL_PTR orig);
10592 export function CResult_InvoiceNoneZ_clone(orig: number): number {
10593 if(!isWasmInitialized) {
10594 throw new Error("initializeWasm() must be awaited first!");
10596 const nativeResponseValue = wasm.TS_CResult_InvoiceNoneZ_clone(orig);
10597 return nativeResponseValue;
10599 // struct LDKCResult_SignedRawInvoiceNoneZ CResult_SignedRawInvoiceNoneZ_ok(struct LDKSignedRawInvoice o);
10601 export function CResult_SignedRawInvoiceNoneZ_ok(o: number): number {
10602 if(!isWasmInitialized) {
10603 throw new Error("initializeWasm() must be awaited first!");
10605 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceNoneZ_ok(o);
10606 return nativeResponseValue;
10608 // struct LDKCResult_SignedRawInvoiceNoneZ CResult_SignedRawInvoiceNoneZ_err(void);
10610 export function CResult_SignedRawInvoiceNoneZ_err(): number {
10611 if(!isWasmInitialized) {
10612 throw new Error("initializeWasm() must be awaited first!");
10614 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceNoneZ_err();
10615 return nativeResponseValue;
10617 // bool CResult_SignedRawInvoiceNoneZ_is_ok(const struct LDKCResult_SignedRawInvoiceNoneZ *NONNULL_PTR o);
10619 export function CResult_SignedRawInvoiceNoneZ_is_ok(o: number): boolean {
10620 if(!isWasmInitialized) {
10621 throw new Error("initializeWasm() must be awaited first!");
10623 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceNoneZ_is_ok(o);
10624 return nativeResponseValue;
10626 // void CResult_SignedRawInvoiceNoneZ_free(struct LDKCResult_SignedRawInvoiceNoneZ _res);
10628 export function CResult_SignedRawInvoiceNoneZ_free(_res: number): void {
10629 if(!isWasmInitialized) {
10630 throw new Error("initializeWasm() must be awaited first!");
10632 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceNoneZ_free(_res);
10633 // debug statements here
10635 // uintptr_t CResult_SignedRawInvoiceNoneZ_clone_ptr(LDKCResult_SignedRawInvoiceNoneZ *NONNULL_PTR arg);
10637 export function CResult_SignedRawInvoiceNoneZ_clone_ptr(arg: number): number {
10638 if(!isWasmInitialized) {
10639 throw new Error("initializeWasm() must be awaited first!");
10641 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceNoneZ_clone_ptr(arg);
10642 return nativeResponseValue;
10644 // struct LDKCResult_SignedRawInvoiceNoneZ CResult_SignedRawInvoiceNoneZ_clone(const struct LDKCResult_SignedRawInvoiceNoneZ *NONNULL_PTR orig);
10646 export function CResult_SignedRawInvoiceNoneZ_clone(orig: number): number {
10647 if(!isWasmInitialized) {
10648 throw new Error("initializeWasm() must be awaited first!");
10650 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceNoneZ_clone(orig);
10651 return nativeResponseValue;
10653 // uintptr_t C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR arg);
10655 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg: number): number {
10656 if(!isWasmInitialized) {
10657 throw new Error("initializeWasm() must be awaited first!");
10659 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg);
10660 return nativeResponseValue;
10662 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(const struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR orig);
10664 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig: number): number {
10665 if(!isWasmInitialized) {
10666 throw new Error("initializeWasm() must be awaited first!");
10668 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig);
10669 return nativeResponseValue;
10671 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(struct LDKRawInvoice a, struct LDKThirtyTwoBytes b, struct LDKInvoiceSignature c);
10673 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a: number, b: number, c: number): number {
10674 if(!isWasmInitialized) {
10675 throw new Error("initializeWasm() must be awaited first!");
10677 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a, b, c);
10678 return nativeResponseValue;
10680 // void C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ _res);
10682 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res: number): void {
10683 if(!isWasmInitialized) {
10684 throw new Error("initializeWasm() must be awaited first!");
10686 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res);
10687 // debug statements here
10689 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_ok(struct LDKPayeePubKey o);
10691 export function CResult_PayeePubKeyErrorZ_ok(o: number): number {
10692 if(!isWasmInitialized) {
10693 throw new Error("initializeWasm() must be awaited first!");
10695 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_ok(o);
10696 return nativeResponseValue;
10698 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_err(enum LDKSecp256k1Error e);
10700 export function CResult_PayeePubKeyErrorZ_err(e: Secp256k1Error): number {
10701 if(!isWasmInitialized) {
10702 throw new Error("initializeWasm() must be awaited first!");
10704 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_err(e);
10705 return nativeResponseValue;
10707 // bool CResult_PayeePubKeyErrorZ_is_ok(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR o);
10709 export function CResult_PayeePubKeyErrorZ_is_ok(o: number): boolean {
10710 if(!isWasmInitialized) {
10711 throw new Error("initializeWasm() must be awaited first!");
10713 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_is_ok(o);
10714 return nativeResponseValue;
10716 // void CResult_PayeePubKeyErrorZ_free(struct LDKCResult_PayeePubKeyErrorZ _res);
10718 export function CResult_PayeePubKeyErrorZ_free(_res: number): void {
10719 if(!isWasmInitialized) {
10720 throw new Error("initializeWasm() must be awaited first!");
10722 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_free(_res);
10723 // debug statements here
10725 // uintptr_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg);
10727 export function CResult_PayeePubKeyErrorZ_clone_ptr(arg: number): number {
10728 if(!isWasmInitialized) {
10729 throw new Error("initializeWasm() must be awaited first!");
10731 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone_ptr(arg);
10732 return nativeResponseValue;
10734 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_clone(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR orig);
10736 export function CResult_PayeePubKeyErrorZ_clone(orig: number): number {
10737 if(!isWasmInitialized) {
10738 throw new Error("initializeWasm() must be awaited first!");
10740 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone(orig);
10741 return nativeResponseValue;
10743 // void CVec_PrivateRouteZ_free(struct LDKCVec_PrivateRouteZ _res);
10745 export function CVec_PrivateRouteZ_free(_res: number): void {
10746 if(!isWasmInitialized) {
10747 throw new Error("initializeWasm() must be awaited first!");
10749 const nativeResponseValue = wasm.TS_CVec_PrivateRouteZ_free(_res);
10750 // debug statements here
10752 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_ok(struct LDKPositiveTimestamp o);
10754 export function CResult_PositiveTimestampCreationErrorZ_ok(o: number): number {
10755 if(!isWasmInitialized) {
10756 throw new Error("initializeWasm() must be awaited first!");
10758 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_ok(o);
10759 return nativeResponseValue;
10761 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_err(enum LDKCreationError e);
10763 export function CResult_PositiveTimestampCreationErrorZ_err(e: CreationError): number {
10764 if(!isWasmInitialized) {
10765 throw new Error("initializeWasm() must be awaited first!");
10767 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_err(e);
10768 return nativeResponseValue;
10770 // bool CResult_PositiveTimestampCreationErrorZ_is_ok(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR o);
10772 export function CResult_PositiveTimestampCreationErrorZ_is_ok(o: number): boolean {
10773 if(!isWasmInitialized) {
10774 throw new Error("initializeWasm() must be awaited first!");
10776 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_is_ok(o);
10777 return nativeResponseValue;
10779 // void CResult_PositiveTimestampCreationErrorZ_free(struct LDKCResult_PositiveTimestampCreationErrorZ _res);
10781 export function CResult_PositiveTimestampCreationErrorZ_free(_res: number): void {
10782 if(!isWasmInitialized) {
10783 throw new Error("initializeWasm() must be awaited first!");
10785 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_free(_res);
10786 // debug statements here
10788 // uintptr_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg);
10790 export function CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg: number): number {
10791 if(!isWasmInitialized) {
10792 throw new Error("initializeWasm() must be awaited first!");
10794 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg);
10795 return nativeResponseValue;
10797 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_clone(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR orig);
10799 export function CResult_PositiveTimestampCreationErrorZ_clone(orig: number): number {
10800 if(!isWasmInitialized) {
10801 throw new Error("initializeWasm() must be awaited first!");
10803 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone(orig);
10804 return nativeResponseValue;
10806 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_ok(void);
10808 export function CResult_NoneSemanticErrorZ_ok(): number {
10809 if(!isWasmInitialized) {
10810 throw new Error("initializeWasm() must be awaited first!");
10812 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_ok();
10813 return nativeResponseValue;
10815 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_err(enum LDKSemanticError e);
10817 export function CResult_NoneSemanticErrorZ_err(e: SemanticError): number {
10818 if(!isWasmInitialized) {
10819 throw new Error("initializeWasm() must be awaited first!");
10821 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_err(e);
10822 return nativeResponseValue;
10824 // bool CResult_NoneSemanticErrorZ_is_ok(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR o);
10826 export function CResult_NoneSemanticErrorZ_is_ok(o: number): boolean {
10827 if(!isWasmInitialized) {
10828 throw new Error("initializeWasm() must be awaited first!");
10830 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_is_ok(o);
10831 return nativeResponseValue;
10833 // void CResult_NoneSemanticErrorZ_free(struct LDKCResult_NoneSemanticErrorZ _res);
10835 export function CResult_NoneSemanticErrorZ_free(_res: number): void {
10836 if(!isWasmInitialized) {
10837 throw new Error("initializeWasm() must be awaited first!");
10839 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_free(_res);
10840 // debug statements here
10842 // uintptr_t CResult_NoneSemanticErrorZ_clone_ptr(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR arg);
10844 export function CResult_NoneSemanticErrorZ_clone_ptr(arg: number): number {
10845 if(!isWasmInitialized) {
10846 throw new Error("initializeWasm() must be awaited first!");
10848 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone_ptr(arg);
10849 return nativeResponseValue;
10851 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_clone(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR orig);
10853 export function CResult_NoneSemanticErrorZ_clone(orig: number): number {
10854 if(!isWasmInitialized) {
10855 throw new Error("initializeWasm() must be awaited first!");
10857 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone(orig);
10858 return nativeResponseValue;
10860 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_ok(struct LDKInvoice o);
10862 export function CResult_InvoiceSemanticErrorZ_ok(o: number): number {
10863 if(!isWasmInitialized) {
10864 throw new Error("initializeWasm() must be awaited first!");
10866 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_ok(o);
10867 return nativeResponseValue;
10869 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_err(enum LDKSemanticError e);
10871 export function CResult_InvoiceSemanticErrorZ_err(e: SemanticError): number {
10872 if(!isWasmInitialized) {
10873 throw new Error("initializeWasm() must be awaited first!");
10875 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_err(e);
10876 return nativeResponseValue;
10878 // bool CResult_InvoiceSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR o);
10880 export function CResult_InvoiceSemanticErrorZ_is_ok(o: number): boolean {
10881 if(!isWasmInitialized) {
10882 throw new Error("initializeWasm() must be awaited first!");
10884 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_is_ok(o);
10885 return nativeResponseValue;
10887 // void CResult_InvoiceSemanticErrorZ_free(struct LDKCResult_InvoiceSemanticErrorZ _res);
10889 export function CResult_InvoiceSemanticErrorZ_free(_res: number): void {
10890 if(!isWasmInitialized) {
10891 throw new Error("initializeWasm() must be awaited first!");
10893 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_free(_res);
10894 // debug statements here
10896 // uintptr_t CResult_InvoiceSemanticErrorZ_clone_ptr(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR arg);
10898 export function CResult_InvoiceSemanticErrorZ_clone_ptr(arg: number): number {
10899 if(!isWasmInitialized) {
10900 throw new Error("initializeWasm() must be awaited first!");
10902 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone_ptr(arg);
10903 return nativeResponseValue;
10905 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_clone(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR orig);
10907 export function CResult_InvoiceSemanticErrorZ_clone(orig: number): number {
10908 if(!isWasmInitialized) {
10909 throw new Error("initializeWasm() must be awaited first!");
10911 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone(orig);
10912 return nativeResponseValue;
10914 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_ok(struct LDKDescription o);
10916 export function CResult_DescriptionCreationErrorZ_ok(o: number): number {
10917 if(!isWasmInitialized) {
10918 throw new Error("initializeWasm() must be awaited first!");
10920 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_ok(o);
10921 return nativeResponseValue;
10923 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_err(enum LDKCreationError e);
10925 export function CResult_DescriptionCreationErrorZ_err(e: CreationError): number {
10926 if(!isWasmInitialized) {
10927 throw new Error("initializeWasm() must be awaited first!");
10929 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_err(e);
10930 return nativeResponseValue;
10932 // bool CResult_DescriptionCreationErrorZ_is_ok(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR o);
10934 export function CResult_DescriptionCreationErrorZ_is_ok(o: number): boolean {
10935 if(!isWasmInitialized) {
10936 throw new Error("initializeWasm() must be awaited first!");
10938 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_is_ok(o);
10939 return nativeResponseValue;
10941 // void CResult_DescriptionCreationErrorZ_free(struct LDKCResult_DescriptionCreationErrorZ _res);
10943 export function CResult_DescriptionCreationErrorZ_free(_res: number): void {
10944 if(!isWasmInitialized) {
10945 throw new Error("initializeWasm() must be awaited first!");
10947 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_free(_res);
10948 // debug statements here
10950 // uintptr_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg);
10952 export function CResult_DescriptionCreationErrorZ_clone_ptr(arg: number): number {
10953 if(!isWasmInitialized) {
10954 throw new Error("initializeWasm() must be awaited first!");
10956 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone_ptr(arg);
10957 return nativeResponseValue;
10959 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_clone(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR orig);
10961 export function CResult_DescriptionCreationErrorZ_clone(orig: number): number {
10962 if(!isWasmInitialized) {
10963 throw new Error("initializeWasm() must be awaited first!");
10965 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone(orig);
10966 return nativeResponseValue;
10968 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_ok(struct LDKPrivateRoute o);
10970 export function CResult_PrivateRouteCreationErrorZ_ok(o: number): number {
10971 if(!isWasmInitialized) {
10972 throw new Error("initializeWasm() must be awaited first!");
10974 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_ok(o);
10975 return nativeResponseValue;
10977 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_err(enum LDKCreationError e);
10979 export function CResult_PrivateRouteCreationErrorZ_err(e: CreationError): number {
10980 if(!isWasmInitialized) {
10981 throw new Error("initializeWasm() must be awaited first!");
10983 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_err(e);
10984 return nativeResponseValue;
10986 // bool CResult_PrivateRouteCreationErrorZ_is_ok(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR o);
10988 export function CResult_PrivateRouteCreationErrorZ_is_ok(o: number): boolean {
10989 if(!isWasmInitialized) {
10990 throw new Error("initializeWasm() must be awaited first!");
10992 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_is_ok(o);
10993 return nativeResponseValue;
10995 // void CResult_PrivateRouteCreationErrorZ_free(struct LDKCResult_PrivateRouteCreationErrorZ _res);
10997 export function CResult_PrivateRouteCreationErrorZ_free(_res: number): void {
10998 if(!isWasmInitialized) {
10999 throw new Error("initializeWasm() must be awaited first!");
11001 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_free(_res);
11002 // debug statements here
11004 // uintptr_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg);
11006 export function CResult_PrivateRouteCreationErrorZ_clone_ptr(arg: number): number {
11007 if(!isWasmInitialized) {
11008 throw new Error("initializeWasm() must be awaited first!");
11010 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(arg);
11011 return nativeResponseValue;
11013 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_clone(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR orig);
11015 export function CResult_PrivateRouteCreationErrorZ_clone(orig: number): number {
11016 if(!isWasmInitialized) {
11017 throw new Error("initializeWasm() must be awaited first!");
11019 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone(orig);
11020 return nativeResponseValue;
11022 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_ok(struct LDKStr o);
11024 export function CResult_StringErrorZ_ok(o: number): number {
11025 if(!isWasmInitialized) {
11026 throw new Error("initializeWasm() must be awaited first!");
11028 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_ok(o);
11029 return nativeResponseValue;
11031 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_err(enum LDKSecp256k1Error e);
11033 export function CResult_StringErrorZ_err(e: Secp256k1Error): number {
11034 if(!isWasmInitialized) {
11035 throw new Error("initializeWasm() must be awaited first!");
11037 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_err(e);
11038 return nativeResponseValue;
11040 // bool CResult_StringErrorZ_is_ok(const struct LDKCResult_StringErrorZ *NONNULL_PTR o);
11042 export function CResult_StringErrorZ_is_ok(o: number): boolean {
11043 if(!isWasmInitialized) {
11044 throw new Error("initializeWasm() must be awaited first!");
11046 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_is_ok(o);
11047 return nativeResponseValue;
11049 // void CResult_StringErrorZ_free(struct LDKCResult_StringErrorZ _res);
11051 export function CResult_StringErrorZ_free(_res: number): void {
11052 if(!isWasmInitialized) {
11053 throw new Error("initializeWasm() must be awaited first!");
11055 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_free(_res);
11056 // debug statements here
11058 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
11060 export function CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: number): number {
11061 if(!isWasmInitialized) {
11062 throw new Error("initializeWasm() must be awaited first!");
11064 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o);
11065 return nativeResponseValue;
11067 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
11069 export function CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: number): number {
11070 if(!isWasmInitialized) {
11071 throw new Error("initializeWasm() must be awaited first!");
11073 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(e);
11074 return nativeResponseValue;
11076 // bool CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR o);
11078 export function CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o: number): boolean {
11079 if(!isWasmInitialized) {
11080 throw new Error("initializeWasm() must be awaited first!");
11082 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o);
11083 return nativeResponseValue;
11085 // void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
11087 export function CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: number): void {
11088 if(!isWasmInitialized) {
11089 throw new Error("initializeWasm() must be awaited first!");
11091 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res);
11092 // debug statements here
11094 // uintptr_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg);
11096 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg: number): number {
11097 if(!isWasmInitialized) {
11098 throw new Error("initializeWasm() must be awaited first!");
11100 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg);
11101 return nativeResponseValue;
11103 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
11105 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: number): number {
11106 if(!isWasmInitialized) {
11107 throw new Error("initializeWasm() must be awaited first!");
11109 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig);
11110 return nativeResponseValue;
11112 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_some(struct LDKMonitorEvent o);
11114 export function COption_MonitorEventZ_some(o: number): number {
11115 if(!isWasmInitialized) {
11116 throw new Error("initializeWasm() must be awaited first!");
11118 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_some(o);
11119 return nativeResponseValue;
11121 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_none(void);
11123 export function COption_MonitorEventZ_none(): number {
11124 if(!isWasmInitialized) {
11125 throw new Error("initializeWasm() must be awaited first!");
11127 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_none();
11128 return nativeResponseValue;
11130 // void COption_MonitorEventZ_free(struct LDKCOption_MonitorEventZ _res);
11132 export function COption_MonitorEventZ_free(_res: number): void {
11133 if(!isWasmInitialized) {
11134 throw new Error("initializeWasm() must be awaited first!");
11136 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_free(_res);
11137 // debug statements here
11139 // uintptr_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg);
11141 export function COption_MonitorEventZ_clone_ptr(arg: number): number {
11142 if(!isWasmInitialized) {
11143 throw new Error("initializeWasm() must be awaited first!");
11145 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone_ptr(arg);
11146 return nativeResponseValue;
11148 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_clone(const struct LDKCOption_MonitorEventZ *NONNULL_PTR orig);
11150 export function COption_MonitorEventZ_clone(orig: number): number {
11151 if(!isWasmInitialized) {
11152 throw new Error("initializeWasm() must be awaited first!");
11154 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone(orig);
11155 return nativeResponseValue;
11157 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_ok(struct LDKCOption_MonitorEventZ o);
11159 export function CResult_COption_MonitorEventZDecodeErrorZ_ok(o: number): number {
11160 if(!isWasmInitialized) {
11161 throw new Error("initializeWasm() must be awaited first!");
11163 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(o);
11164 return nativeResponseValue;
11166 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_err(struct LDKDecodeError e);
11168 export function CResult_COption_MonitorEventZDecodeErrorZ_err(e: number): number {
11169 if(!isWasmInitialized) {
11170 throw new Error("initializeWasm() must be awaited first!");
11172 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_err(e);
11173 return nativeResponseValue;
11175 // bool CResult_COption_MonitorEventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR o);
11177 export function CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o: number): boolean {
11178 if(!isWasmInitialized) {
11179 throw new Error("initializeWasm() must be awaited first!");
11181 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o);
11182 return nativeResponseValue;
11184 // void CResult_COption_MonitorEventZDecodeErrorZ_free(struct LDKCResult_COption_MonitorEventZDecodeErrorZ _res);
11186 export function CResult_COption_MonitorEventZDecodeErrorZ_free(_res: number): void {
11187 if(!isWasmInitialized) {
11188 throw new Error("initializeWasm() must be awaited first!");
11190 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_free(_res);
11191 // debug statements here
11193 // uintptr_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg);
11195 export function CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg: number): number {
11196 if(!isWasmInitialized) {
11197 throw new Error("initializeWasm() must be awaited first!");
11199 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg);
11200 return nativeResponseValue;
11202 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_clone(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR orig);
11204 export function CResult_COption_MonitorEventZDecodeErrorZ_clone(orig: number): number {
11205 if(!isWasmInitialized) {
11206 throw new Error("initializeWasm() must be awaited first!");
11208 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(orig);
11209 return nativeResponseValue;
11211 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
11213 export function CResult_HTLCUpdateDecodeErrorZ_ok(o: number): number {
11214 if(!isWasmInitialized) {
11215 throw new Error("initializeWasm() must be awaited first!");
11217 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_ok(o);
11218 return nativeResponseValue;
11220 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
11222 export function CResult_HTLCUpdateDecodeErrorZ_err(e: number): number {
11223 if(!isWasmInitialized) {
11224 throw new Error("initializeWasm() must be awaited first!");
11226 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_err(e);
11227 return nativeResponseValue;
11229 // bool CResult_HTLCUpdateDecodeErrorZ_is_ok(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR o);
11231 export function CResult_HTLCUpdateDecodeErrorZ_is_ok(o: number): boolean {
11232 if(!isWasmInitialized) {
11233 throw new Error("initializeWasm() must be awaited first!");
11235 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(o);
11236 return nativeResponseValue;
11238 // void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
11240 export function CResult_HTLCUpdateDecodeErrorZ_free(_res: number): void {
11241 if(!isWasmInitialized) {
11242 throw new Error("initializeWasm() must be awaited first!");
11244 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_free(_res);
11245 // debug statements here
11247 // uintptr_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg);
11249 export function CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg: number): number {
11250 if(!isWasmInitialized) {
11251 throw new Error("initializeWasm() must be awaited first!");
11253 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg);
11254 return nativeResponseValue;
11256 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
11258 export function CResult_HTLCUpdateDecodeErrorZ_clone(orig: number): number {
11259 if(!isWasmInitialized) {
11260 throw new Error("initializeWasm() must be awaited first!");
11262 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone(orig);
11263 return nativeResponseValue;
11265 // uintptr_t C2Tuple_OutPointScriptZ_clone_ptr(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR arg);
11267 export function C2Tuple_OutPointScriptZ_clone_ptr(arg: number): number {
11268 if(!isWasmInitialized) {
11269 throw new Error("initializeWasm() must be awaited first!");
11271 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone_ptr(arg);
11272 return nativeResponseValue;
11274 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_clone(const struct LDKC2Tuple_OutPointScriptZ *NONNULL_PTR orig);
11276 export function C2Tuple_OutPointScriptZ_clone(orig: number): number {
11277 if(!isWasmInitialized) {
11278 throw new Error("initializeWasm() must be awaited first!");
11280 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone(orig);
11281 return nativeResponseValue;
11283 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
11285 export function C2Tuple_OutPointScriptZ_new(a: number, b: number): number {
11286 if(!isWasmInitialized) {
11287 throw new Error("initializeWasm() must be awaited first!");
11289 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_new(a, b);
11290 return nativeResponseValue;
11292 // void C2Tuple_OutPointScriptZ_free(struct LDKC2Tuple_OutPointScriptZ _res);
11294 export function C2Tuple_OutPointScriptZ_free(_res: number): void {
11295 if(!isWasmInitialized) {
11296 throw new Error("initializeWasm() must be awaited first!");
11298 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_free(_res);
11299 // debug statements here
11301 // uintptr_t C2Tuple_u32ScriptZ_clone_ptr(LDKC2Tuple_u32ScriptZ *NONNULL_PTR arg);
11303 export function C2Tuple_u32ScriptZ_clone_ptr(arg: number): number {
11304 if(!isWasmInitialized) {
11305 throw new Error("initializeWasm() must be awaited first!");
11307 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone_ptr(arg);
11308 return nativeResponseValue;
11310 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_clone(const struct LDKC2Tuple_u32ScriptZ *NONNULL_PTR orig);
11312 export function C2Tuple_u32ScriptZ_clone(orig: number): number {
11313 if(!isWasmInitialized) {
11314 throw new Error("initializeWasm() must be awaited first!");
11316 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone(orig);
11317 return nativeResponseValue;
11319 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_new(uint32_t a, struct LDKCVec_u8Z b);
11321 export function C2Tuple_u32ScriptZ_new(a: number, b: number): number {
11322 if(!isWasmInitialized) {
11323 throw new Error("initializeWasm() must be awaited first!");
11325 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_new(a, b);
11326 return nativeResponseValue;
11328 // void C2Tuple_u32ScriptZ_free(struct LDKC2Tuple_u32ScriptZ _res);
11330 export function C2Tuple_u32ScriptZ_free(_res: number): void {
11331 if(!isWasmInitialized) {
11332 throw new Error("initializeWasm() must be awaited first!");
11334 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_free(_res);
11335 // debug statements here
11337 // void CVec_C2Tuple_u32ScriptZZ_free(struct LDKCVec_C2Tuple_u32ScriptZZ _res);
11339 export function CVec_C2Tuple_u32ScriptZZ_free(_res: number): void {
11340 if(!isWasmInitialized) {
11341 throw new Error("initializeWasm() must be awaited first!");
11343 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32ScriptZZ_free(_res);
11344 // debug statements here
11346 // uintptr_t C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR arg);
11348 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg: number): number {
11349 if(!isWasmInitialized) {
11350 throw new Error("initializeWasm() must be awaited first!");
11352 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg);
11353 return nativeResponseValue;
11355 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR orig);
11357 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig: number): number {
11358 if(!isWasmInitialized) {
11359 throw new Error("initializeWasm() must be awaited first!");
11361 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig);
11362 return nativeResponseValue;
11364 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32ScriptZZ b);
11366 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a: number, b: number): number {
11367 if(!isWasmInitialized) {
11368 throw new Error("initializeWasm() must be awaited first!");
11370 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a, b);
11371 return nativeResponseValue;
11373 // void C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res);
11375 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res: number): void {
11376 if(!isWasmInitialized) {
11377 throw new Error("initializeWasm() must be awaited first!");
11379 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res);
11380 // debug statements here
11382 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res);
11384 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res: number): void {
11385 if(!isWasmInitialized) {
11386 throw new Error("initializeWasm() must be awaited first!");
11388 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res);
11389 // debug statements here
11391 // void CVec_EventZ_free(struct LDKCVec_EventZ _res);
11393 export function CVec_EventZ_free(_res: number): void {
11394 if(!isWasmInitialized) {
11395 throw new Error("initializeWasm() must be awaited first!");
11397 const nativeResponseValue = wasm.TS_CVec_EventZ_free(_res);
11398 // debug statements here
11400 // void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
11402 export function CVec_TransactionZ_free(_res: number): void {
11403 if(!isWasmInitialized) {
11404 throw new Error("initializeWasm() must be awaited first!");
11406 const nativeResponseValue = wasm.TS_CVec_TransactionZ_free(_res);
11407 // debug statements here
11409 // uintptr_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg);
11411 export function C2Tuple_u32TxOutZ_clone_ptr(arg: number): number {
11412 if(!isWasmInitialized) {
11413 throw new Error("initializeWasm() must be awaited first!");
11415 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone_ptr(arg);
11416 return nativeResponseValue;
11418 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
11420 export function C2Tuple_u32TxOutZ_clone(orig: number): number {
11421 if(!isWasmInitialized) {
11422 throw new Error("initializeWasm() must be awaited first!");
11424 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone(orig);
11425 return nativeResponseValue;
11427 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
11429 export function C2Tuple_u32TxOutZ_new(a: number, b: number): number {
11430 if(!isWasmInitialized) {
11431 throw new Error("initializeWasm() must be awaited first!");
11433 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_new(a, b);
11434 return nativeResponseValue;
11436 // void C2Tuple_u32TxOutZ_free(struct LDKC2Tuple_u32TxOutZ _res);
11438 export function C2Tuple_u32TxOutZ_free(_res: number): void {
11439 if(!isWasmInitialized) {
11440 throw new Error("initializeWasm() must be awaited first!");
11442 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_free(_res);
11443 // debug statements here
11445 // void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
11447 export function CVec_C2Tuple_u32TxOutZZ_free(_res: number): void {
11448 if(!isWasmInitialized) {
11449 throw new Error("initializeWasm() must be awaited first!");
11451 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32TxOutZZ_free(_res);
11452 // debug statements here
11454 // uintptr_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg);
11456 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg: number): number {
11457 if(!isWasmInitialized) {
11458 throw new Error("initializeWasm() must be awaited first!");
11460 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg);
11461 return nativeResponseValue;
11463 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR orig);
11465 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig: number): number {
11466 if(!isWasmInitialized) {
11467 throw new Error("initializeWasm() must be awaited first!");
11469 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig);
11470 return nativeResponseValue;
11472 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
11474 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a: number, b: number): number {
11475 if(!isWasmInitialized) {
11476 throw new Error("initializeWasm() must be awaited first!");
11478 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a, b);
11479 return nativeResponseValue;
11481 // void C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res);
11483 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res: number): void {
11484 if(!isWasmInitialized) {
11485 throw new Error("initializeWasm() must be awaited first!");
11487 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res);
11488 // debug statements here
11490 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res);
11492 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res: number): void {
11493 if(!isWasmInitialized) {
11494 throw new Error("initializeWasm() must be awaited first!");
11496 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res);
11497 // debug statements here
11499 // void CVec_BalanceZ_free(struct LDKCVec_BalanceZ _res);
11501 export function CVec_BalanceZ_free(_res: number): void {
11502 if(!isWasmInitialized) {
11503 throw new Error("initializeWasm() must be awaited first!");
11505 const nativeResponseValue = wasm.TS_CVec_BalanceZ_free(_res);
11506 // debug statements here
11508 // uintptr_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg);
11510 export function C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg: number): number {
11511 if(!isWasmInitialized) {
11512 throw new Error("initializeWasm() must be awaited first!");
11514 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg);
11515 return nativeResponseValue;
11517 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_clone(const struct LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR orig);
11519 export function C2Tuple_BlockHashChannelMonitorZ_clone(orig: number): number {
11520 if(!isWasmInitialized) {
11521 throw new Error("initializeWasm() must be awaited first!");
11523 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone(orig);
11524 return nativeResponseValue;
11526 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
11528 export function C2Tuple_BlockHashChannelMonitorZ_new(a: number, b: number): number {
11529 if(!isWasmInitialized) {
11530 throw new Error("initializeWasm() must be awaited first!");
11532 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_new(a, b);
11533 return nativeResponseValue;
11535 // void C2Tuple_BlockHashChannelMonitorZ_free(struct LDKC2Tuple_BlockHashChannelMonitorZ _res);
11537 export function C2Tuple_BlockHashChannelMonitorZ_free(_res: number): void {
11538 if(!isWasmInitialized) {
11539 throw new Error("initializeWasm() must be awaited first!");
11541 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_free(_res);
11542 // debug statements here
11544 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelMonitorZ o);
11546 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o: number): number {
11547 if(!isWasmInitialized) {
11548 throw new Error("initializeWasm() must be awaited first!");
11550 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o);
11551 return nativeResponseValue;
11553 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
11555 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e: number): number {
11556 if(!isWasmInitialized) {
11557 throw new Error("initializeWasm() must be awaited first!");
11559 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e);
11560 return nativeResponseValue;
11562 // bool CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR o);
11564 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o: number): boolean {
11565 if(!isWasmInitialized) {
11566 throw new Error("initializeWasm() must be awaited first!");
11568 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o);
11569 return nativeResponseValue;
11571 // void CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res);
11573 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res: number): void {
11574 if(!isWasmInitialized) {
11575 throw new Error("initializeWasm() must be awaited first!");
11577 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res);
11578 // debug statements here
11580 // uintptr_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg);
11582 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg: number): number {
11583 if(!isWasmInitialized) {
11584 throw new Error("initializeWasm() must be awaited first!");
11586 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg);
11587 return nativeResponseValue;
11589 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR orig);
11591 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig: number): number {
11592 if(!isWasmInitialized) {
11593 throw new Error("initializeWasm() must be awaited first!");
11595 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig);
11596 return nativeResponseValue;
11598 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
11600 export function CResult_NoneLightningErrorZ_ok(): number {
11601 if(!isWasmInitialized) {
11602 throw new Error("initializeWasm() must be awaited first!");
11604 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_ok();
11605 return nativeResponseValue;
11607 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
11609 export function CResult_NoneLightningErrorZ_err(e: number): number {
11610 if(!isWasmInitialized) {
11611 throw new Error("initializeWasm() must be awaited first!");
11613 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_err(e);
11614 return nativeResponseValue;
11616 // bool CResult_NoneLightningErrorZ_is_ok(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR o);
11618 export function CResult_NoneLightningErrorZ_is_ok(o: number): boolean {
11619 if(!isWasmInitialized) {
11620 throw new Error("initializeWasm() must be awaited first!");
11622 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_is_ok(o);
11623 return nativeResponseValue;
11625 // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
11627 export function CResult_NoneLightningErrorZ_free(_res: number): void {
11628 if(!isWasmInitialized) {
11629 throw new Error("initializeWasm() must be awaited first!");
11631 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_free(_res);
11632 // debug statements here
11634 // uintptr_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg);
11636 export function CResult_NoneLightningErrorZ_clone_ptr(arg: number): number {
11637 if(!isWasmInitialized) {
11638 throw new Error("initializeWasm() must be awaited first!");
11640 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone_ptr(arg);
11641 return nativeResponseValue;
11643 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
11645 export function CResult_NoneLightningErrorZ_clone(orig: number): number {
11646 if(!isWasmInitialized) {
11647 throw new Error("initializeWasm() must be awaited first!");
11649 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone(orig);
11650 return nativeResponseValue;
11652 // uintptr_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg);
11654 export function C2Tuple_PublicKeyTypeZ_clone_ptr(arg: number): number {
11655 if(!isWasmInitialized) {
11656 throw new Error("initializeWasm() must be awaited first!");
11658 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone_ptr(arg);
11659 return nativeResponseValue;
11661 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_clone(const struct LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR orig);
11663 export function C2Tuple_PublicKeyTypeZ_clone(orig: number): number {
11664 if(!isWasmInitialized) {
11665 throw new Error("initializeWasm() must be awaited first!");
11667 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone(orig);
11668 return nativeResponseValue;
11670 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_new(struct LDKPublicKey a, struct LDKType b);
11672 export function C2Tuple_PublicKeyTypeZ_new(a: number, b: number): number {
11673 if(!isWasmInitialized) {
11674 throw new Error("initializeWasm() must be awaited first!");
11676 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_new(a, b);
11677 return nativeResponseValue;
11679 // void C2Tuple_PublicKeyTypeZ_free(struct LDKC2Tuple_PublicKeyTypeZ _res);
11681 export function C2Tuple_PublicKeyTypeZ_free(_res: number): void {
11682 if(!isWasmInitialized) {
11683 throw new Error("initializeWasm() must be awaited first!");
11685 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_free(_res);
11686 // debug statements here
11688 // void CVec_C2Tuple_PublicKeyTypeZZ_free(struct LDKCVec_C2Tuple_PublicKeyTypeZZ _res);
11690 export function CVec_C2Tuple_PublicKeyTypeZZ_free(_res: number): void {
11691 if(!isWasmInitialized) {
11692 throw new Error("initializeWasm() must be awaited first!");
11694 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyTypeZZ_free(_res);
11695 // debug statements here
11697 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
11699 export function CResult_boolLightningErrorZ_ok(o: boolean): number {
11700 if(!isWasmInitialized) {
11701 throw new Error("initializeWasm() must be awaited first!");
11703 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_ok(o);
11704 return nativeResponseValue;
11706 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
11708 export function CResult_boolLightningErrorZ_err(e: number): number {
11709 if(!isWasmInitialized) {
11710 throw new Error("initializeWasm() must be awaited first!");
11712 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_err(e);
11713 return nativeResponseValue;
11715 // bool CResult_boolLightningErrorZ_is_ok(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR o);
11717 export function CResult_boolLightningErrorZ_is_ok(o: number): boolean {
11718 if(!isWasmInitialized) {
11719 throw new Error("initializeWasm() must be awaited first!");
11721 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_is_ok(o);
11722 return nativeResponseValue;
11724 // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
11726 export function CResult_boolLightningErrorZ_free(_res: number): void {
11727 if(!isWasmInitialized) {
11728 throw new Error("initializeWasm() must be awaited first!");
11730 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_free(_res);
11731 // debug statements here
11733 // uintptr_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg);
11735 export function CResult_boolLightningErrorZ_clone_ptr(arg: number): number {
11736 if(!isWasmInitialized) {
11737 throw new Error("initializeWasm() must be awaited first!");
11739 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone_ptr(arg);
11740 return nativeResponseValue;
11742 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
11744 export function CResult_boolLightningErrorZ_clone(orig: number): number {
11745 if(!isWasmInitialized) {
11746 throw new Error("initializeWasm() must be awaited first!");
11748 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone(orig);
11749 return nativeResponseValue;
11751 // uintptr_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg);
11753 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg: number): number {
11754 if(!isWasmInitialized) {
11755 throw new Error("initializeWasm() must be awaited first!");
11757 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg);
11758 return nativeResponseValue;
11760 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
11762 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: number): number {
11763 if(!isWasmInitialized) {
11764 throw new Error("initializeWasm() must be awaited first!");
11766 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig);
11767 return nativeResponseValue;
11769 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
11771 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: number, b: number, c: number): number {
11772 if(!isWasmInitialized) {
11773 throw new Error("initializeWasm() must be awaited first!");
11775 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c);
11776 return nativeResponseValue;
11778 // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
11780 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: number): void {
11781 if(!isWasmInitialized) {
11782 throw new Error("initializeWasm() must be awaited first!");
11784 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res);
11785 // debug statements here
11787 // void CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
11789 export function CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: number): void {
11790 if(!isWasmInitialized) {
11791 throw new Error("initializeWasm() must be awaited first!");
11793 const nativeResponseValue = wasm.TS_CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res);
11794 // debug statements here
11796 // void CVec_NodeAnnouncementZ_free(struct LDKCVec_NodeAnnouncementZ _res);
11798 export function CVec_NodeAnnouncementZ_free(_res: number): void {
11799 if(!isWasmInitialized) {
11800 throw new Error("initializeWasm() must be awaited first!");
11802 const nativeResponseValue = wasm.TS_CVec_NodeAnnouncementZ_free(_res);
11803 // debug statements here
11805 // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
11807 export function CVec_PublicKeyZ_free(_res: number): void {
11808 if(!isWasmInitialized) {
11809 throw new Error("initializeWasm() must be awaited first!");
11811 const nativeResponseValue = wasm.TS_CVec_PublicKeyZ_free(_res);
11812 // debug statements here
11814 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
11816 export function CResult_CVec_u8ZPeerHandleErrorZ_ok(o: number): number {
11817 if(!isWasmInitialized) {
11818 throw new Error("initializeWasm() must be awaited first!");
11820 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(o);
11821 return nativeResponseValue;
11823 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
11825 export function CResult_CVec_u8ZPeerHandleErrorZ_err(e: number): number {
11826 if(!isWasmInitialized) {
11827 throw new Error("initializeWasm() must be awaited first!");
11829 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_err(e);
11830 return nativeResponseValue;
11832 // bool CResult_CVec_u8ZPeerHandleErrorZ_is_ok(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR o);
11834 export function CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o: number): boolean {
11835 if(!isWasmInitialized) {
11836 throw new Error("initializeWasm() must be awaited first!");
11838 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o);
11839 return nativeResponseValue;
11841 // void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
11843 export function CResult_CVec_u8ZPeerHandleErrorZ_free(_res: number): void {
11844 if(!isWasmInitialized) {
11845 throw new Error("initializeWasm() must be awaited first!");
11847 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_free(_res);
11848 // debug statements here
11850 // uintptr_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg);
11852 export function CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg: number): number {
11853 if(!isWasmInitialized) {
11854 throw new Error("initializeWasm() must be awaited first!");
11856 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg);
11857 return nativeResponseValue;
11859 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
11861 export function CResult_CVec_u8ZPeerHandleErrorZ_clone(orig: number): number {
11862 if(!isWasmInitialized) {
11863 throw new Error("initializeWasm() must be awaited first!");
11865 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(orig);
11866 return nativeResponseValue;
11868 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
11870 export function CResult_NonePeerHandleErrorZ_ok(): number {
11871 if(!isWasmInitialized) {
11872 throw new Error("initializeWasm() must be awaited first!");
11874 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_ok();
11875 return nativeResponseValue;
11877 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
11879 export function CResult_NonePeerHandleErrorZ_err(e: number): number {
11880 if(!isWasmInitialized) {
11881 throw new Error("initializeWasm() must be awaited first!");
11883 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_err(e);
11884 return nativeResponseValue;
11886 // bool CResult_NonePeerHandleErrorZ_is_ok(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR o);
11888 export function CResult_NonePeerHandleErrorZ_is_ok(o: number): boolean {
11889 if(!isWasmInitialized) {
11890 throw new Error("initializeWasm() must be awaited first!");
11892 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_is_ok(o);
11893 return nativeResponseValue;
11895 // void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
11897 export function CResult_NonePeerHandleErrorZ_free(_res: number): void {
11898 if(!isWasmInitialized) {
11899 throw new Error("initializeWasm() must be awaited first!");
11901 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_free(_res);
11902 // debug statements here
11904 // uintptr_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg);
11906 export function CResult_NonePeerHandleErrorZ_clone_ptr(arg: number): number {
11907 if(!isWasmInitialized) {
11908 throw new Error("initializeWasm() must be awaited first!");
11910 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone_ptr(arg);
11911 return nativeResponseValue;
11913 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
11915 export function CResult_NonePeerHandleErrorZ_clone(orig: number): number {
11916 if(!isWasmInitialized) {
11917 throw new Error("initializeWasm() must be awaited first!");
11919 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone(orig);
11920 return nativeResponseValue;
11922 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
11924 export function CResult_boolPeerHandleErrorZ_ok(o: boolean): number {
11925 if(!isWasmInitialized) {
11926 throw new Error("initializeWasm() must be awaited first!");
11928 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_ok(o);
11929 return nativeResponseValue;
11931 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
11933 export function CResult_boolPeerHandleErrorZ_err(e: number): number {
11934 if(!isWasmInitialized) {
11935 throw new Error("initializeWasm() must be awaited first!");
11937 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_err(e);
11938 return nativeResponseValue;
11940 // bool CResult_boolPeerHandleErrorZ_is_ok(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR o);
11942 export function CResult_boolPeerHandleErrorZ_is_ok(o: number): boolean {
11943 if(!isWasmInitialized) {
11944 throw new Error("initializeWasm() must be awaited first!");
11946 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_is_ok(o);
11947 return nativeResponseValue;
11949 // void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
11951 export function CResult_boolPeerHandleErrorZ_free(_res: number): void {
11952 if(!isWasmInitialized) {
11953 throw new Error("initializeWasm() must be awaited first!");
11955 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_free(_res);
11956 // debug statements here
11958 // uintptr_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg);
11960 export function CResult_boolPeerHandleErrorZ_clone_ptr(arg: number): number {
11961 if(!isWasmInitialized) {
11962 throw new Error("initializeWasm() must be awaited first!");
11964 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone_ptr(arg);
11965 return nativeResponseValue;
11967 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
11969 export function CResult_boolPeerHandleErrorZ_clone(orig: number): number {
11970 if(!isWasmInitialized) {
11971 throw new Error("initializeWasm() must be awaited first!");
11973 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone(orig);
11974 return nativeResponseValue;
11976 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_ok(struct LDKNodeId o);
11978 export function CResult_NodeIdDecodeErrorZ_ok(o: number): number {
11979 if(!isWasmInitialized) {
11980 throw new Error("initializeWasm() must be awaited first!");
11982 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_ok(o);
11983 return nativeResponseValue;
11985 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_err(struct LDKDecodeError e);
11987 export function CResult_NodeIdDecodeErrorZ_err(e: number): number {
11988 if(!isWasmInitialized) {
11989 throw new Error("initializeWasm() must be awaited first!");
11991 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_err(e);
11992 return nativeResponseValue;
11994 // bool CResult_NodeIdDecodeErrorZ_is_ok(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR o);
11996 export function CResult_NodeIdDecodeErrorZ_is_ok(o: number): boolean {
11997 if(!isWasmInitialized) {
11998 throw new Error("initializeWasm() must be awaited first!");
12000 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_is_ok(o);
12001 return nativeResponseValue;
12003 // void CResult_NodeIdDecodeErrorZ_free(struct LDKCResult_NodeIdDecodeErrorZ _res);
12005 export function CResult_NodeIdDecodeErrorZ_free(_res: number): void {
12006 if(!isWasmInitialized) {
12007 throw new Error("initializeWasm() must be awaited first!");
12009 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_free(_res);
12010 // debug statements here
12012 // uintptr_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg);
12014 export function CResult_NodeIdDecodeErrorZ_clone_ptr(arg: number): number {
12015 if(!isWasmInitialized) {
12016 throw new Error("initializeWasm() must be awaited first!");
12018 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone_ptr(arg);
12019 return nativeResponseValue;
12021 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_clone(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR orig);
12023 export function CResult_NodeIdDecodeErrorZ_clone(orig: number): number {
12024 if(!isWasmInitialized) {
12025 throw new Error("initializeWasm() must be awaited first!");
12027 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone(orig);
12028 return nativeResponseValue;
12030 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_ok(struct LDKCOption_NetworkUpdateZ o);
12032 export function CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o: number): number {
12033 if(!isWasmInitialized) {
12034 throw new Error("initializeWasm() must be awaited first!");
12036 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o);
12037 return nativeResponseValue;
12039 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_err(struct LDKDecodeError e);
12041 export function CResult_COption_NetworkUpdateZDecodeErrorZ_err(e: number): number {
12042 if(!isWasmInitialized) {
12043 throw new Error("initializeWasm() must be awaited first!");
12045 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(e);
12046 return nativeResponseValue;
12048 // bool CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR o);
12050 export function CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o: number): boolean {
12051 if(!isWasmInitialized) {
12052 throw new Error("initializeWasm() must be awaited first!");
12054 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o);
12055 return nativeResponseValue;
12057 // void CResult_COption_NetworkUpdateZDecodeErrorZ_free(struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res);
12059 export function CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res: number): void {
12060 if(!isWasmInitialized) {
12061 throw new Error("initializeWasm() must be awaited first!");
12063 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res);
12064 // debug statements here
12066 // uintptr_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg);
12068 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg: number): number {
12069 if(!isWasmInitialized) {
12070 throw new Error("initializeWasm() must be awaited first!");
12072 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg);
12073 return nativeResponseValue;
12075 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_clone(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR orig);
12077 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig: number): number {
12078 if(!isWasmInitialized) {
12079 throw new Error("initializeWasm() must be awaited first!");
12081 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig);
12082 return nativeResponseValue;
12084 // struct LDKCOption_AccessZ COption_AccessZ_some(struct LDKAccess o);
12086 export function COption_AccessZ_some(o: number): number {
12087 if(!isWasmInitialized) {
12088 throw new Error("initializeWasm() must be awaited first!");
12090 const nativeResponseValue = wasm.TS_COption_AccessZ_some(o);
12091 return nativeResponseValue;
12093 // struct LDKCOption_AccessZ COption_AccessZ_none(void);
12095 export function COption_AccessZ_none(): number {
12096 if(!isWasmInitialized) {
12097 throw new Error("initializeWasm() must be awaited first!");
12099 const nativeResponseValue = wasm.TS_COption_AccessZ_none();
12100 return nativeResponseValue;
12102 // void COption_AccessZ_free(struct LDKCOption_AccessZ _res);
12104 export function COption_AccessZ_free(_res: number): void {
12105 if(!isWasmInitialized) {
12106 throw new Error("initializeWasm() must be awaited first!");
12108 const nativeResponseValue = wasm.TS_COption_AccessZ_free(_res);
12109 // debug statements here
12111 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_ok(struct LDKChannelUpdateInfo o);
12113 export function CResult_ChannelUpdateInfoDecodeErrorZ_ok(o: number): number {
12114 if(!isWasmInitialized) {
12115 throw new Error("initializeWasm() must be awaited first!");
12117 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok(o);
12118 return nativeResponseValue;
12120 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_err(struct LDKDecodeError e);
12122 export function CResult_ChannelUpdateInfoDecodeErrorZ_err(e: number): number {
12123 if(!isWasmInitialized) {
12124 throw new Error("initializeWasm() must be awaited first!");
12126 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_err(e);
12127 return nativeResponseValue;
12129 // bool CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR o);
12131 export function CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o: number): boolean {
12132 if(!isWasmInitialized) {
12133 throw new Error("initializeWasm() must be awaited first!");
12135 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o);
12136 return nativeResponseValue;
12138 // void CResult_ChannelUpdateInfoDecodeErrorZ_free(struct LDKCResult_ChannelUpdateInfoDecodeErrorZ _res);
12140 export function CResult_ChannelUpdateInfoDecodeErrorZ_free(_res: number): void {
12141 if(!isWasmInitialized) {
12142 throw new Error("initializeWasm() must be awaited first!");
12144 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_free(_res);
12145 // debug statements here
12147 // uintptr_t CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR arg);
12149 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg: number): number {
12150 if(!isWasmInitialized) {
12151 throw new Error("initializeWasm() must be awaited first!");
12153 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg);
12154 return nativeResponseValue;
12156 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR orig);
12158 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig: number): number {
12159 if(!isWasmInitialized) {
12160 throw new Error("initializeWasm() must be awaited first!");
12162 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig);
12163 return nativeResponseValue;
12165 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
12167 export function CResult_ChannelInfoDecodeErrorZ_ok(o: number): number {
12168 if(!isWasmInitialized) {
12169 throw new Error("initializeWasm() must be awaited first!");
12171 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_ok(o);
12172 return nativeResponseValue;
12174 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
12176 export function CResult_ChannelInfoDecodeErrorZ_err(e: number): number {
12177 if(!isWasmInitialized) {
12178 throw new Error("initializeWasm() must be awaited first!");
12180 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_err(e);
12181 return nativeResponseValue;
12183 // bool CResult_ChannelInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR o);
12185 export function CResult_ChannelInfoDecodeErrorZ_is_ok(o: number): boolean {
12186 if(!isWasmInitialized) {
12187 throw new Error("initializeWasm() must be awaited first!");
12189 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_is_ok(o);
12190 return nativeResponseValue;
12192 // void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
12194 export function CResult_ChannelInfoDecodeErrorZ_free(_res: number): void {
12195 if(!isWasmInitialized) {
12196 throw new Error("initializeWasm() must be awaited first!");
12198 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_free(_res);
12199 // debug statements here
12201 // uintptr_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg);
12203 export function CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg: number): number {
12204 if(!isWasmInitialized) {
12205 throw new Error("initializeWasm() must be awaited first!");
12207 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg);
12208 return nativeResponseValue;
12210 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
12212 export function CResult_ChannelInfoDecodeErrorZ_clone(orig: number): number {
12213 if(!isWasmInitialized) {
12214 throw new Error("initializeWasm() must be awaited first!");
12216 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone(orig);
12217 return nativeResponseValue;
12219 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
12221 export function CResult_RoutingFeesDecodeErrorZ_ok(o: number): number {
12222 if(!isWasmInitialized) {
12223 throw new Error("initializeWasm() must be awaited first!");
12225 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_ok(o);
12226 return nativeResponseValue;
12228 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
12230 export function CResult_RoutingFeesDecodeErrorZ_err(e: number): number {
12231 if(!isWasmInitialized) {
12232 throw new Error("initializeWasm() must be awaited first!");
12234 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_err(e);
12235 return nativeResponseValue;
12237 // bool CResult_RoutingFeesDecodeErrorZ_is_ok(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR o);
12239 export function CResult_RoutingFeesDecodeErrorZ_is_ok(o: number): boolean {
12240 if(!isWasmInitialized) {
12241 throw new Error("initializeWasm() must be awaited first!");
12243 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_is_ok(o);
12244 return nativeResponseValue;
12246 // void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
12248 export function CResult_RoutingFeesDecodeErrorZ_free(_res: number): void {
12249 if(!isWasmInitialized) {
12250 throw new Error("initializeWasm() must be awaited first!");
12252 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_free(_res);
12253 // debug statements here
12255 // uintptr_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg);
12257 export function CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg: number): number {
12258 if(!isWasmInitialized) {
12259 throw new Error("initializeWasm() must be awaited first!");
12261 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg);
12262 return nativeResponseValue;
12264 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
12266 export function CResult_RoutingFeesDecodeErrorZ_clone(orig: number): number {
12267 if(!isWasmInitialized) {
12268 throw new Error("initializeWasm() must be awaited first!");
12270 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone(orig);
12271 return nativeResponseValue;
12273 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
12275 export function CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o: number): number {
12276 if(!isWasmInitialized) {
12277 throw new Error("initializeWasm() must be awaited first!");
12279 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o);
12280 return nativeResponseValue;
12282 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
12284 export function CResult_NodeAnnouncementInfoDecodeErrorZ_err(e: number): number {
12285 if(!isWasmInitialized) {
12286 throw new Error("initializeWasm() must be awaited first!");
12288 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(e);
12289 return nativeResponseValue;
12291 // bool CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR o);
12293 export function CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o: number): boolean {
12294 if(!isWasmInitialized) {
12295 throw new Error("initializeWasm() must be awaited first!");
12297 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o);
12298 return nativeResponseValue;
12300 // void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
12302 export function CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res: number): void {
12303 if(!isWasmInitialized) {
12304 throw new Error("initializeWasm() must be awaited first!");
12306 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res);
12307 // debug statements here
12309 // uintptr_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg);
12311 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg: number): number {
12312 if(!isWasmInitialized) {
12313 throw new Error("initializeWasm() must be awaited first!");
12315 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg);
12316 return nativeResponseValue;
12318 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
12320 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: number): number {
12321 if(!isWasmInitialized) {
12322 throw new Error("initializeWasm() must be awaited first!");
12324 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig);
12325 return nativeResponseValue;
12327 // void CVec_u64Z_free(struct LDKCVec_u64Z _res);
12329 export function CVec_u64Z_free(_res: number): void {
12330 if(!isWasmInitialized) {
12331 throw new Error("initializeWasm() must be awaited first!");
12333 const nativeResponseValue = wasm.TS_CVec_u64Z_free(_res);
12334 // debug statements here
12336 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_ok(struct LDKNodeInfo o);
12338 export function CResult_NodeInfoDecodeErrorZ_ok(o: number): number {
12339 if(!isWasmInitialized) {
12340 throw new Error("initializeWasm() must be awaited first!");
12342 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_ok(o);
12343 return nativeResponseValue;
12345 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
12347 export function CResult_NodeInfoDecodeErrorZ_err(e: number): number {
12348 if(!isWasmInitialized) {
12349 throw new Error("initializeWasm() must be awaited first!");
12351 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_err(e);
12352 return nativeResponseValue;
12354 // bool CResult_NodeInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR o);
12356 export function CResult_NodeInfoDecodeErrorZ_is_ok(o: number): boolean {
12357 if(!isWasmInitialized) {
12358 throw new Error("initializeWasm() must be awaited first!");
12360 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_is_ok(o);
12361 return nativeResponseValue;
12363 // void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
12365 export function CResult_NodeInfoDecodeErrorZ_free(_res: number): void {
12366 if(!isWasmInitialized) {
12367 throw new Error("initializeWasm() must be awaited first!");
12369 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_free(_res);
12370 // debug statements here
12372 // uintptr_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg);
12374 export function CResult_NodeInfoDecodeErrorZ_clone_ptr(arg: number): number {
12375 if(!isWasmInitialized) {
12376 throw new Error("initializeWasm() must be awaited first!");
12378 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(arg);
12379 return nativeResponseValue;
12381 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
12383 export function CResult_NodeInfoDecodeErrorZ_clone(orig: number): number {
12384 if(!isWasmInitialized) {
12385 throw new Error("initializeWasm() must be awaited first!");
12387 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone(orig);
12388 return nativeResponseValue;
12390 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
12392 export function CResult_NetworkGraphDecodeErrorZ_ok(o: number): number {
12393 if(!isWasmInitialized) {
12394 throw new Error("initializeWasm() must be awaited first!");
12396 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_ok(o);
12397 return nativeResponseValue;
12399 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
12401 export function CResult_NetworkGraphDecodeErrorZ_err(e: number): number {
12402 if(!isWasmInitialized) {
12403 throw new Error("initializeWasm() must be awaited first!");
12405 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_err(e);
12406 return nativeResponseValue;
12408 // bool CResult_NetworkGraphDecodeErrorZ_is_ok(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR o);
12410 export function CResult_NetworkGraphDecodeErrorZ_is_ok(o: number): boolean {
12411 if(!isWasmInitialized) {
12412 throw new Error("initializeWasm() must be awaited first!");
12414 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_is_ok(o);
12415 return nativeResponseValue;
12417 // void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
12419 export function CResult_NetworkGraphDecodeErrorZ_free(_res: number): void {
12420 if(!isWasmInitialized) {
12421 throw new Error("initializeWasm() must be awaited first!");
12423 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_free(_res);
12424 // debug statements here
12426 // uintptr_t CResult_NetworkGraphDecodeErrorZ_clone_ptr(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR arg);
12428 export function CResult_NetworkGraphDecodeErrorZ_clone_ptr(arg: number): number {
12429 if(!isWasmInitialized) {
12430 throw new Error("initializeWasm() must be awaited first!");
12432 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_clone_ptr(arg);
12433 return nativeResponseValue;
12435 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_clone(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR orig);
12437 export function CResult_NetworkGraphDecodeErrorZ_clone(orig: number): number {
12438 if(!isWasmInitialized) {
12439 throw new Error("initializeWasm() must be awaited first!");
12441 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_clone(orig);
12442 return nativeResponseValue;
12444 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_some(struct LDKCVec_NetAddressZ o);
12446 export function COption_CVec_NetAddressZZ_some(o: number): number {
12447 if(!isWasmInitialized) {
12448 throw new Error("initializeWasm() must be awaited first!");
12450 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_some(o);
12451 return nativeResponseValue;
12453 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_none(void);
12455 export function COption_CVec_NetAddressZZ_none(): number {
12456 if(!isWasmInitialized) {
12457 throw new Error("initializeWasm() must be awaited first!");
12459 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_none();
12460 return nativeResponseValue;
12462 // void COption_CVec_NetAddressZZ_free(struct LDKCOption_CVec_NetAddressZZ _res);
12464 export function COption_CVec_NetAddressZZ_free(_res: number): void {
12465 if(!isWasmInitialized) {
12466 throw new Error("initializeWasm() must be awaited first!");
12468 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_free(_res);
12469 // debug statements here
12471 // uintptr_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg);
12473 export function COption_CVec_NetAddressZZ_clone_ptr(arg: number): number {
12474 if(!isWasmInitialized) {
12475 throw new Error("initializeWasm() must be awaited first!");
12477 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone_ptr(arg);
12478 return nativeResponseValue;
12480 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_clone(const struct LDKCOption_CVec_NetAddressZZ *NONNULL_PTR orig);
12482 export function COption_CVec_NetAddressZZ_clone(orig: number): number {
12483 if(!isWasmInitialized) {
12484 throw new Error("initializeWasm() must be awaited first!");
12486 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone(orig);
12487 return nativeResponseValue;
12489 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_ok(struct LDKNetAddress o);
12491 export function CResult_NetAddressDecodeErrorZ_ok(o: number): number {
12492 if(!isWasmInitialized) {
12493 throw new Error("initializeWasm() must be awaited first!");
12495 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_ok(o);
12496 return nativeResponseValue;
12498 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_err(struct LDKDecodeError e);
12500 export function CResult_NetAddressDecodeErrorZ_err(e: number): number {
12501 if(!isWasmInitialized) {
12502 throw new Error("initializeWasm() must be awaited first!");
12504 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_err(e);
12505 return nativeResponseValue;
12507 // bool CResult_NetAddressDecodeErrorZ_is_ok(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR o);
12509 export function CResult_NetAddressDecodeErrorZ_is_ok(o: number): boolean {
12510 if(!isWasmInitialized) {
12511 throw new Error("initializeWasm() must be awaited first!");
12513 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_is_ok(o);
12514 return nativeResponseValue;
12516 // void CResult_NetAddressDecodeErrorZ_free(struct LDKCResult_NetAddressDecodeErrorZ _res);
12518 export function CResult_NetAddressDecodeErrorZ_free(_res: number): void {
12519 if(!isWasmInitialized) {
12520 throw new Error("initializeWasm() must be awaited first!");
12522 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_free(_res);
12523 // debug statements here
12525 // uintptr_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg);
12527 export function CResult_NetAddressDecodeErrorZ_clone_ptr(arg: number): number {
12528 if(!isWasmInitialized) {
12529 throw new Error("initializeWasm() must be awaited first!");
12531 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone_ptr(arg);
12532 return nativeResponseValue;
12534 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_clone(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR orig);
12536 export function CResult_NetAddressDecodeErrorZ_clone(orig: number): number {
12537 if(!isWasmInitialized) {
12538 throw new Error("initializeWasm() must be awaited first!");
12540 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone(orig);
12541 return nativeResponseValue;
12543 // void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
12545 export function CVec_UpdateAddHTLCZ_free(_res: number): void {
12546 if(!isWasmInitialized) {
12547 throw new Error("initializeWasm() must be awaited first!");
12549 const nativeResponseValue = wasm.TS_CVec_UpdateAddHTLCZ_free(_res);
12550 // debug statements here
12552 // void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
12554 export function CVec_UpdateFulfillHTLCZ_free(_res: number): void {
12555 if(!isWasmInitialized) {
12556 throw new Error("initializeWasm() must be awaited first!");
12558 const nativeResponseValue = wasm.TS_CVec_UpdateFulfillHTLCZ_free(_res);
12559 // debug statements here
12561 // void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
12563 export function CVec_UpdateFailHTLCZ_free(_res: number): void {
12564 if(!isWasmInitialized) {
12565 throw new Error("initializeWasm() must be awaited first!");
12567 const nativeResponseValue = wasm.TS_CVec_UpdateFailHTLCZ_free(_res);
12568 // debug statements here
12570 // void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
12572 export function CVec_UpdateFailMalformedHTLCZ_free(_res: number): void {
12573 if(!isWasmInitialized) {
12574 throw new Error("initializeWasm() must be awaited first!");
12576 const nativeResponseValue = wasm.TS_CVec_UpdateFailMalformedHTLCZ_free(_res);
12577 // debug statements here
12579 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
12581 export function CResult_AcceptChannelDecodeErrorZ_ok(o: number): number {
12582 if(!isWasmInitialized) {
12583 throw new Error("initializeWasm() must be awaited first!");
12585 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_ok(o);
12586 return nativeResponseValue;
12588 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
12590 export function CResult_AcceptChannelDecodeErrorZ_err(e: number): number {
12591 if(!isWasmInitialized) {
12592 throw new Error("initializeWasm() must be awaited first!");
12594 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_err(e);
12595 return nativeResponseValue;
12597 // bool CResult_AcceptChannelDecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR o);
12599 export function CResult_AcceptChannelDecodeErrorZ_is_ok(o: number): boolean {
12600 if(!isWasmInitialized) {
12601 throw new Error("initializeWasm() must be awaited first!");
12603 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_is_ok(o);
12604 return nativeResponseValue;
12606 // void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
12608 export function CResult_AcceptChannelDecodeErrorZ_free(_res: number): void {
12609 if(!isWasmInitialized) {
12610 throw new Error("initializeWasm() must be awaited first!");
12612 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_free(_res);
12613 // debug statements here
12615 // uintptr_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg);
12617 export function CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg: number): number {
12618 if(!isWasmInitialized) {
12619 throw new Error("initializeWasm() must be awaited first!");
12621 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg);
12622 return nativeResponseValue;
12624 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
12626 export function CResult_AcceptChannelDecodeErrorZ_clone(orig: number): number {
12627 if(!isWasmInitialized) {
12628 throw new Error("initializeWasm() must be awaited first!");
12630 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone(orig);
12631 return nativeResponseValue;
12633 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
12635 export function CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: number): number {
12636 if(!isWasmInitialized) {
12637 throw new Error("initializeWasm() must be awaited first!");
12639 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(o);
12640 return nativeResponseValue;
12642 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
12644 export function CResult_AnnouncementSignaturesDecodeErrorZ_err(e: number): number {
12645 if(!isWasmInitialized) {
12646 throw new Error("initializeWasm() must be awaited first!");
12648 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(e);
12649 return nativeResponseValue;
12651 // bool CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR o);
12653 export function CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o: number): boolean {
12654 if(!isWasmInitialized) {
12655 throw new Error("initializeWasm() must be awaited first!");
12657 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o);
12658 return nativeResponseValue;
12660 // void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
12662 export function CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: number): void {
12663 if(!isWasmInitialized) {
12664 throw new Error("initializeWasm() must be awaited first!");
12666 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(_res);
12667 // debug statements here
12669 // uintptr_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg);
12671 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg: number): number {
12672 if(!isWasmInitialized) {
12673 throw new Error("initializeWasm() must be awaited first!");
12675 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg);
12676 return nativeResponseValue;
12678 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
12680 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: number): number {
12681 if(!isWasmInitialized) {
12682 throw new Error("initializeWasm() must be awaited first!");
12684 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig);
12685 return nativeResponseValue;
12687 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
12689 export function CResult_ChannelReestablishDecodeErrorZ_ok(o: number): number {
12690 if(!isWasmInitialized) {
12691 throw new Error("initializeWasm() must be awaited first!");
12693 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_ok(o);
12694 return nativeResponseValue;
12696 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
12698 export function CResult_ChannelReestablishDecodeErrorZ_err(e: number): number {
12699 if(!isWasmInitialized) {
12700 throw new Error("initializeWasm() must be awaited first!");
12702 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_err(e);
12703 return nativeResponseValue;
12705 // bool CResult_ChannelReestablishDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR o);
12707 export function CResult_ChannelReestablishDecodeErrorZ_is_ok(o: number): boolean {
12708 if(!isWasmInitialized) {
12709 throw new Error("initializeWasm() must be awaited first!");
12711 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(o);
12712 return nativeResponseValue;
12714 // void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
12716 export function CResult_ChannelReestablishDecodeErrorZ_free(_res: number): void {
12717 if(!isWasmInitialized) {
12718 throw new Error("initializeWasm() must be awaited first!");
12720 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_free(_res);
12721 // debug statements here
12723 // uintptr_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg);
12725 export function CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg: number): number {
12726 if(!isWasmInitialized) {
12727 throw new Error("initializeWasm() must be awaited first!");
12729 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg);
12730 return nativeResponseValue;
12732 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
12734 export function CResult_ChannelReestablishDecodeErrorZ_clone(orig: number): number {
12735 if(!isWasmInitialized) {
12736 throw new Error("initializeWasm() must be awaited first!");
12738 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone(orig);
12739 return nativeResponseValue;
12741 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
12743 export function CResult_ClosingSignedDecodeErrorZ_ok(o: number): number {
12744 if(!isWasmInitialized) {
12745 throw new Error("initializeWasm() must be awaited first!");
12747 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_ok(o);
12748 return nativeResponseValue;
12750 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
12752 export function CResult_ClosingSignedDecodeErrorZ_err(e: number): number {
12753 if(!isWasmInitialized) {
12754 throw new Error("initializeWasm() must be awaited first!");
12756 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_err(e);
12757 return nativeResponseValue;
12759 // bool CResult_ClosingSignedDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR o);
12761 export function CResult_ClosingSignedDecodeErrorZ_is_ok(o: number): boolean {
12762 if(!isWasmInitialized) {
12763 throw new Error("initializeWasm() must be awaited first!");
12765 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_is_ok(o);
12766 return nativeResponseValue;
12768 // void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
12770 export function CResult_ClosingSignedDecodeErrorZ_free(_res: number): void {
12771 if(!isWasmInitialized) {
12772 throw new Error("initializeWasm() must be awaited first!");
12774 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_free(_res);
12775 // debug statements here
12777 // uintptr_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg);
12779 export function CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg: number): number {
12780 if(!isWasmInitialized) {
12781 throw new Error("initializeWasm() must be awaited first!");
12783 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg);
12784 return nativeResponseValue;
12786 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
12788 export function CResult_ClosingSignedDecodeErrorZ_clone(orig: number): number {
12789 if(!isWasmInitialized) {
12790 throw new Error("initializeWasm() must be awaited first!");
12792 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone(orig);
12793 return nativeResponseValue;
12795 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(struct LDKClosingSignedFeeRange o);
12797 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o: number): number {
12798 if(!isWasmInitialized) {
12799 throw new Error("initializeWasm() must be awaited first!");
12801 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o);
12802 return nativeResponseValue;
12804 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_err(struct LDKDecodeError e);
12806 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e: number): number {
12807 if(!isWasmInitialized) {
12808 throw new Error("initializeWasm() must be awaited first!");
12810 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e);
12811 return nativeResponseValue;
12813 // bool CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR o);
12815 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o: number): boolean {
12816 if(!isWasmInitialized) {
12817 throw new Error("initializeWasm() must be awaited first!");
12819 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o);
12820 return nativeResponseValue;
12822 // void CResult_ClosingSignedFeeRangeDecodeErrorZ_free(struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res);
12824 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res: number): void {
12825 if(!isWasmInitialized) {
12826 throw new Error("initializeWasm() must be awaited first!");
12828 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res);
12829 // debug statements here
12831 // uintptr_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg);
12833 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg: number): number {
12834 if(!isWasmInitialized) {
12835 throw new Error("initializeWasm() must be awaited first!");
12837 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg);
12838 return nativeResponseValue;
12840 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR orig);
12842 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig: number): number {
12843 if(!isWasmInitialized) {
12844 throw new Error("initializeWasm() must be awaited first!");
12846 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig);
12847 return nativeResponseValue;
12849 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
12851 export function CResult_CommitmentSignedDecodeErrorZ_ok(o: number): number {
12852 if(!isWasmInitialized) {
12853 throw new Error("initializeWasm() must be awaited first!");
12855 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_ok(o);
12856 return nativeResponseValue;
12858 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
12860 export function CResult_CommitmentSignedDecodeErrorZ_err(e: number): number {
12861 if(!isWasmInitialized) {
12862 throw new Error("initializeWasm() must be awaited first!");
12864 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_err(e);
12865 return nativeResponseValue;
12867 // bool CResult_CommitmentSignedDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR o);
12869 export function CResult_CommitmentSignedDecodeErrorZ_is_ok(o: number): boolean {
12870 if(!isWasmInitialized) {
12871 throw new Error("initializeWasm() must be awaited first!");
12873 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(o);
12874 return nativeResponseValue;
12876 // void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
12878 export function CResult_CommitmentSignedDecodeErrorZ_free(_res: number): void {
12879 if(!isWasmInitialized) {
12880 throw new Error("initializeWasm() must be awaited first!");
12882 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_free(_res);
12883 // debug statements here
12885 // uintptr_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg);
12887 export function CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg: number): number {
12888 if(!isWasmInitialized) {
12889 throw new Error("initializeWasm() must be awaited first!");
12891 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg);
12892 return nativeResponseValue;
12894 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
12896 export function CResult_CommitmentSignedDecodeErrorZ_clone(orig: number): number {
12897 if(!isWasmInitialized) {
12898 throw new Error("initializeWasm() must be awaited first!");
12900 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone(orig);
12901 return nativeResponseValue;
12903 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
12905 export function CResult_FundingCreatedDecodeErrorZ_ok(o: number): number {
12906 if(!isWasmInitialized) {
12907 throw new Error("initializeWasm() must be awaited first!");
12909 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_ok(o);
12910 return nativeResponseValue;
12912 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
12914 export function CResult_FundingCreatedDecodeErrorZ_err(e: number): number {
12915 if(!isWasmInitialized) {
12916 throw new Error("initializeWasm() must be awaited first!");
12918 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_err(e);
12919 return nativeResponseValue;
12921 // bool CResult_FundingCreatedDecodeErrorZ_is_ok(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR o);
12923 export function CResult_FundingCreatedDecodeErrorZ_is_ok(o: number): boolean {
12924 if(!isWasmInitialized) {
12925 throw new Error("initializeWasm() must be awaited first!");
12927 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_is_ok(o);
12928 return nativeResponseValue;
12930 // void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
12932 export function CResult_FundingCreatedDecodeErrorZ_free(_res: number): void {
12933 if(!isWasmInitialized) {
12934 throw new Error("initializeWasm() must be awaited first!");
12936 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_free(_res);
12937 // debug statements here
12939 // uintptr_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg);
12941 export function CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg: number): number {
12942 if(!isWasmInitialized) {
12943 throw new Error("initializeWasm() must be awaited first!");
12945 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg);
12946 return nativeResponseValue;
12948 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
12950 export function CResult_FundingCreatedDecodeErrorZ_clone(orig: number): number {
12951 if(!isWasmInitialized) {
12952 throw new Error("initializeWasm() must be awaited first!");
12954 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone(orig);
12955 return nativeResponseValue;
12957 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
12959 export function CResult_FundingSignedDecodeErrorZ_ok(o: number): number {
12960 if(!isWasmInitialized) {
12961 throw new Error("initializeWasm() must be awaited first!");
12963 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_ok(o);
12964 return nativeResponseValue;
12966 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
12968 export function CResult_FundingSignedDecodeErrorZ_err(e: number): number {
12969 if(!isWasmInitialized) {
12970 throw new Error("initializeWasm() must be awaited first!");
12972 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_err(e);
12973 return nativeResponseValue;
12975 // bool CResult_FundingSignedDecodeErrorZ_is_ok(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR o);
12977 export function CResult_FundingSignedDecodeErrorZ_is_ok(o: number): boolean {
12978 if(!isWasmInitialized) {
12979 throw new Error("initializeWasm() must be awaited first!");
12981 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_is_ok(o);
12982 return nativeResponseValue;
12984 // void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
12986 export function CResult_FundingSignedDecodeErrorZ_free(_res: number): void {
12987 if(!isWasmInitialized) {
12988 throw new Error("initializeWasm() must be awaited first!");
12990 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_free(_res);
12991 // debug statements here
12993 // uintptr_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg);
12995 export function CResult_FundingSignedDecodeErrorZ_clone_ptr(arg: number): number {
12996 if(!isWasmInitialized) {
12997 throw new Error("initializeWasm() must be awaited first!");
12999 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(arg);
13000 return nativeResponseValue;
13002 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
13004 export function CResult_FundingSignedDecodeErrorZ_clone(orig: number): number {
13005 if(!isWasmInitialized) {
13006 throw new Error("initializeWasm() must be awaited first!");
13008 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone(orig);
13009 return nativeResponseValue;
13011 // struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_ok(struct LDKFundingLocked o);
13013 export function CResult_FundingLockedDecodeErrorZ_ok(o: number): number {
13014 if(!isWasmInitialized) {
13015 throw new Error("initializeWasm() must be awaited first!");
13017 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_ok(o);
13018 return nativeResponseValue;
13020 // struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_err(struct LDKDecodeError e);
13022 export function CResult_FundingLockedDecodeErrorZ_err(e: number): number {
13023 if(!isWasmInitialized) {
13024 throw new Error("initializeWasm() must be awaited first!");
13026 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_err(e);
13027 return nativeResponseValue;
13029 // bool CResult_FundingLockedDecodeErrorZ_is_ok(const struct LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR o);
13031 export function CResult_FundingLockedDecodeErrorZ_is_ok(o: number): boolean {
13032 if(!isWasmInitialized) {
13033 throw new Error("initializeWasm() must be awaited first!");
13035 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_is_ok(o);
13036 return nativeResponseValue;
13038 // void CResult_FundingLockedDecodeErrorZ_free(struct LDKCResult_FundingLockedDecodeErrorZ _res);
13040 export function CResult_FundingLockedDecodeErrorZ_free(_res: number): void {
13041 if(!isWasmInitialized) {
13042 throw new Error("initializeWasm() must be awaited first!");
13044 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_free(_res);
13045 // debug statements here
13047 // uintptr_t CResult_FundingLockedDecodeErrorZ_clone_ptr(LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR arg);
13049 export function CResult_FundingLockedDecodeErrorZ_clone_ptr(arg: number): number {
13050 if(!isWasmInitialized) {
13051 throw new Error("initializeWasm() must be awaited first!");
13053 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_clone_ptr(arg);
13054 return nativeResponseValue;
13056 // struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_clone(const struct LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR orig);
13058 export function CResult_FundingLockedDecodeErrorZ_clone(orig: number): number {
13059 if(!isWasmInitialized) {
13060 throw new Error("initializeWasm() must be awaited first!");
13062 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_clone(orig);
13063 return nativeResponseValue;
13065 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
13067 export function CResult_InitDecodeErrorZ_ok(o: number): number {
13068 if(!isWasmInitialized) {
13069 throw new Error("initializeWasm() must be awaited first!");
13071 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_ok(o);
13072 return nativeResponseValue;
13074 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
13076 export function CResult_InitDecodeErrorZ_err(e: number): number {
13077 if(!isWasmInitialized) {
13078 throw new Error("initializeWasm() must be awaited first!");
13080 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_err(e);
13081 return nativeResponseValue;
13083 // bool CResult_InitDecodeErrorZ_is_ok(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR o);
13085 export function CResult_InitDecodeErrorZ_is_ok(o: number): boolean {
13086 if(!isWasmInitialized) {
13087 throw new Error("initializeWasm() must be awaited first!");
13089 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_is_ok(o);
13090 return nativeResponseValue;
13092 // void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
13094 export function CResult_InitDecodeErrorZ_free(_res: number): void {
13095 if(!isWasmInitialized) {
13096 throw new Error("initializeWasm() must be awaited first!");
13098 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_free(_res);
13099 // debug statements here
13101 // uintptr_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg);
13103 export function CResult_InitDecodeErrorZ_clone_ptr(arg: number): number {
13104 if(!isWasmInitialized) {
13105 throw new Error("initializeWasm() must be awaited first!");
13107 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone_ptr(arg);
13108 return nativeResponseValue;
13110 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
13112 export function CResult_InitDecodeErrorZ_clone(orig: number): number {
13113 if(!isWasmInitialized) {
13114 throw new Error("initializeWasm() must be awaited first!");
13116 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone(orig);
13117 return nativeResponseValue;
13119 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
13121 export function CResult_OpenChannelDecodeErrorZ_ok(o: number): number {
13122 if(!isWasmInitialized) {
13123 throw new Error("initializeWasm() must be awaited first!");
13125 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_ok(o);
13126 return nativeResponseValue;
13128 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
13130 export function CResult_OpenChannelDecodeErrorZ_err(e: number): number {
13131 if(!isWasmInitialized) {
13132 throw new Error("initializeWasm() must be awaited first!");
13134 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_err(e);
13135 return nativeResponseValue;
13137 // bool CResult_OpenChannelDecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR o);
13139 export function CResult_OpenChannelDecodeErrorZ_is_ok(o: number): boolean {
13140 if(!isWasmInitialized) {
13141 throw new Error("initializeWasm() must be awaited first!");
13143 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_is_ok(o);
13144 return nativeResponseValue;
13146 // void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
13148 export function CResult_OpenChannelDecodeErrorZ_free(_res: number): void {
13149 if(!isWasmInitialized) {
13150 throw new Error("initializeWasm() must be awaited first!");
13152 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_free(_res);
13153 // debug statements here
13155 // uintptr_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg);
13157 export function CResult_OpenChannelDecodeErrorZ_clone_ptr(arg: number): number {
13158 if(!isWasmInitialized) {
13159 throw new Error("initializeWasm() must be awaited first!");
13161 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(arg);
13162 return nativeResponseValue;
13164 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
13166 export function CResult_OpenChannelDecodeErrorZ_clone(orig: number): number {
13167 if(!isWasmInitialized) {
13168 throw new Error("initializeWasm() must be awaited first!");
13170 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone(orig);
13171 return nativeResponseValue;
13173 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
13175 export function CResult_RevokeAndACKDecodeErrorZ_ok(o: number): number {
13176 if(!isWasmInitialized) {
13177 throw new Error("initializeWasm() must be awaited first!");
13179 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_ok(o);
13180 return nativeResponseValue;
13182 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
13184 export function CResult_RevokeAndACKDecodeErrorZ_err(e: number): number {
13185 if(!isWasmInitialized) {
13186 throw new Error("initializeWasm() must be awaited first!");
13188 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_err(e);
13189 return nativeResponseValue;
13191 // bool CResult_RevokeAndACKDecodeErrorZ_is_ok(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR o);
13193 export function CResult_RevokeAndACKDecodeErrorZ_is_ok(o: number): boolean {
13194 if(!isWasmInitialized) {
13195 throw new Error("initializeWasm() must be awaited first!");
13197 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(o);
13198 return nativeResponseValue;
13200 // void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
13202 export function CResult_RevokeAndACKDecodeErrorZ_free(_res: number): void {
13203 if(!isWasmInitialized) {
13204 throw new Error("initializeWasm() must be awaited first!");
13206 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_free(_res);
13207 // debug statements here
13209 // uintptr_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg);
13211 export function CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg: number): number {
13212 if(!isWasmInitialized) {
13213 throw new Error("initializeWasm() must be awaited first!");
13215 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg);
13216 return nativeResponseValue;
13218 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
13220 export function CResult_RevokeAndACKDecodeErrorZ_clone(orig: number): number {
13221 if(!isWasmInitialized) {
13222 throw new Error("initializeWasm() must be awaited first!");
13224 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone(orig);
13225 return nativeResponseValue;
13227 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
13229 export function CResult_ShutdownDecodeErrorZ_ok(o: number): number {
13230 if(!isWasmInitialized) {
13231 throw new Error("initializeWasm() must be awaited first!");
13233 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_ok(o);
13234 return nativeResponseValue;
13236 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
13238 export function CResult_ShutdownDecodeErrorZ_err(e: number): number {
13239 if(!isWasmInitialized) {
13240 throw new Error("initializeWasm() must be awaited first!");
13242 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_err(e);
13243 return nativeResponseValue;
13245 // bool CResult_ShutdownDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR o);
13247 export function CResult_ShutdownDecodeErrorZ_is_ok(o: number): boolean {
13248 if(!isWasmInitialized) {
13249 throw new Error("initializeWasm() must be awaited first!");
13251 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_is_ok(o);
13252 return nativeResponseValue;
13254 // void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
13256 export function CResult_ShutdownDecodeErrorZ_free(_res: number): void {
13257 if(!isWasmInitialized) {
13258 throw new Error("initializeWasm() must be awaited first!");
13260 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_free(_res);
13261 // debug statements here
13263 // uintptr_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg);
13265 export function CResult_ShutdownDecodeErrorZ_clone_ptr(arg: number): number {
13266 if(!isWasmInitialized) {
13267 throw new Error("initializeWasm() must be awaited first!");
13269 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone_ptr(arg);
13270 return nativeResponseValue;
13272 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
13274 export function CResult_ShutdownDecodeErrorZ_clone(orig: number): number {
13275 if(!isWasmInitialized) {
13276 throw new Error("initializeWasm() must be awaited first!");
13278 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone(orig);
13279 return nativeResponseValue;
13281 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
13283 export function CResult_UpdateFailHTLCDecodeErrorZ_ok(o: number): number {
13284 if(!isWasmInitialized) {
13285 throw new Error("initializeWasm() must be awaited first!");
13287 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(o);
13288 return nativeResponseValue;
13290 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
13292 export function CResult_UpdateFailHTLCDecodeErrorZ_err(e: number): number {
13293 if(!isWasmInitialized) {
13294 throw new Error("initializeWasm() must be awaited first!");
13296 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_err(e);
13297 return nativeResponseValue;
13299 // bool CResult_UpdateFailHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR o);
13301 export function CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o: number): boolean {
13302 if(!isWasmInitialized) {
13303 throw new Error("initializeWasm() must be awaited first!");
13305 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o);
13306 return nativeResponseValue;
13308 // void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
13310 export function CResult_UpdateFailHTLCDecodeErrorZ_free(_res: number): void {
13311 if(!isWasmInitialized) {
13312 throw new Error("initializeWasm() must be awaited first!");
13314 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_free(_res);
13315 // debug statements here
13317 // uintptr_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg);
13319 export function CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg: number): number {
13320 if(!isWasmInitialized) {
13321 throw new Error("initializeWasm() must be awaited first!");
13323 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg);
13324 return nativeResponseValue;
13326 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
13328 export function CResult_UpdateFailHTLCDecodeErrorZ_clone(orig: number): number {
13329 if(!isWasmInitialized) {
13330 throw new Error("initializeWasm() must be awaited first!");
13332 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(orig);
13333 return nativeResponseValue;
13335 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
13337 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o: number): number {
13338 if(!isWasmInitialized) {
13339 throw new Error("initializeWasm() must be awaited first!");
13341 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o);
13342 return nativeResponseValue;
13344 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
13346 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e: number): number {
13347 if(!isWasmInitialized) {
13348 throw new Error("initializeWasm() must be awaited first!");
13350 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e);
13351 return nativeResponseValue;
13353 // bool CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR o);
13355 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o: number): boolean {
13356 if(!isWasmInitialized) {
13357 throw new Error("initializeWasm() must be awaited first!");
13359 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o);
13360 return nativeResponseValue;
13362 // void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
13364 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res: number): void {
13365 if(!isWasmInitialized) {
13366 throw new Error("initializeWasm() must be awaited first!");
13368 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res);
13369 // debug statements here
13371 // uintptr_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg);
13373 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg: number): number {
13374 if(!isWasmInitialized) {
13375 throw new Error("initializeWasm() must be awaited first!");
13377 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg);
13378 return nativeResponseValue;
13380 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
13382 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig: number): number {
13383 if(!isWasmInitialized) {
13384 throw new Error("initializeWasm() must be awaited first!");
13386 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig);
13387 return nativeResponseValue;
13389 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
13391 export function CResult_UpdateFeeDecodeErrorZ_ok(o: number): number {
13392 if(!isWasmInitialized) {
13393 throw new Error("initializeWasm() must be awaited first!");
13395 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_ok(o);
13396 return nativeResponseValue;
13398 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
13400 export function CResult_UpdateFeeDecodeErrorZ_err(e: number): number {
13401 if(!isWasmInitialized) {
13402 throw new Error("initializeWasm() must be awaited first!");
13404 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_err(e);
13405 return nativeResponseValue;
13407 // bool CResult_UpdateFeeDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR o);
13409 export function CResult_UpdateFeeDecodeErrorZ_is_ok(o: number): boolean {
13410 if(!isWasmInitialized) {
13411 throw new Error("initializeWasm() must be awaited first!");
13413 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_is_ok(o);
13414 return nativeResponseValue;
13416 // void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
13418 export function CResult_UpdateFeeDecodeErrorZ_free(_res: number): void {
13419 if(!isWasmInitialized) {
13420 throw new Error("initializeWasm() must be awaited first!");
13422 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_free(_res);
13423 // debug statements here
13425 // uintptr_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg);
13427 export function CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg: number): number {
13428 if(!isWasmInitialized) {
13429 throw new Error("initializeWasm() must be awaited first!");
13431 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg);
13432 return nativeResponseValue;
13434 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
13436 export function CResult_UpdateFeeDecodeErrorZ_clone(orig: number): number {
13437 if(!isWasmInitialized) {
13438 throw new Error("initializeWasm() must be awaited first!");
13440 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone(orig);
13441 return nativeResponseValue;
13443 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
13445 export function CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o: number): number {
13446 if(!isWasmInitialized) {
13447 throw new Error("initializeWasm() must be awaited first!");
13449 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o);
13450 return nativeResponseValue;
13452 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
13454 export function CResult_UpdateFulfillHTLCDecodeErrorZ_err(e: number): number {
13455 if(!isWasmInitialized) {
13456 throw new Error("initializeWasm() must be awaited first!");
13458 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(e);
13459 return nativeResponseValue;
13461 // bool CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR o);
13463 export function CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o: number): boolean {
13464 if(!isWasmInitialized) {
13465 throw new Error("initializeWasm() must be awaited first!");
13467 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o);
13468 return nativeResponseValue;
13470 // void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
13472 export function CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res: number): void {
13473 if(!isWasmInitialized) {
13474 throw new Error("initializeWasm() must be awaited first!");
13476 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res);
13477 // debug statements here
13479 // uintptr_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg);
13481 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg: number): number {
13482 if(!isWasmInitialized) {
13483 throw new Error("initializeWasm() must be awaited first!");
13485 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg);
13486 return nativeResponseValue;
13488 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
13490 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig: number): number {
13491 if(!isWasmInitialized) {
13492 throw new Error("initializeWasm() must be awaited first!");
13494 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig);
13495 return nativeResponseValue;
13497 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
13499 export function CResult_UpdateAddHTLCDecodeErrorZ_ok(o: number): number {
13500 if(!isWasmInitialized) {
13501 throw new Error("initializeWasm() must be awaited first!");
13503 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(o);
13504 return nativeResponseValue;
13506 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
13508 export function CResult_UpdateAddHTLCDecodeErrorZ_err(e: number): number {
13509 if(!isWasmInitialized) {
13510 throw new Error("initializeWasm() must be awaited first!");
13512 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_err(e);
13513 return nativeResponseValue;
13515 // bool CResult_UpdateAddHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR o);
13517 export function CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o: number): boolean {
13518 if(!isWasmInitialized) {
13519 throw new Error("initializeWasm() must be awaited first!");
13521 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o);
13522 return nativeResponseValue;
13524 // void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
13526 export function CResult_UpdateAddHTLCDecodeErrorZ_free(_res: number): void {
13527 if(!isWasmInitialized) {
13528 throw new Error("initializeWasm() must be awaited first!");
13530 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_free(_res);
13531 // debug statements here
13533 // uintptr_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg);
13535 export function CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg: number): number {
13536 if(!isWasmInitialized) {
13537 throw new Error("initializeWasm() must be awaited first!");
13539 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg);
13540 return nativeResponseValue;
13542 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
13544 export function CResult_UpdateAddHTLCDecodeErrorZ_clone(orig: number): number {
13545 if(!isWasmInitialized) {
13546 throw new Error("initializeWasm() must be awaited first!");
13548 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(orig);
13549 return nativeResponseValue;
13551 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
13553 export function CResult_PingDecodeErrorZ_ok(o: number): number {
13554 if(!isWasmInitialized) {
13555 throw new Error("initializeWasm() must be awaited first!");
13557 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_ok(o);
13558 return nativeResponseValue;
13560 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
13562 export function CResult_PingDecodeErrorZ_err(e: number): number {
13563 if(!isWasmInitialized) {
13564 throw new Error("initializeWasm() must be awaited first!");
13566 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_err(e);
13567 return nativeResponseValue;
13569 // bool CResult_PingDecodeErrorZ_is_ok(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR o);
13571 export function CResult_PingDecodeErrorZ_is_ok(o: number): boolean {
13572 if(!isWasmInitialized) {
13573 throw new Error("initializeWasm() must be awaited first!");
13575 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_is_ok(o);
13576 return nativeResponseValue;
13578 // void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
13580 export function CResult_PingDecodeErrorZ_free(_res: number): void {
13581 if(!isWasmInitialized) {
13582 throw new Error("initializeWasm() must be awaited first!");
13584 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_free(_res);
13585 // debug statements here
13587 // uintptr_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg);
13589 export function CResult_PingDecodeErrorZ_clone_ptr(arg: number): number {
13590 if(!isWasmInitialized) {
13591 throw new Error("initializeWasm() must be awaited first!");
13593 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone_ptr(arg);
13594 return nativeResponseValue;
13596 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
13598 export function CResult_PingDecodeErrorZ_clone(orig: number): number {
13599 if(!isWasmInitialized) {
13600 throw new Error("initializeWasm() must be awaited first!");
13602 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone(orig);
13603 return nativeResponseValue;
13605 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
13607 export function CResult_PongDecodeErrorZ_ok(o: number): number {
13608 if(!isWasmInitialized) {
13609 throw new Error("initializeWasm() must be awaited first!");
13611 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_ok(o);
13612 return nativeResponseValue;
13614 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
13616 export function CResult_PongDecodeErrorZ_err(e: number): number {
13617 if(!isWasmInitialized) {
13618 throw new Error("initializeWasm() must be awaited first!");
13620 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_err(e);
13621 return nativeResponseValue;
13623 // bool CResult_PongDecodeErrorZ_is_ok(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR o);
13625 export function CResult_PongDecodeErrorZ_is_ok(o: number): boolean {
13626 if(!isWasmInitialized) {
13627 throw new Error("initializeWasm() must be awaited first!");
13629 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_is_ok(o);
13630 return nativeResponseValue;
13632 // void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
13634 export function CResult_PongDecodeErrorZ_free(_res: number): void {
13635 if(!isWasmInitialized) {
13636 throw new Error("initializeWasm() must be awaited first!");
13638 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_free(_res);
13639 // debug statements here
13641 // uintptr_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg);
13643 export function CResult_PongDecodeErrorZ_clone_ptr(arg: number): number {
13644 if(!isWasmInitialized) {
13645 throw new Error("initializeWasm() must be awaited first!");
13647 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone_ptr(arg);
13648 return nativeResponseValue;
13650 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
13652 export function CResult_PongDecodeErrorZ_clone(orig: number): number {
13653 if(!isWasmInitialized) {
13654 throw new Error("initializeWasm() must be awaited first!");
13656 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone(orig);
13657 return nativeResponseValue;
13659 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
13661 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o: number): number {
13662 if(!isWasmInitialized) {
13663 throw new Error("initializeWasm() must be awaited first!");
13665 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o);
13666 return nativeResponseValue;
13668 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
13670 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e: number): number {
13671 if(!isWasmInitialized) {
13672 throw new Error("initializeWasm() must be awaited first!");
13674 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e);
13675 return nativeResponseValue;
13677 // bool CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
13679 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
13680 if(!isWasmInitialized) {
13681 throw new Error("initializeWasm() must be awaited first!");
13683 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o);
13684 return nativeResponseValue;
13686 // void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
13688 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res: number): void {
13689 if(!isWasmInitialized) {
13690 throw new Error("initializeWasm() must be awaited first!");
13692 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res);
13693 // debug statements here
13695 // uintptr_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
13697 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
13698 if(!isWasmInitialized) {
13699 throw new Error("initializeWasm() must be awaited first!");
13701 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
13702 return nativeResponseValue;
13704 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
13706 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
13707 if(!isWasmInitialized) {
13708 throw new Error("initializeWasm() must be awaited first!");
13710 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig);
13711 return nativeResponseValue;
13713 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
13715 export function CResult_ChannelAnnouncementDecodeErrorZ_ok(o: number): number {
13716 if(!isWasmInitialized) {
13717 throw new Error("initializeWasm() must be awaited first!");
13719 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(o);
13720 return nativeResponseValue;
13722 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
13724 export function CResult_ChannelAnnouncementDecodeErrorZ_err(e: number): number {
13725 if(!isWasmInitialized) {
13726 throw new Error("initializeWasm() must be awaited first!");
13728 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_err(e);
13729 return nativeResponseValue;
13731 // bool CResult_ChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
13733 export function CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
13734 if(!isWasmInitialized) {
13735 throw new Error("initializeWasm() must be awaited first!");
13737 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o);
13738 return nativeResponseValue;
13740 // void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
13742 export function CResult_ChannelAnnouncementDecodeErrorZ_free(_res: number): void {
13743 if(!isWasmInitialized) {
13744 throw new Error("initializeWasm() must be awaited first!");
13746 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_free(_res);
13747 // debug statements here
13749 // uintptr_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
13751 export function CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
13752 if(!isWasmInitialized) {
13753 throw new Error("initializeWasm() must be awaited first!");
13755 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
13756 return nativeResponseValue;
13758 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
13760 export function CResult_ChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
13761 if(!isWasmInitialized) {
13762 throw new Error("initializeWasm() must be awaited first!");
13764 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(orig);
13765 return nativeResponseValue;
13767 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
13769 export function CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o: number): number {
13770 if(!isWasmInitialized) {
13771 throw new Error("initializeWasm() must be awaited first!");
13773 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o);
13774 return nativeResponseValue;
13776 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
13778 export function CResult_UnsignedChannelUpdateDecodeErrorZ_err(e: number): number {
13779 if(!isWasmInitialized) {
13780 throw new Error("initializeWasm() must be awaited first!");
13782 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(e);
13783 return nativeResponseValue;
13785 // bool CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR o);
13787 export function CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o: number): boolean {
13788 if(!isWasmInitialized) {
13789 throw new Error("initializeWasm() must be awaited first!");
13791 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o);
13792 return nativeResponseValue;
13794 // void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
13796 export function CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res: number): void {
13797 if(!isWasmInitialized) {
13798 throw new Error("initializeWasm() must be awaited first!");
13800 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res);
13801 // debug statements here
13803 // uintptr_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
13805 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg: number): number {
13806 if(!isWasmInitialized) {
13807 throw new Error("initializeWasm() must be awaited first!");
13809 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg);
13810 return nativeResponseValue;
13812 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
13814 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig: number): number {
13815 if(!isWasmInitialized) {
13816 throw new Error("initializeWasm() must be awaited first!");
13818 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig);
13819 return nativeResponseValue;
13821 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
13823 export function CResult_ChannelUpdateDecodeErrorZ_ok(o: number): number {
13824 if(!isWasmInitialized) {
13825 throw new Error("initializeWasm() must be awaited first!");
13827 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_ok(o);
13828 return nativeResponseValue;
13830 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
13832 export function CResult_ChannelUpdateDecodeErrorZ_err(e: number): number {
13833 if(!isWasmInitialized) {
13834 throw new Error("initializeWasm() must be awaited first!");
13836 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_err(e);
13837 return nativeResponseValue;
13839 // bool CResult_ChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR o);
13841 export function CResult_ChannelUpdateDecodeErrorZ_is_ok(o: number): boolean {
13842 if(!isWasmInitialized) {
13843 throw new Error("initializeWasm() must be awaited first!");
13845 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(o);
13846 return nativeResponseValue;
13848 // void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
13850 export function CResult_ChannelUpdateDecodeErrorZ_free(_res: number): void {
13851 if(!isWasmInitialized) {
13852 throw new Error("initializeWasm() must be awaited first!");
13854 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_free(_res);
13855 // debug statements here
13857 // uintptr_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
13859 export function CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg: number): number {
13860 if(!isWasmInitialized) {
13861 throw new Error("initializeWasm() must be awaited first!");
13863 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg);
13864 return nativeResponseValue;
13866 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
13868 export function CResult_ChannelUpdateDecodeErrorZ_clone(orig: number): number {
13869 if(!isWasmInitialized) {
13870 throw new Error("initializeWasm() must be awaited first!");
13872 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone(orig);
13873 return nativeResponseValue;
13875 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
13877 export function CResult_ErrorMessageDecodeErrorZ_ok(o: number): number {
13878 if(!isWasmInitialized) {
13879 throw new Error("initializeWasm() must be awaited first!");
13881 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_ok(o);
13882 return nativeResponseValue;
13884 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
13886 export function CResult_ErrorMessageDecodeErrorZ_err(e: number): number {
13887 if(!isWasmInitialized) {
13888 throw new Error("initializeWasm() must be awaited first!");
13890 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_err(e);
13891 return nativeResponseValue;
13893 // bool CResult_ErrorMessageDecodeErrorZ_is_ok(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR o);
13895 export function CResult_ErrorMessageDecodeErrorZ_is_ok(o: number): boolean {
13896 if(!isWasmInitialized) {
13897 throw new Error("initializeWasm() must be awaited first!");
13899 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_is_ok(o);
13900 return nativeResponseValue;
13902 // void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
13904 export function CResult_ErrorMessageDecodeErrorZ_free(_res: number): void {
13905 if(!isWasmInitialized) {
13906 throw new Error("initializeWasm() must be awaited first!");
13908 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_free(_res);
13909 // debug statements here
13911 // uintptr_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg);
13913 export function CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg: number): number {
13914 if(!isWasmInitialized) {
13915 throw new Error("initializeWasm() must be awaited first!");
13917 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg);
13918 return nativeResponseValue;
13920 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
13922 export function CResult_ErrorMessageDecodeErrorZ_clone(orig: number): number {
13923 if(!isWasmInitialized) {
13924 throw new Error("initializeWasm() must be awaited first!");
13926 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone(orig);
13927 return nativeResponseValue;
13929 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_ok(struct LDKWarningMessage o);
13931 export function CResult_WarningMessageDecodeErrorZ_ok(o: number): number {
13932 if(!isWasmInitialized) {
13933 throw new Error("initializeWasm() must be awaited first!");
13935 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_ok(o);
13936 return nativeResponseValue;
13938 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_err(struct LDKDecodeError e);
13940 export function CResult_WarningMessageDecodeErrorZ_err(e: number): number {
13941 if(!isWasmInitialized) {
13942 throw new Error("initializeWasm() must be awaited first!");
13944 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_err(e);
13945 return nativeResponseValue;
13947 // bool CResult_WarningMessageDecodeErrorZ_is_ok(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR o);
13949 export function CResult_WarningMessageDecodeErrorZ_is_ok(o: number): boolean {
13950 if(!isWasmInitialized) {
13951 throw new Error("initializeWasm() must be awaited first!");
13953 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_is_ok(o);
13954 return nativeResponseValue;
13956 // void CResult_WarningMessageDecodeErrorZ_free(struct LDKCResult_WarningMessageDecodeErrorZ _res);
13958 export function CResult_WarningMessageDecodeErrorZ_free(_res: number): void {
13959 if(!isWasmInitialized) {
13960 throw new Error("initializeWasm() must be awaited first!");
13962 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_free(_res);
13963 // debug statements here
13965 // uintptr_t CResult_WarningMessageDecodeErrorZ_clone_ptr(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR arg);
13967 export function CResult_WarningMessageDecodeErrorZ_clone_ptr(arg: number): number {
13968 if(!isWasmInitialized) {
13969 throw new Error("initializeWasm() must be awaited first!");
13971 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone_ptr(arg);
13972 return nativeResponseValue;
13974 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_clone(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR orig);
13976 export function CResult_WarningMessageDecodeErrorZ_clone(orig: number): number {
13977 if(!isWasmInitialized) {
13978 throw new Error("initializeWasm() must be awaited first!");
13980 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone(orig);
13981 return nativeResponseValue;
13983 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
13985 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o: number): number {
13986 if(!isWasmInitialized) {
13987 throw new Error("initializeWasm() must be awaited first!");
13989 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o);
13990 return nativeResponseValue;
13992 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
13994 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e: number): number {
13995 if(!isWasmInitialized) {
13996 throw new Error("initializeWasm() must be awaited first!");
13998 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e);
13999 return nativeResponseValue;
14001 // bool CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
14003 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
14004 if(!isWasmInitialized) {
14005 throw new Error("initializeWasm() must be awaited first!");
14007 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o);
14008 return nativeResponseValue;
14010 // void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
14012 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res: number): void {
14013 if(!isWasmInitialized) {
14014 throw new Error("initializeWasm() must be awaited first!");
14016 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res);
14017 // debug statements here
14019 // uintptr_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14021 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
14022 if(!isWasmInitialized) {
14023 throw new Error("initializeWasm() must be awaited first!");
14025 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg);
14026 return nativeResponseValue;
14028 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14030 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig: number): number {
14031 if(!isWasmInitialized) {
14032 throw new Error("initializeWasm() must be awaited first!");
14034 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig);
14035 return nativeResponseValue;
14037 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
14039 export function CResult_NodeAnnouncementDecodeErrorZ_ok(o: number): number {
14040 if(!isWasmInitialized) {
14041 throw new Error("initializeWasm() must be awaited first!");
14043 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_ok(o);
14044 return nativeResponseValue;
14046 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
14048 export function CResult_NodeAnnouncementDecodeErrorZ_err(e: number): number {
14049 if(!isWasmInitialized) {
14050 throw new Error("initializeWasm() must be awaited first!");
14052 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_err(e);
14053 return nativeResponseValue;
14055 // bool CResult_NodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
14057 export function CResult_NodeAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
14058 if(!isWasmInitialized) {
14059 throw new Error("initializeWasm() must be awaited first!");
14061 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(o);
14062 return nativeResponseValue;
14064 // void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
14066 export function CResult_NodeAnnouncementDecodeErrorZ_free(_res: number): void {
14067 if(!isWasmInitialized) {
14068 throw new Error("initializeWasm() must be awaited first!");
14070 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_free(_res);
14071 // debug statements here
14073 // uintptr_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14075 export function CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
14076 if(!isWasmInitialized) {
14077 throw new Error("initializeWasm() must be awaited first!");
14079 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg);
14080 return nativeResponseValue;
14082 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14084 export function CResult_NodeAnnouncementDecodeErrorZ_clone(orig: number): number {
14085 if(!isWasmInitialized) {
14086 throw new Error("initializeWasm() must be awaited first!");
14088 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone(orig);
14089 return nativeResponseValue;
14091 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
14093 export function CResult_QueryShortChannelIdsDecodeErrorZ_ok(o: number): number {
14094 if(!isWasmInitialized) {
14095 throw new Error("initializeWasm() must be awaited first!");
14097 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(o);
14098 return nativeResponseValue;
14100 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
14102 export function CResult_QueryShortChannelIdsDecodeErrorZ_err(e: number): number {
14103 if(!isWasmInitialized) {
14104 throw new Error("initializeWasm() must be awaited first!");
14106 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(e);
14107 return nativeResponseValue;
14109 // bool CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR o);
14111 export function CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o: number): boolean {
14112 if(!isWasmInitialized) {
14113 throw new Error("initializeWasm() must be awaited first!");
14115 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o);
14116 return nativeResponseValue;
14118 // void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
14120 export function CResult_QueryShortChannelIdsDecodeErrorZ_free(_res: number): void {
14121 if(!isWasmInitialized) {
14122 throw new Error("initializeWasm() must be awaited first!");
14124 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(_res);
14125 // debug statements here
14127 // uintptr_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg);
14129 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg: number): number {
14130 if(!isWasmInitialized) {
14131 throw new Error("initializeWasm() must be awaited first!");
14133 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg);
14134 return nativeResponseValue;
14136 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
14138 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig: number): number {
14139 if(!isWasmInitialized) {
14140 throw new Error("initializeWasm() must be awaited first!");
14142 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig);
14143 return nativeResponseValue;
14145 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
14147 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o: number): number {
14148 if(!isWasmInitialized) {
14149 throw new Error("initializeWasm() must be awaited first!");
14151 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o);
14152 return nativeResponseValue;
14154 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
14156 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e: number): number {
14157 if(!isWasmInitialized) {
14158 throw new Error("initializeWasm() must be awaited first!");
14160 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e);
14161 return nativeResponseValue;
14163 // bool CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR o);
14165 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o: number): boolean {
14166 if(!isWasmInitialized) {
14167 throw new Error("initializeWasm() must be awaited first!");
14169 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o);
14170 return nativeResponseValue;
14172 // void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
14174 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res: number): void {
14175 if(!isWasmInitialized) {
14176 throw new Error("initializeWasm() must be awaited first!");
14178 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res);
14179 // debug statements here
14181 // uintptr_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg);
14183 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg: number): number {
14184 if(!isWasmInitialized) {
14185 throw new Error("initializeWasm() must be awaited first!");
14187 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg);
14188 return nativeResponseValue;
14190 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
14192 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig: number): number {
14193 if(!isWasmInitialized) {
14194 throw new Error("initializeWasm() must be awaited first!");
14196 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig);
14197 return nativeResponseValue;
14199 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
14201 export function CResult_QueryChannelRangeDecodeErrorZ_ok(o: number): number {
14202 if(!isWasmInitialized) {
14203 throw new Error("initializeWasm() must be awaited first!");
14205 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_ok(o);
14206 return nativeResponseValue;
14208 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
14210 export function CResult_QueryChannelRangeDecodeErrorZ_err(e: number): number {
14211 if(!isWasmInitialized) {
14212 throw new Error("initializeWasm() must be awaited first!");
14214 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_err(e);
14215 return nativeResponseValue;
14217 // bool CResult_QueryChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR o);
14219 export function CResult_QueryChannelRangeDecodeErrorZ_is_ok(o: number): boolean {
14220 if(!isWasmInitialized) {
14221 throw new Error("initializeWasm() must be awaited first!");
14223 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(o);
14224 return nativeResponseValue;
14226 // void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
14228 export function CResult_QueryChannelRangeDecodeErrorZ_free(_res: number): void {
14229 if(!isWasmInitialized) {
14230 throw new Error("initializeWasm() must be awaited first!");
14232 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_free(_res);
14233 // debug statements here
14235 // uintptr_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg);
14237 export function CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg: number): number {
14238 if(!isWasmInitialized) {
14239 throw new Error("initializeWasm() must be awaited first!");
14241 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg);
14242 return nativeResponseValue;
14244 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
14246 export function CResult_QueryChannelRangeDecodeErrorZ_clone(orig: number): number {
14247 if(!isWasmInitialized) {
14248 throw new Error("initializeWasm() must be awaited first!");
14250 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone(orig);
14251 return nativeResponseValue;
14253 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
14255 export function CResult_ReplyChannelRangeDecodeErrorZ_ok(o: number): number {
14256 if(!isWasmInitialized) {
14257 throw new Error("initializeWasm() must be awaited first!");
14259 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(o);
14260 return nativeResponseValue;
14262 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
14264 export function CResult_ReplyChannelRangeDecodeErrorZ_err(e: number): number {
14265 if(!isWasmInitialized) {
14266 throw new Error("initializeWasm() must be awaited first!");
14268 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_err(e);
14269 return nativeResponseValue;
14271 // bool CResult_ReplyChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR o);
14273 export function CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o: number): boolean {
14274 if(!isWasmInitialized) {
14275 throw new Error("initializeWasm() must be awaited first!");
14277 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o);
14278 return nativeResponseValue;
14280 // void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
14282 export function CResult_ReplyChannelRangeDecodeErrorZ_free(_res: number): void {
14283 if(!isWasmInitialized) {
14284 throw new Error("initializeWasm() must be awaited first!");
14286 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_free(_res);
14287 // debug statements here
14289 // uintptr_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg);
14291 export function CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg: number): number {
14292 if(!isWasmInitialized) {
14293 throw new Error("initializeWasm() must be awaited first!");
14295 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg);
14296 return nativeResponseValue;
14298 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
14300 export function CResult_ReplyChannelRangeDecodeErrorZ_clone(orig: number): number {
14301 if(!isWasmInitialized) {
14302 throw new Error("initializeWasm() must be awaited first!");
14304 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(orig);
14305 return nativeResponseValue;
14307 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
14309 export function CResult_GossipTimestampFilterDecodeErrorZ_ok(o: number): number {
14310 if(!isWasmInitialized) {
14311 throw new Error("initializeWasm() must be awaited first!");
14313 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(o);
14314 return nativeResponseValue;
14316 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
14318 export function CResult_GossipTimestampFilterDecodeErrorZ_err(e: number): number {
14319 if(!isWasmInitialized) {
14320 throw new Error("initializeWasm() must be awaited first!");
14322 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_err(e);
14323 return nativeResponseValue;
14325 // bool CResult_GossipTimestampFilterDecodeErrorZ_is_ok(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR o);
14327 export function CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o: number): boolean {
14328 if(!isWasmInitialized) {
14329 throw new Error("initializeWasm() must be awaited first!");
14331 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o);
14332 return nativeResponseValue;
14334 // void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
14336 export function CResult_GossipTimestampFilterDecodeErrorZ_free(_res: number): void {
14337 if(!isWasmInitialized) {
14338 throw new Error("initializeWasm() must be awaited first!");
14340 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_free(_res);
14341 // debug statements here
14343 // uintptr_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg);
14345 export function CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg: number): number {
14346 if(!isWasmInitialized) {
14347 throw new Error("initializeWasm() must be awaited first!");
14349 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg);
14350 return nativeResponseValue;
14352 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
14354 export function CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: number): number {
14355 if(!isWasmInitialized) {
14356 throw new Error("initializeWasm() must be awaited first!");
14358 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(orig);
14359 return nativeResponseValue;
14361 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_ok(struct LDKInvoice o);
14363 export function CResult_InvoiceSignOrCreationErrorZ_ok(o: number): number {
14364 if(!isWasmInitialized) {
14365 throw new Error("initializeWasm() must be awaited first!");
14367 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_ok(o);
14368 return nativeResponseValue;
14370 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_err(struct LDKSignOrCreationError e);
14372 export function CResult_InvoiceSignOrCreationErrorZ_err(e: number): number {
14373 if(!isWasmInitialized) {
14374 throw new Error("initializeWasm() must be awaited first!");
14376 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_err(e);
14377 return nativeResponseValue;
14379 // bool CResult_InvoiceSignOrCreationErrorZ_is_ok(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR o);
14381 export function CResult_InvoiceSignOrCreationErrorZ_is_ok(o: number): boolean {
14382 if(!isWasmInitialized) {
14383 throw new Error("initializeWasm() must be awaited first!");
14385 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_is_ok(o);
14386 return nativeResponseValue;
14388 // void CResult_InvoiceSignOrCreationErrorZ_free(struct LDKCResult_InvoiceSignOrCreationErrorZ _res);
14390 export function CResult_InvoiceSignOrCreationErrorZ_free(_res: number): void {
14391 if(!isWasmInitialized) {
14392 throw new Error("initializeWasm() must be awaited first!");
14394 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_free(_res);
14395 // debug statements here
14397 // uintptr_t CResult_InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR arg);
14399 export function CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg: number): number {
14400 if(!isWasmInitialized) {
14401 throw new Error("initializeWasm() must be awaited first!");
14403 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg);
14404 return nativeResponseValue;
14406 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_clone(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR orig);
14408 export function CResult_InvoiceSignOrCreationErrorZ_clone(orig: number): number {
14409 if(!isWasmInitialized) {
14410 throw new Error("initializeWasm() must be awaited first!");
14412 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone(orig);
14413 return nativeResponseValue;
14415 // struct LDKCOption_FilterZ COption_FilterZ_some(struct LDKFilter o);
14417 export function COption_FilterZ_some(o: number): number {
14418 if(!isWasmInitialized) {
14419 throw new Error("initializeWasm() must be awaited first!");
14421 const nativeResponseValue = wasm.TS_COption_FilterZ_some(o);
14422 return nativeResponseValue;
14424 // struct LDKCOption_FilterZ COption_FilterZ_none(void);
14426 export function COption_FilterZ_none(): number {
14427 if(!isWasmInitialized) {
14428 throw new Error("initializeWasm() must be awaited first!");
14430 const nativeResponseValue = wasm.TS_COption_FilterZ_none();
14431 return nativeResponseValue;
14433 // void COption_FilterZ_free(struct LDKCOption_FilterZ _res);
14435 export function COption_FilterZ_free(_res: number): void {
14436 if(!isWasmInitialized) {
14437 throw new Error("initializeWasm() must be awaited first!");
14439 const nativeResponseValue = wasm.TS_COption_FilterZ_free(_res);
14440 // debug statements here
14442 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_ok(struct LDKLockedChannelMonitor o);
14444 export function CResult_LockedChannelMonitorNoneZ_ok(o: number): number {
14445 if(!isWasmInitialized) {
14446 throw new Error("initializeWasm() must be awaited first!");
14448 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_ok(o);
14449 return nativeResponseValue;
14451 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_err(void);
14453 export function CResult_LockedChannelMonitorNoneZ_err(): number {
14454 if(!isWasmInitialized) {
14455 throw new Error("initializeWasm() must be awaited first!");
14457 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_err();
14458 return nativeResponseValue;
14460 // bool CResult_LockedChannelMonitorNoneZ_is_ok(const struct LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR o);
14462 export function CResult_LockedChannelMonitorNoneZ_is_ok(o: number): boolean {
14463 if(!isWasmInitialized) {
14464 throw new Error("initializeWasm() must be awaited first!");
14466 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_is_ok(o);
14467 return nativeResponseValue;
14469 // void CResult_LockedChannelMonitorNoneZ_free(struct LDKCResult_LockedChannelMonitorNoneZ _res);
14471 export function CResult_LockedChannelMonitorNoneZ_free(_res: number): void {
14472 if(!isWasmInitialized) {
14473 throw new Error("initializeWasm() must be awaited first!");
14475 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_free(_res);
14476 // debug statements here
14478 // void CVec_OutPointZ_free(struct LDKCVec_OutPointZ _res);
14480 export function CVec_OutPointZ_free(_res: number): void {
14481 if(!isWasmInitialized) {
14482 throw new Error("initializeWasm() must be awaited first!");
14484 const nativeResponseValue = wasm.TS_CVec_OutPointZ_free(_res);
14485 // debug statements here
14487 // void PaymentPurpose_free(struct LDKPaymentPurpose this_ptr);
14489 export function PaymentPurpose_free(this_ptr: number): void {
14490 if(!isWasmInitialized) {
14491 throw new Error("initializeWasm() must be awaited first!");
14493 const nativeResponseValue = wasm.TS_PaymentPurpose_free(this_ptr);
14494 // debug statements here
14496 // uintptr_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg);
14498 export function PaymentPurpose_clone_ptr(arg: number): number {
14499 if(!isWasmInitialized) {
14500 throw new Error("initializeWasm() must be awaited first!");
14502 const nativeResponseValue = wasm.TS_PaymentPurpose_clone_ptr(arg);
14503 return nativeResponseValue;
14505 // struct LDKPaymentPurpose PaymentPurpose_clone(const struct LDKPaymentPurpose *NONNULL_PTR orig);
14507 export function PaymentPurpose_clone(orig: number): number {
14508 if(!isWasmInitialized) {
14509 throw new Error("initializeWasm() must be awaited first!");
14511 const nativeResponseValue = wasm.TS_PaymentPurpose_clone(orig);
14512 return nativeResponseValue;
14514 // struct LDKPaymentPurpose PaymentPurpose_invoice_payment(struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_secret);
14516 export function PaymentPurpose_invoice_payment(payment_preimage: number, payment_secret: number): number {
14517 if(!isWasmInitialized) {
14518 throw new Error("initializeWasm() must be awaited first!");
14520 const nativeResponseValue = wasm.TS_PaymentPurpose_invoice_payment(payment_preimage, payment_secret);
14521 return nativeResponseValue;
14523 // struct LDKPaymentPurpose PaymentPurpose_spontaneous_payment(struct LDKThirtyTwoBytes a);
14525 export function PaymentPurpose_spontaneous_payment(a: number): number {
14526 if(!isWasmInitialized) {
14527 throw new Error("initializeWasm() must be awaited first!");
14529 const nativeResponseValue = wasm.TS_PaymentPurpose_spontaneous_payment(a);
14530 return nativeResponseValue;
14532 // void ClosureReason_free(struct LDKClosureReason this_ptr);
14534 export function ClosureReason_free(this_ptr: number): void {
14535 if(!isWasmInitialized) {
14536 throw new Error("initializeWasm() must be awaited first!");
14538 const nativeResponseValue = wasm.TS_ClosureReason_free(this_ptr);
14539 // debug statements here
14541 // uintptr_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg);
14543 export function ClosureReason_clone_ptr(arg: number): number {
14544 if(!isWasmInitialized) {
14545 throw new Error("initializeWasm() must be awaited first!");
14547 const nativeResponseValue = wasm.TS_ClosureReason_clone_ptr(arg);
14548 return nativeResponseValue;
14550 // struct LDKClosureReason ClosureReason_clone(const struct LDKClosureReason *NONNULL_PTR orig);
14552 export function ClosureReason_clone(orig: number): number {
14553 if(!isWasmInitialized) {
14554 throw new Error("initializeWasm() must be awaited first!");
14556 const nativeResponseValue = wasm.TS_ClosureReason_clone(orig);
14557 return nativeResponseValue;
14559 // struct LDKClosureReason ClosureReason_counterparty_force_closed(struct LDKStr peer_msg);
14561 export function ClosureReason_counterparty_force_closed(peer_msg: number): number {
14562 if(!isWasmInitialized) {
14563 throw new Error("initializeWasm() must be awaited first!");
14565 const nativeResponseValue = wasm.TS_ClosureReason_counterparty_force_closed(peer_msg);
14566 return nativeResponseValue;
14568 // struct LDKClosureReason ClosureReason_holder_force_closed(void);
14570 export function ClosureReason_holder_force_closed(): number {
14571 if(!isWasmInitialized) {
14572 throw new Error("initializeWasm() must be awaited first!");
14574 const nativeResponseValue = wasm.TS_ClosureReason_holder_force_closed();
14575 return nativeResponseValue;
14577 // struct LDKClosureReason ClosureReason_cooperative_closure(void);
14579 export function ClosureReason_cooperative_closure(): number {
14580 if(!isWasmInitialized) {
14581 throw new Error("initializeWasm() must be awaited first!");
14583 const nativeResponseValue = wasm.TS_ClosureReason_cooperative_closure();
14584 return nativeResponseValue;
14586 // struct LDKClosureReason ClosureReason_commitment_tx_confirmed(void);
14588 export function ClosureReason_commitment_tx_confirmed(): number {
14589 if(!isWasmInitialized) {
14590 throw new Error("initializeWasm() must be awaited first!");
14592 const nativeResponseValue = wasm.TS_ClosureReason_commitment_tx_confirmed();
14593 return nativeResponseValue;
14595 // struct LDKClosureReason ClosureReason_funding_timed_out(void);
14597 export function ClosureReason_funding_timed_out(): number {
14598 if(!isWasmInitialized) {
14599 throw new Error("initializeWasm() must be awaited first!");
14601 const nativeResponseValue = wasm.TS_ClosureReason_funding_timed_out();
14602 return nativeResponseValue;
14604 // struct LDKClosureReason ClosureReason_processing_error(struct LDKStr err);
14606 export function ClosureReason_processing_error(err: number): number {
14607 if(!isWasmInitialized) {
14608 throw new Error("initializeWasm() must be awaited first!");
14610 const nativeResponseValue = wasm.TS_ClosureReason_processing_error(err);
14611 return nativeResponseValue;
14613 // struct LDKClosureReason ClosureReason_disconnected_peer(void);
14615 export function ClosureReason_disconnected_peer(): number {
14616 if(!isWasmInitialized) {
14617 throw new Error("initializeWasm() must be awaited first!");
14619 const nativeResponseValue = wasm.TS_ClosureReason_disconnected_peer();
14620 return nativeResponseValue;
14622 // struct LDKClosureReason ClosureReason_outdated_channel_manager(void);
14624 export function ClosureReason_outdated_channel_manager(): number {
14625 if(!isWasmInitialized) {
14626 throw new Error("initializeWasm() must be awaited first!");
14628 const nativeResponseValue = wasm.TS_ClosureReason_outdated_channel_manager();
14629 return nativeResponseValue;
14631 // struct LDKCVec_u8Z ClosureReason_write(const struct LDKClosureReason *NONNULL_PTR obj);
14633 export function ClosureReason_write(obj: number): number {
14634 if(!isWasmInitialized) {
14635 throw new Error("initializeWasm() must be awaited first!");
14637 const nativeResponseValue = wasm.TS_ClosureReason_write(obj);
14638 return nativeResponseValue;
14640 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ ClosureReason_read(struct LDKu8slice ser);
14642 export function ClosureReason_read(ser: number): number {
14643 if(!isWasmInitialized) {
14644 throw new Error("initializeWasm() must be awaited first!");
14646 const nativeResponseValue = wasm.TS_ClosureReason_read(ser);
14647 return nativeResponseValue;
14649 // void Event_free(struct LDKEvent this_ptr);
14651 export function Event_free(this_ptr: number): void {
14652 if(!isWasmInitialized) {
14653 throw new Error("initializeWasm() must be awaited first!");
14655 const nativeResponseValue = wasm.TS_Event_free(this_ptr);
14656 // debug statements here
14658 // uintptr_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg);
14660 export function Event_clone_ptr(arg: number): number {
14661 if(!isWasmInitialized) {
14662 throw new Error("initializeWasm() must be awaited first!");
14664 const nativeResponseValue = wasm.TS_Event_clone_ptr(arg);
14665 return nativeResponseValue;
14667 // struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
14669 export function Event_clone(orig: number): number {
14670 if(!isWasmInitialized) {
14671 throw new Error("initializeWasm() must be awaited first!");
14673 const nativeResponseValue = wasm.TS_Event_clone(orig);
14674 return nativeResponseValue;
14676 // 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);
14678 export function Event_funding_generation_ready(temporary_channel_id: number, channel_value_satoshis: bigint, output_script: number, user_channel_id: bigint): number {
14679 if(!isWasmInitialized) {
14680 throw new Error("initializeWasm() must be awaited first!");
14682 const nativeResponseValue = wasm.TS_Event_funding_generation_ready(temporary_channel_id, channel_value_satoshis, output_script, user_channel_id);
14683 return nativeResponseValue;
14685 // struct LDKEvent Event_payment_received(struct LDKThirtyTwoBytes payment_hash, uint64_t amt, struct LDKPaymentPurpose purpose);
14687 export function Event_payment_received(payment_hash: number, amt: bigint, purpose: number): number {
14688 if(!isWasmInitialized) {
14689 throw new Error("initializeWasm() must be awaited first!");
14691 const nativeResponseValue = wasm.TS_Event_payment_received(payment_hash, amt, purpose);
14692 return nativeResponseValue;
14694 // struct LDKEvent Event_payment_sent(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z fee_paid_msat);
14696 export function Event_payment_sent(payment_id: number, payment_preimage: number, payment_hash: number, fee_paid_msat: number): number {
14697 if(!isWasmInitialized) {
14698 throw new Error("initializeWasm() must be awaited first!");
14700 const nativeResponseValue = wasm.TS_Event_payment_sent(payment_id, payment_preimage, payment_hash, fee_paid_msat);
14701 return nativeResponseValue;
14703 // 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);
14705 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 {
14706 if(!isWasmInitialized) {
14707 throw new Error("initializeWasm() must be awaited first!");
14709 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);
14710 return nativeResponseValue;
14712 // struct LDKEvent Event_payment_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash);
14714 export function Event_payment_failed(payment_id: number, payment_hash: number): number {
14715 if(!isWasmInitialized) {
14716 throw new Error("initializeWasm() must be awaited first!");
14718 const nativeResponseValue = wasm.TS_Event_payment_failed(payment_id, payment_hash);
14719 return nativeResponseValue;
14721 // struct LDKEvent Event_pending_htlcs_forwardable(uint64_t time_forwardable);
14723 export function Event_pending_htlcs_forwardable(time_forwardable: bigint): number {
14724 if(!isWasmInitialized) {
14725 throw new Error("initializeWasm() must be awaited first!");
14727 const nativeResponseValue = wasm.TS_Event_pending_htlcs_forwardable(time_forwardable);
14728 return nativeResponseValue;
14730 // struct LDKEvent Event_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ outputs);
14732 export function Event_spendable_outputs(outputs: number): number {
14733 if(!isWasmInitialized) {
14734 throw new Error("initializeWasm() must be awaited first!");
14736 const nativeResponseValue = wasm.TS_Event_spendable_outputs(outputs);
14737 return nativeResponseValue;
14739 // struct LDKEvent Event_payment_forwarded(struct LDKCOption_u64Z fee_earned_msat, bool claim_from_onchain_tx);
14741 export function Event_payment_forwarded(fee_earned_msat: number, claim_from_onchain_tx: boolean): number {
14742 if(!isWasmInitialized) {
14743 throw new Error("initializeWasm() must be awaited first!");
14745 const nativeResponseValue = wasm.TS_Event_payment_forwarded(fee_earned_msat, claim_from_onchain_tx);
14746 return nativeResponseValue;
14748 // struct LDKEvent Event_channel_closed(struct LDKThirtyTwoBytes channel_id, uint64_t user_channel_id, struct LDKClosureReason reason);
14750 export function Event_channel_closed(channel_id: number, user_channel_id: bigint, reason: number): number {
14751 if(!isWasmInitialized) {
14752 throw new Error("initializeWasm() must be awaited first!");
14754 const nativeResponseValue = wasm.TS_Event_channel_closed(channel_id, user_channel_id, reason);
14755 return nativeResponseValue;
14757 // struct LDKEvent Event_discard_funding(struct LDKThirtyTwoBytes channel_id, struct LDKTransaction transaction);
14759 export function Event_discard_funding(channel_id: number, transaction: number): number {
14760 if(!isWasmInitialized) {
14761 throw new Error("initializeWasm() must be awaited first!");
14763 const nativeResponseValue = wasm.TS_Event_discard_funding(channel_id, transaction);
14764 return nativeResponseValue;
14766 // struct LDKEvent Event_payment_path_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path);
14768 export function Event_payment_path_successful(payment_id: number, payment_hash: number, path: number): number {
14769 if(!isWasmInitialized) {
14770 throw new Error("initializeWasm() must be awaited first!");
14772 const nativeResponseValue = wasm.TS_Event_payment_path_successful(payment_id, payment_hash, path);
14773 return nativeResponseValue;
14775 // struct LDKEvent Event_open_channel_request(struct LDKThirtyTwoBytes temporary_channel_id, struct LDKPublicKey counterparty_node_id, uint64_t funding_satoshis, uint64_t push_msat);
14777 export function Event_open_channel_request(temporary_channel_id: number, counterparty_node_id: number, funding_satoshis: bigint, push_msat: bigint): number {
14778 if(!isWasmInitialized) {
14779 throw new Error("initializeWasm() must be awaited first!");
14781 const nativeResponseValue = wasm.TS_Event_open_channel_request(temporary_channel_id, counterparty_node_id, funding_satoshis, push_msat);
14782 return nativeResponseValue;
14784 // struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
14786 export function Event_write(obj: number): number {
14787 if(!isWasmInitialized) {
14788 throw new Error("initializeWasm() must be awaited first!");
14790 const nativeResponseValue = wasm.TS_Event_write(obj);
14791 return nativeResponseValue;
14793 // struct LDKCResult_COption_EventZDecodeErrorZ Event_read(struct LDKu8slice ser);
14795 export function Event_read(ser: number): number {
14796 if(!isWasmInitialized) {
14797 throw new Error("initializeWasm() must be awaited first!");
14799 const nativeResponseValue = wasm.TS_Event_read(ser);
14800 return nativeResponseValue;
14802 // void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
14804 export function MessageSendEvent_free(this_ptr: number): void {
14805 if(!isWasmInitialized) {
14806 throw new Error("initializeWasm() must be awaited first!");
14808 const nativeResponseValue = wasm.TS_MessageSendEvent_free(this_ptr);
14809 // debug statements here
14811 // uintptr_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg);
14813 export function MessageSendEvent_clone_ptr(arg: number): number {
14814 if(!isWasmInitialized) {
14815 throw new Error("initializeWasm() must be awaited first!");
14817 const nativeResponseValue = wasm.TS_MessageSendEvent_clone_ptr(arg);
14818 return nativeResponseValue;
14820 // struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
14822 export function MessageSendEvent_clone(orig: number): number {
14823 if(!isWasmInitialized) {
14824 throw new Error("initializeWasm() must be awaited first!");
14826 const nativeResponseValue = wasm.TS_MessageSendEvent_clone(orig);
14827 return nativeResponseValue;
14829 // struct LDKMessageSendEvent MessageSendEvent_send_accept_channel(struct LDKPublicKey node_id, struct LDKAcceptChannel msg);
14831 export function MessageSendEvent_send_accept_channel(node_id: number, msg: number): number {
14832 if(!isWasmInitialized) {
14833 throw new Error("initializeWasm() must be awaited first!");
14835 const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel(node_id, msg);
14836 return nativeResponseValue;
14838 // struct LDKMessageSendEvent MessageSendEvent_send_open_channel(struct LDKPublicKey node_id, struct LDKOpenChannel msg);
14840 export function MessageSendEvent_send_open_channel(node_id: number, msg: number): number {
14841 if(!isWasmInitialized) {
14842 throw new Error("initializeWasm() must be awaited first!");
14844 const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel(node_id, msg);
14845 return nativeResponseValue;
14847 // struct LDKMessageSendEvent MessageSendEvent_send_funding_created(struct LDKPublicKey node_id, struct LDKFundingCreated msg);
14849 export function MessageSendEvent_send_funding_created(node_id: number, msg: number): number {
14850 if(!isWasmInitialized) {
14851 throw new Error("initializeWasm() must be awaited first!");
14853 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_created(node_id, msg);
14854 return nativeResponseValue;
14856 // struct LDKMessageSendEvent MessageSendEvent_send_funding_signed(struct LDKPublicKey node_id, struct LDKFundingSigned msg);
14858 export function MessageSendEvent_send_funding_signed(node_id: number, msg: number): number {
14859 if(!isWasmInitialized) {
14860 throw new Error("initializeWasm() must be awaited first!");
14862 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_signed(node_id, msg);
14863 return nativeResponseValue;
14865 // struct LDKMessageSendEvent MessageSendEvent_send_funding_locked(struct LDKPublicKey node_id, struct LDKFundingLocked msg);
14867 export function MessageSendEvent_send_funding_locked(node_id: number, msg: number): number {
14868 if(!isWasmInitialized) {
14869 throw new Error("initializeWasm() must be awaited first!");
14871 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_locked(node_id, msg);
14872 return nativeResponseValue;
14874 // struct LDKMessageSendEvent MessageSendEvent_send_announcement_signatures(struct LDKPublicKey node_id, struct LDKAnnouncementSignatures msg);
14876 export function MessageSendEvent_send_announcement_signatures(node_id: number, msg: number): number {
14877 if(!isWasmInitialized) {
14878 throw new Error("initializeWasm() must be awaited first!");
14880 const nativeResponseValue = wasm.TS_MessageSendEvent_send_announcement_signatures(node_id, msg);
14881 return nativeResponseValue;
14883 // struct LDKMessageSendEvent MessageSendEvent_update_htlcs(struct LDKPublicKey node_id, struct LDKCommitmentUpdate updates);
14885 export function MessageSendEvent_update_htlcs(node_id: number, updates: number): number {
14886 if(!isWasmInitialized) {
14887 throw new Error("initializeWasm() must be awaited first!");
14889 const nativeResponseValue = wasm.TS_MessageSendEvent_update_htlcs(node_id, updates);
14890 return nativeResponseValue;
14892 // struct LDKMessageSendEvent MessageSendEvent_send_revoke_and_ack(struct LDKPublicKey node_id, struct LDKRevokeAndACK msg);
14894 export function MessageSendEvent_send_revoke_and_ack(node_id: number, msg: number): number {
14895 if(!isWasmInitialized) {
14896 throw new Error("initializeWasm() must be awaited first!");
14898 const nativeResponseValue = wasm.TS_MessageSendEvent_send_revoke_and_ack(node_id, msg);
14899 return nativeResponseValue;
14901 // struct LDKMessageSendEvent MessageSendEvent_send_closing_signed(struct LDKPublicKey node_id, struct LDKClosingSigned msg);
14903 export function MessageSendEvent_send_closing_signed(node_id: number, msg: number): number {
14904 if(!isWasmInitialized) {
14905 throw new Error("initializeWasm() must be awaited first!");
14907 const nativeResponseValue = wasm.TS_MessageSendEvent_send_closing_signed(node_id, msg);
14908 return nativeResponseValue;
14910 // struct LDKMessageSendEvent MessageSendEvent_send_shutdown(struct LDKPublicKey node_id, struct LDKShutdown msg);
14912 export function MessageSendEvent_send_shutdown(node_id: number, msg: number): number {
14913 if(!isWasmInitialized) {
14914 throw new Error("initializeWasm() must be awaited first!");
14916 const nativeResponseValue = wasm.TS_MessageSendEvent_send_shutdown(node_id, msg);
14917 return nativeResponseValue;
14919 // struct LDKMessageSendEvent MessageSendEvent_send_channel_reestablish(struct LDKPublicKey node_id, struct LDKChannelReestablish msg);
14921 export function MessageSendEvent_send_channel_reestablish(node_id: number, msg: number): number {
14922 if(!isWasmInitialized) {
14923 throw new Error("initializeWasm() must be awaited first!");
14925 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_reestablish(node_id, msg);
14926 return nativeResponseValue;
14928 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_announcement(struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
14930 export function MessageSendEvent_broadcast_channel_announcement(msg: number, update_msg: number): number {
14931 if(!isWasmInitialized) {
14932 throw new Error("initializeWasm() must be awaited first!");
14934 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_announcement(msg, update_msg);
14935 return nativeResponseValue;
14937 // struct LDKMessageSendEvent MessageSendEvent_broadcast_node_announcement(struct LDKNodeAnnouncement msg);
14939 export function MessageSendEvent_broadcast_node_announcement(msg: number): number {
14940 if(!isWasmInitialized) {
14941 throw new Error("initializeWasm() must be awaited first!");
14943 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_node_announcement(msg);
14944 return nativeResponseValue;
14946 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_update(struct LDKChannelUpdate msg);
14948 export function MessageSendEvent_broadcast_channel_update(msg: number): number {
14949 if(!isWasmInitialized) {
14950 throw new Error("initializeWasm() must be awaited first!");
14952 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_update(msg);
14953 return nativeResponseValue;
14955 // struct LDKMessageSendEvent MessageSendEvent_send_channel_update(struct LDKPublicKey node_id, struct LDKChannelUpdate msg);
14957 export function MessageSendEvent_send_channel_update(node_id: number, msg: number): number {
14958 if(!isWasmInitialized) {
14959 throw new Error("initializeWasm() must be awaited first!");
14961 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_update(node_id, msg);
14962 return nativeResponseValue;
14964 // struct LDKMessageSendEvent MessageSendEvent_handle_error(struct LDKPublicKey node_id, struct LDKErrorAction action);
14966 export function MessageSendEvent_handle_error(node_id: number, action: number): number {
14967 if(!isWasmInitialized) {
14968 throw new Error("initializeWasm() must be awaited first!");
14970 const nativeResponseValue = wasm.TS_MessageSendEvent_handle_error(node_id, action);
14971 return nativeResponseValue;
14973 // struct LDKMessageSendEvent MessageSendEvent_send_channel_range_query(struct LDKPublicKey node_id, struct LDKQueryChannelRange msg);
14975 export function MessageSendEvent_send_channel_range_query(node_id: number, msg: number): number {
14976 if(!isWasmInitialized) {
14977 throw new Error("initializeWasm() must be awaited first!");
14979 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_range_query(node_id, msg);
14980 return nativeResponseValue;
14982 // struct LDKMessageSendEvent MessageSendEvent_send_short_ids_query(struct LDKPublicKey node_id, struct LDKQueryShortChannelIds msg);
14984 export function MessageSendEvent_send_short_ids_query(node_id: number, msg: number): number {
14985 if(!isWasmInitialized) {
14986 throw new Error("initializeWasm() must be awaited first!");
14988 const nativeResponseValue = wasm.TS_MessageSendEvent_send_short_ids_query(node_id, msg);
14989 return nativeResponseValue;
14991 // struct LDKMessageSendEvent MessageSendEvent_send_reply_channel_range(struct LDKPublicKey node_id, struct LDKReplyChannelRange msg);
14993 export function MessageSendEvent_send_reply_channel_range(node_id: number, msg: number): number {
14994 if(!isWasmInitialized) {
14995 throw new Error("initializeWasm() must be awaited first!");
14997 const nativeResponseValue = wasm.TS_MessageSendEvent_send_reply_channel_range(node_id, msg);
14998 return nativeResponseValue;
15000 // void MessageSendEventsProvider_free(struct LDKMessageSendEventsProvider this_ptr);
15002 export function MessageSendEventsProvider_free(this_ptr: number): void {
15003 if(!isWasmInitialized) {
15004 throw new Error("initializeWasm() must be awaited first!");
15006 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_free(this_ptr);
15007 // debug statements here
15009 // void EventsProvider_free(struct LDKEventsProvider this_ptr);
15011 export function EventsProvider_free(this_ptr: number): void {
15012 if(!isWasmInitialized) {
15013 throw new Error("initializeWasm() must be awaited first!");
15015 const nativeResponseValue = wasm.TS_EventsProvider_free(this_ptr);
15016 // debug statements here
15018 // void EventHandler_free(struct LDKEventHandler this_ptr);
15020 export function EventHandler_free(this_ptr: number): void {
15021 if(!isWasmInitialized) {
15022 throw new Error("initializeWasm() must be awaited first!");
15024 const nativeResponseValue = wasm.TS_EventHandler_free(this_ptr);
15025 // debug statements here
15027 // void APIError_free(struct LDKAPIError this_ptr);
15029 export function APIError_free(this_ptr: number): void {
15030 if(!isWasmInitialized) {
15031 throw new Error("initializeWasm() must be awaited first!");
15033 const nativeResponseValue = wasm.TS_APIError_free(this_ptr);
15034 // debug statements here
15036 // uintptr_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg);
15038 export function APIError_clone_ptr(arg: number): number {
15039 if(!isWasmInitialized) {
15040 throw new Error("initializeWasm() must be awaited first!");
15042 const nativeResponseValue = wasm.TS_APIError_clone_ptr(arg);
15043 return nativeResponseValue;
15045 // struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
15047 export function APIError_clone(orig: number): number {
15048 if(!isWasmInitialized) {
15049 throw new Error("initializeWasm() must be awaited first!");
15051 const nativeResponseValue = wasm.TS_APIError_clone(orig);
15052 return nativeResponseValue;
15054 // struct LDKAPIError APIError_apimisuse_error(struct LDKStr err);
15056 export function APIError_apimisuse_error(err: number): number {
15057 if(!isWasmInitialized) {
15058 throw new Error("initializeWasm() must be awaited first!");
15060 const nativeResponseValue = wasm.TS_APIError_apimisuse_error(err);
15061 return nativeResponseValue;
15063 // struct LDKAPIError APIError_fee_rate_too_high(struct LDKStr err, uint32_t feerate);
15065 export function APIError_fee_rate_too_high(err: number, feerate: number): number {
15066 if(!isWasmInitialized) {
15067 throw new Error("initializeWasm() must be awaited first!");
15069 const nativeResponseValue = wasm.TS_APIError_fee_rate_too_high(err, feerate);
15070 return nativeResponseValue;
15072 // struct LDKAPIError APIError_route_error(struct LDKStr err);
15074 export function APIError_route_error(err: number): number {
15075 if(!isWasmInitialized) {
15076 throw new Error("initializeWasm() must be awaited first!");
15078 const nativeResponseValue = wasm.TS_APIError_route_error(err);
15079 return nativeResponseValue;
15081 // struct LDKAPIError APIError_channel_unavailable(struct LDKStr err);
15083 export function APIError_channel_unavailable(err: number): number {
15084 if(!isWasmInitialized) {
15085 throw new Error("initializeWasm() must be awaited first!");
15087 const nativeResponseValue = wasm.TS_APIError_channel_unavailable(err);
15088 return nativeResponseValue;
15090 // struct LDKAPIError APIError_monitor_update_failed(void);
15092 export function APIError_monitor_update_failed(): number {
15093 if(!isWasmInitialized) {
15094 throw new Error("initializeWasm() must be awaited first!");
15096 const nativeResponseValue = wasm.TS_APIError_monitor_update_failed();
15097 return nativeResponseValue;
15099 // struct LDKAPIError APIError_incompatible_shutdown_script(struct LDKShutdownScript script);
15101 export function APIError_incompatible_shutdown_script(script: number): number {
15102 if(!isWasmInitialized) {
15103 throw new Error("initializeWasm() must be awaited first!");
15105 const nativeResponseValue = wasm.TS_APIError_incompatible_shutdown_script(script);
15106 return nativeResponseValue;
15108 // struct LDKCResult_StringErrorZ sign(struct LDKu8slice msg, const uint8_t (*sk)[32]);
15110 export function sign(msg: number, sk: number): number {
15111 if(!isWasmInitialized) {
15112 throw new Error("initializeWasm() must be awaited first!");
15114 const nativeResponseValue = wasm.TS_sign(msg, sk);
15115 return nativeResponseValue;
15117 // struct LDKCResult_PublicKeyErrorZ recover_pk(struct LDKu8slice msg, struct LDKStr sig);
15119 export function recover_pk(msg: number, sig: number): number {
15120 if(!isWasmInitialized) {
15121 throw new Error("initializeWasm() must be awaited first!");
15123 const nativeResponseValue = wasm.TS_recover_pk(msg, sig);
15124 return nativeResponseValue;
15126 // bool verify(struct LDKu8slice msg, struct LDKStr sig, struct LDKPublicKey pk);
15128 export function verify(msg: number, sig: number, pk: number): boolean {
15129 if(!isWasmInitialized) {
15130 throw new Error("initializeWasm() must be awaited first!");
15132 const nativeResponseValue = wasm.TS_verify(msg, sig, pk);
15133 return nativeResponseValue;
15135 // struct LDKCVec_u8Z construct_invoice_preimage(struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z data_without_signature);
15137 export function construct_invoice_preimage(hrp_bytes: number, data_without_signature: number): number {
15138 if(!isWasmInitialized) {
15139 throw new Error("initializeWasm() must be awaited first!");
15141 const nativeResponseValue = wasm.TS_construct_invoice_preimage(hrp_bytes, data_without_signature);
15142 return nativeResponseValue;
15144 // enum LDKLevel Level_clone(const enum LDKLevel *NONNULL_PTR orig);
15146 export function Level_clone(orig: number): Level {
15147 if(!isWasmInitialized) {
15148 throw new Error("initializeWasm() must be awaited first!");
15150 const nativeResponseValue = wasm.TS_Level_clone(orig);
15151 return nativeResponseValue;
15153 // enum LDKLevel Level_gossip(void);
15155 export function Level_gossip(): Level {
15156 if(!isWasmInitialized) {
15157 throw new Error("initializeWasm() must be awaited first!");
15159 const nativeResponseValue = wasm.TS_Level_gossip();
15160 return nativeResponseValue;
15162 // enum LDKLevel Level_trace(void);
15164 export function Level_trace(): Level {
15165 if(!isWasmInitialized) {
15166 throw new Error("initializeWasm() must be awaited first!");
15168 const nativeResponseValue = wasm.TS_Level_trace();
15169 return nativeResponseValue;
15171 // enum LDKLevel Level_debug(void);
15173 export function Level_debug(): Level {
15174 if(!isWasmInitialized) {
15175 throw new Error("initializeWasm() must be awaited first!");
15177 const nativeResponseValue = wasm.TS_Level_debug();
15178 return nativeResponseValue;
15180 // enum LDKLevel Level_info(void);
15182 export function Level_info(): Level {
15183 if(!isWasmInitialized) {
15184 throw new Error("initializeWasm() must be awaited first!");
15186 const nativeResponseValue = wasm.TS_Level_info();
15187 return nativeResponseValue;
15189 // enum LDKLevel Level_warn(void);
15191 export function Level_warn(): Level {
15192 if(!isWasmInitialized) {
15193 throw new Error("initializeWasm() must be awaited first!");
15195 const nativeResponseValue = wasm.TS_Level_warn();
15196 return nativeResponseValue;
15198 // enum LDKLevel Level_error(void);
15200 export function Level_error(): Level {
15201 if(!isWasmInitialized) {
15202 throw new Error("initializeWasm() must be awaited first!");
15204 const nativeResponseValue = wasm.TS_Level_error();
15205 return nativeResponseValue;
15207 // bool Level_eq(const enum LDKLevel *NONNULL_PTR a, const enum LDKLevel *NONNULL_PTR b);
15209 export function Level_eq(a: number, b: number): boolean {
15210 if(!isWasmInitialized) {
15211 throw new Error("initializeWasm() must be awaited first!");
15213 const nativeResponseValue = wasm.TS_Level_eq(a, b);
15214 return nativeResponseValue;
15216 // uint64_t Level_hash(const enum LDKLevel *NONNULL_PTR o);
15218 export function Level_hash(o: number): bigint {
15219 if(!isWasmInitialized) {
15220 throw new Error("initializeWasm() must be awaited first!");
15222 const nativeResponseValue = wasm.TS_Level_hash(o);
15223 return nativeResponseValue;
15225 // MUST_USE_RES enum LDKLevel Level_max(void);
15227 export function Level_max(): Level {
15228 if(!isWasmInitialized) {
15229 throw new Error("initializeWasm() must be awaited first!");
15231 const nativeResponseValue = wasm.TS_Level_max();
15232 return nativeResponseValue;
15234 // void Record_free(struct LDKRecord this_obj);
15236 export function Record_free(this_obj: number): void {
15237 if(!isWasmInitialized) {
15238 throw new Error("initializeWasm() must be awaited first!");
15240 const nativeResponseValue = wasm.TS_Record_free(this_obj);
15241 // debug statements here
15243 // enum LDKLevel Record_get_level(const struct LDKRecord *NONNULL_PTR this_ptr);
15245 export function Record_get_level(this_ptr: number): Level {
15246 if(!isWasmInitialized) {
15247 throw new Error("initializeWasm() must be awaited first!");
15249 const nativeResponseValue = wasm.TS_Record_get_level(this_ptr);
15250 return nativeResponseValue;
15252 // void Record_set_level(struct LDKRecord *NONNULL_PTR this_ptr, enum LDKLevel val);
15254 export function Record_set_level(this_ptr: number, val: Level): void {
15255 if(!isWasmInitialized) {
15256 throw new Error("initializeWasm() must be awaited first!");
15258 const nativeResponseValue = wasm.TS_Record_set_level(this_ptr, val);
15259 // debug statements here
15261 // struct LDKStr Record_get_args(const struct LDKRecord *NONNULL_PTR this_ptr);
15263 export function Record_get_args(this_ptr: number): number {
15264 if(!isWasmInitialized) {
15265 throw new Error("initializeWasm() must be awaited first!");
15267 const nativeResponseValue = wasm.TS_Record_get_args(this_ptr);
15268 return nativeResponseValue;
15270 // void Record_set_args(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
15272 export function Record_set_args(this_ptr: number, val: number): void {
15273 if(!isWasmInitialized) {
15274 throw new Error("initializeWasm() must be awaited first!");
15276 const nativeResponseValue = wasm.TS_Record_set_args(this_ptr, val);
15277 // debug statements here
15279 // struct LDKStr Record_get_module_path(const struct LDKRecord *NONNULL_PTR this_ptr);
15281 export function Record_get_module_path(this_ptr: number): number {
15282 if(!isWasmInitialized) {
15283 throw new Error("initializeWasm() must be awaited first!");
15285 const nativeResponseValue = wasm.TS_Record_get_module_path(this_ptr);
15286 return nativeResponseValue;
15288 // void Record_set_module_path(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
15290 export function Record_set_module_path(this_ptr: number, val: number): void {
15291 if(!isWasmInitialized) {
15292 throw new Error("initializeWasm() must be awaited first!");
15294 const nativeResponseValue = wasm.TS_Record_set_module_path(this_ptr, val);
15295 // debug statements here
15297 // struct LDKStr Record_get_file(const struct LDKRecord *NONNULL_PTR this_ptr);
15299 export function Record_get_file(this_ptr: number): number {
15300 if(!isWasmInitialized) {
15301 throw new Error("initializeWasm() must be awaited first!");
15303 const nativeResponseValue = wasm.TS_Record_get_file(this_ptr);
15304 return nativeResponseValue;
15306 // void Record_set_file(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
15308 export function Record_set_file(this_ptr: number, val: number): void {
15309 if(!isWasmInitialized) {
15310 throw new Error("initializeWasm() must be awaited first!");
15312 const nativeResponseValue = wasm.TS_Record_set_file(this_ptr, val);
15313 // debug statements here
15315 // uint32_t Record_get_line(const struct LDKRecord *NONNULL_PTR this_ptr);
15317 export function Record_get_line(this_ptr: number): number {
15318 if(!isWasmInitialized) {
15319 throw new Error("initializeWasm() must be awaited first!");
15321 const nativeResponseValue = wasm.TS_Record_get_line(this_ptr);
15322 return nativeResponseValue;
15324 // void Record_set_line(struct LDKRecord *NONNULL_PTR this_ptr, uint32_t val);
15326 export function Record_set_line(this_ptr: number, val: number): void {
15327 if(!isWasmInitialized) {
15328 throw new Error("initializeWasm() must be awaited first!");
15330 const nativeResponseValue = wasm.TS_Record_set_line(this_ptr, val);
15331 // debug statements here
15333 // uintptr_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg);
15335 export function Record_clone_ptr(arg: number): number {
15336 if(!isWasmInitialized) {
15337 throw new Error("initializeWasm() must be awaited first!");
15339 const nativeResponseValue = wasm.TS_Record_clone_ptr(arg);
15340 return nativeResponseValue;
15342 // struct LDKRecord Record_clone(const struct LDKRecord *NONNULL_PTR orig);
15344 export function Record_clone(orig: number): number {
15345 if(!isWasmInitialized) {
15346 throw new Error("initializeWasm() must be awaited first!");
15348 const nativeResponseValue = wasm.TS_Record_clone(orig);
15349 return nativeResponseValue;
15351 // void Logger_free(struct LDKLogger this_ptr);
15353 export function Logger_free(this_ptr: number): void {
15354 if(!isWasmInitialized) {
15355 throw new Error("initializeWasm() must be awaited first!");
15357 const nativeResponseValue = wasm.TS_Logger_free(this_ptr);
15358 // debug statements here
15360 // void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_obj);
15362 export function ChannelHandshakeConfig_free(this_obj: number): void {
15363 if(!isWasmInitialized) {
15364 throw new Error("initializeWasm() must be awaited first!");
15366 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_free(this_obj);
15367 // debug statements here
15369 // uint32_t ChannelHandshakeConfig_get_minimum_depth(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
15371 export function ChannelHandshakeConfig_get_minimum_depth(this_ptr: number): number {
15372 if(!isWasmInitialized) {
15373 throw new Error("initializeWasm() must be awaited first!");
15375 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_minimum_depth(this_ptr);
15376 return nativeResponseValue;
15378 // void ChannelHandshakeConfig_set_minimum_depth(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
15380 export function ChannelHandshakeConfig_set_minimum_depth(this_ptr: number, val: number): void {
15381 if(!isWasmInitialized) {
15382 throw new Error("initializeWasm() must be awaited first!");
15384 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_minimum_depth(this_ptr, val);
15385 // debug statements here
15387 // uint16_t ChannelHandshakeConfig_get_our_to_self_delay(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
15389 export function ChannelHandshakeConfig_get_our_to_self_delay(this_ptr: number): number {
15390 if(!isWasmInitialized) {
15391 throw new Error("initializeWasm() must be awaited first!");
15393 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_to_self_delay(this_ptr);
15394 return nativeResponseValue;
15396 // void ChannelHandshakeConfig_set_our_to_self_delay(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
15398 export function ChannelHandshakeConfig_set_our_to_self_delay(this_ptr: number, val: number): void {
15399 if(!isWasmInitialized) {
15400 throw new Error("initializeWasm() must be awaited first!");
15402 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_to_self_delay(this_ptr, val);
15403 // debug statements here
15405 // uint64_t ChannelHandshakeConfig_get_our_htlc_minimum_msat(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
15407 export function ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr: number): bigint {
15408 if(!isWasmInitialized) {
15409 throw new Error("initializeWasm() must be awaited first!");
15411 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr);
15412 return nativeResponseValue;
15414 // void ChannelHandshakeConfig_set_our_htlc_minimum_msat(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint64_t val);
15416 export function ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr: number, val: bigint): void {
15417 if(!isWasmInitialized) {
15418 throw new Error("initializeWasm() must be awaited first!");
15420 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr, val);
15421 // debug statements here
15423 // 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);
15425 export function ChannelHandshakeConfig_new(minimum_depth_arg: number, our_to_self_delay_arg: number, our_htlc_minimum_msat_arg: bigint): number {
15426 if(!isWasmInitialized) {
15427 throw new Error("initializeWasm() must be awaited first!");
15429 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_new(minimum_depth_arg, our_to_self_delay_arg, our_htlc_minimum_msat_arg);
15430 return nativeResponseValue;
15432 // uintptr_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg);
15434 export function ChannelHandshakeConfig_clone_ptr(arg: number): number {
15435 if(!isWasmInitialized) {
15436 throw new Error("initializeWasm() must be awaited first!");
15438 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone_ptr(arg);
15439 return nativeResponseValue;
15441 // struct LDKChannelHandshakeConfig ChannelHandshakeConfig_clone(const struct LDKChannelHandshakeConfig *NONNULL_PTR orig);
15443 export function ChannelHandshakeConfig_clone(orig: number): number {
15444 if(!isWasmInitialized) {
15445 throw new Error("initializeWasm() must be awaited first!");
15447 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone(orig);
15448 return nativeResponseValue;
15450 // MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void);
15452 export function ChannelHandshakeConfig_default(): number {
15453 if(!isWasmInitialized) {
15454 throw new Error("initializeWasm() must be awaited first!");
15456 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_default();
15457 return nativeResponseValue;
15459 // void ChannelHandshakeLimits_free(struct LDKChannelHandshakeLimits this_obj);
15461 export function ChannelHandshakeLimits_free(this_obj: number): void {
15462 if(!isWasmInitialized) {
15463 throw new Error("initializeWasm() must be awaited first!");
15465 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_free(this_obj);
15466 // debug statements here
15468 // uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
15470 export function ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr: number): bigint {
15471 if(!isWasmInitialized) {
15472 throw new Error("initializeWasm() must be awaited first!");
15474 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr);
15475 return nativeResponseValue;
15477 // void ChannelHandshakeLimits_set_min_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
15479 export function ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr: number, val: bigint): void {
15480 if(!isWasmInitialized) {
15481 throw new Error("initializeWasm() must be awaited first!");
15483 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr, val);
15484 // debug statements here
15486 // uint64_t ChannelHandshakeLimits_get_max_htlc_minimum_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
15488 export function ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr: number): bigint {
15489 if(!isWasmInitialized) {
15490 throw new Error("initializeWasm() must be awaited first!");
15492 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr);
15493 return nativeResponseValue;
15495 // void ChannelHandshakeLimits_set_max_htlc_minimum_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
15497 export function ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr: number, val: bigint): void {
15498 if(!isWasmInitialized) {
15499 throw new Error("initializeWasm() must be awaited first!");
15501 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr, val);
15502 // debug statements here
15504 // uint64_t ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
15506 export function ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
15507 if(!isWasmInitialized) {
15508 throw new Error("initializeWasm() must be awaited first!");
15510 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr);
15511 return nativeResponseValue;
15513 // void ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
15515 export function ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
15516 if(!isWasmInitialized) {
15517 throw new Error("initializeWasm() must be awaited first!");
15519 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr, val);
15520 // debug statements here
15522 // uint64_t ChannelHandshakeLimits_get_max_channel_reserve_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
15524 export function ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr: number): bigint {
15525 if(!isWasmInitialized) {
15526 throw new Error("initializeWasm() must be awaited first!");
15528 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr);
15529 return nativeResponseValue;
15531 // void ChannelHandshakeLimits_set_max_channel_reserve_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
15533 export function ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
15534 if(!isWasmInitialized) {
15535 throw new Error("initializeWasm() must be awaited first!");
15537 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr, val);
15538 // debug statements here
15540 // uint16_t ChannelHandshakeLimits_get_min_max_accepted_htlcs(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
15542 export function ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr: number): number {
15543 if(!isWasmInitialized) {
15544 throw new Error("initializeWasm() must be awaited first!");
15546 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr);
15547 return nativeResponseValue;
15549 // void ChannelHandshakeLimits_set_min_max_accepted_htlcs(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
15551 export function ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr: number, val: number): void {
15552 if(!isWasmInitialized) {
15553 throw new Error("initializeWasm() must be awaited first!");
15555 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr, val);
15556 // debug statements here
15558 // uint32_t ChannelHandshakeLimits_get_max_minimum_depth(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
15560 export function ChannelHandshakeLimits_get_max_minimum_depth(this_ptr: number): number {
15561 if(!isWasmInitialized) {
15562 throw new Error("initializeWasm() must be awaited first!");
15564 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_minimum_depth(this_ptr);
15565 return nativeResponseValue;
15567 // void ChannelHandshakeLimits_set_max_minimum_depth(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint32_t val);
15569 export function ChannelHandshakeLimits_set_max_minimum_depth(this_ptr: number, val: number): void {
15570 if(!isWasmInitialized) {
15571 throw new Error("initializeWasm() must be awaited first!");
15573 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_minimum_depth(this_ptr, val);
15574 // debug statements here
15576 // bool ChannelHandshakeLimits_get_force_announced_channel_preference(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
15578 export function ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr: number): boolean {
15579 if(!isWasmInitialized) {
15580 throw new Error("initializeWasm() must be awaited first!");
15582 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr);
15583 return nativeResponseValue;
15585 // void ChannelHandshakeLimits_set_force_announced_channel_preference(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
15587 export function ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr: number, val: boolean): void {
15588 if(!isWasmInitialized) {
15589 throw new Error("initializeWasm() must be awaited first!");
15591 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr, val);
15592 // debug statements here
15594 // uint16_t ChannelHandshakeLimits_get_their_to_self_delay(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
15596 export function ChannelHandshakeLimits_get_their_to_self_delay(this_ptr: number): number {
15597 if(!isWasmInitialized) {
15598 throw new Error("initializeWasm() must be awaited first!");
15600 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_their_to_self_delay(this_ptr);
15601 return nativeResponseValue;
15603 // void ChannelHandshakeLimits_set_their_to_self_delay(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
15605 export function ChannelHandshakeLimits_set_their_to_self_delay(this_ptr: number, val: number): void {
15606 if(!isWasmInitialized) {
15607 throw new Error("initializeWasm() must be awaited first!");
15609 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_their_to_self_delay(this_ptr, val);
15610 // debug statements here
15612 // 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);
15614 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 {
15615 if(!isWasmInitialized) {
15616 throw new Error("initializeWasm() must be awaited first!");
15618 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);
15619 return nativeResponseValue;
15621 // uintptr_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg);
15623 export function ChannelHandshakeLimits_clone_ptr(arg: number): number {
15624 if(!isWasmInitialized) {
15625 throw new Error("initializeWasm() must be awaited first!");
15627 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone_ptr(arg);
15628 return nativeResponseValue;
15630 // struct LDKChannelHandshakeLimits ChannelHandshakeLimits_clone(const struct LDKChannelHandshakeLimits *NONNULL_PTR orig);
15632 export function ChannelHandshakeLimits_clone(orig: number): number {
15633 if(!isWasmInitialized) {
15634 throw new Error("initializeWasm() must be awaited first!");
15636 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone(orig);
15637 return nativeResponseValue;
15639 // MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_default(void);
15641 export function ChannelHandshakeLimits_default(): number {
15642 if(!isWasmInitialized) {
15643 throw new Error("initializeWasm() must be awaited first!");
15645 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_default();
15646 return nativeResponseValue;
15648 // void ChannelConfig_free(struct LDKChannelConfig this_obj);
15650 export function ChannelConfig_free(this_obj: number): void {
15651 if(!isWasmInitialized) {
15652 throw new Error("initializeWasm() must be awaited first!");
15654 const nativeResponseValue = wasm.TS_ChannelConfig_free(this_obj);
15655 // debug statements here
15657 // uint32_t ChannelConfig_get_forwarding_fee_proportional_millionths(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
15659 export function ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr: number): number {
15660 if(!isWasmInitialized) {
15661 throw new Error("initializeWasm() must be awaited first!");
15663 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr);
15664 return nativeResponseValue;
15666 // void ChannelConfig_set_forwarding_fee_proportional_millionths(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
15668 export function ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr: number, val: number): void {
15669 if(!isWasmInitialized) {
15670 throw new Error("initializeWasm() must be awaited first!");
15672 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr, val);
15673 // debug statements here
15675 // uint32_t ChannelConfig_get_forwarding_fee_base_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
15677 export function ChannelConfig_get_forwarding_fee_base_msat(this_ptr: number): number {
15678 if(!isWasmInitialized) {
15679 throw new Error("initializeWasm() must be awaited first!");
15681 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_base_msat(this_ptr);
15682 return nativeResponseValue;
15684 // void ChannelConfig_set_forwarding_fee_base_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
15686 export function ChannelConfig_set_forwarding_fee_base_msat(this_ptr: number, val: number): void {
15687 if(!isWasmInitialized) {
15688 throw new Error("initializeWasm() must be awaited first!");
15690 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_base_msat(this_ptr, val);
15691 // debug statements here
15693 // uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
15695 export function ChannelConfig_get_cltv_expiry_delta(this_ptr: number): number {
15696 if(!isWasmInitialized) {
15697 throw new Error("initializeWasm() must be awaited first!");
15699 const nativeResponseValue = wasm.TS_ChannelConfig_get_cltv_expiry_delta(this_ptr);
15700 return nativeResponseValue;
15702 // void ChannelConfig_set_cltv_expiry_delta(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint16_t val);
15704 export function ChannelConfig_set_cltv_expiry_delta(this_ptr: number, val: number): void {
15705 if(!isWasmInitialized) {
15706 throw new Error("initializeWasm() must be awaited first!");
15708 const nativeResponseValue = wasm.TS_ChannelConfig_set_cltv_expiry_delta(this_ptr, val);
15709 // debug statements here
15711 // bool ChannelConfig_get_announced_channel(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
15713 export function ChannelConfig_get_announced_channel(this_ptr: number): boolean {
15714 if(!isWasmInitialized) {
15715 throw new Error("initializeWasm() must be awaited first!");
15717 const nativeResponseValue = wasm.TS_ChannelConfig_get_announced_channel(this_ptr);
15718 return nativeResponseValue;
15720 // void ChannelConfig_set_announced_channel(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
15722 export function ChannelConfig_set_announced_channel(this_ptr: number, val: boolean): void {
15723 if(!isWasmInitialized) {
15724 throw new Error("initializeWasm() must be awaited first!");
15726 const nativeResponseValue = wasm.TS_ChannelConfig_set_announced_channel(this_ptr, val);
15727 // debug statements here
15729 // bool ChannelConfig_get_commit_upfront_shutdown_pubkey(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
15731 export function ChannelConfig_get_commit_upfront_shutdown_pubkey(this_ptr: number): boolean {
15732 if(!isWasmInitialized) {
15733 throw new Error("initializeWasm() must be awaited first!");
15735 const nativeResponseValue = wasm.TS_ChannelConfig_get_commit_upfront_shutdown_pubkey(this_ptr);
15736 return nativeResponseValue;
15738 // void ChannelConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
15740 export function ChannelConfig_set_commit_upfront_shutdown_pubkey(this_ptr: number, val: boolean): void {
15741 if(!isWasmInitialized) {
15742 throw new Error("initializeWasm() must be awaited first!");
15744 const nativeResponseValue = wasm.TS_ChannelConfig_set_commit_upfront_shutdown_pubkey(this_ptr, val);
15745 // debug statements here
15747 // uint64_t ChannelConfig_get_max_dust_htlc_exposure_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
15749 export function ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr: number): bigint {
15750 if(!isWasmInitialized) {
15751 throw new Error("initializeWasm() must be awaited first!");
15753 const nativeResponseValue = wasm.TS_ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr);
15754 return nativeResponseValue;
15756 // void ChannelConfig_set_max_dust_htlc_exposure_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
15758 export function ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr: number, val: bigint): void {
15759 if(!isWasmInitialized) {
15760 throw new Error("initializeWasm() must be awaited first!");
15762 const nativeResponseValue = wasm.TS_ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr, val);
15763 // debug statements here
15765 // uint64_t ChannelConfig_get_force_close_avoidance_max_fee_satoshis(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
15767 export function ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr: number): bigint {
15768 if(!isWasmInitialized) {
15769 throw new Error("initializeWasm() must be awaited first!");
15771 const nativeResponseValue = wasm.TS_ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr);
15772 return nativeResponseValue;
15774 // void ChannelConfig_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
15776 export function ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr: number, val: bigint): void {
15777 if(!isWasmInitialized) {
15778 throw new Error("initializeWasm() must be awaited first!");
15780 const nativeResponseValue = wasm.TS_ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr, val);
15781 // debug statements here
15783 // 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);
15785 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 {
15786 if(!isWasmInitialized) {
15787 throw new Error("initializeWasm() must be awaited first!");
15789 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);
15790 return nativeResponseValue;
15792 // uintptr_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg);
15794 export function ChannelConfig_clone_ptr(arg: number): number {
15795 if(!isWasmInitialized) {
15796 throw new Error("initializeWasm() must be awaited first!");
15798 const nativeResponseValue = wasm.TS_ChannelConfig_clone_ptr(arg);
15799 return nativeResponseValue;
15801 // struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
15803 export function ChannelConfig_clone(orig: number): number {
15804 if(!isWasmInitialized) {
15805 throw new Error("initializeWasm() must be awaited first!");
15807 const nativeResponseValue = wasm.TS_ChannelConfig_clone(orig);
15808 return nativeResponseValue;
15810 // MUST_USE_RES struct LDKChannelConfig ChannelConfig_default(void);
15812 export function ChannelConfig_default(): number {
15813 if(!isWasmInitialized) {
15814 throw new Error("initializeWasm() must be awaited first!");
15816 const nativeResponseValue = wasm.TS_ChannelConfig_default();
15817 return nativeResponseValue;
15819 // struct LDKCVec_u8Z ChannelConfig_write(const struct LDKChannelConfig *NONNULL_PTR obj);
15821 export function ChannelConfig_write(obj: number): number {
15822 if(!isWasmInitialized) {
15823 throw new Error("initializeWasm() must be awaited first!");
15825 const nativeResponseValue = wasm.TS_ChannelConfig_write(obj);
15826 return nativeResponseValue;
15828 // struct LDKCResult_ChannelConfigDecodeErrorZ ChannelConfig_read(struct LDKu8slice ser);
15830 export function ChannelConfig_read(ser: number): number {
15831 if(!isWasmInitialized) {
15832 throw new Error("initializeWasm() must be awaited first!");
15834 const nativeResponseValue = wasm.TS_ChannelConfig_read(ser);
15835 return nativeResponseValue;
15837 // void UserConfig_free(struct LDKUserConfig this_obj);
15839 export function UserConfig_free(this_obj: number): void {
15840 if(!isWasmInitialized) {
15841 throw new Error("initializeWasm() must be awaited first!");
15843 const nativeResponseValue = wasm.TS_UserConfig_free(this_obj);
15844 // debug statements here
15846 // struct LDKChannelHandshakeConfig UserConfig_get_own_channel_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
15848 export function UserConfig_get_own_channel_config(this_ptr: number): number {
15849 if(!isWasmInitialized) {
15850 throw new Error("initializeWasm() must be awaited first!");
15852 const nativeResponseValue = wasm.TS_UserConfig_get_own_channel_config(this_ptr);
15853 return nativeResponseValue;
15855 // void UserConfig_set_own_channel_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeConfig val);
15857 export function UserConfig_set_own_channel_config(this_ptr: number, val: number): void {
15858 if(!isWasmInitialized) {
15859 throw new Error("initializeWasm() must be awaited first!");
15861 const nativeResponseValue = wasm.TS_UserConfig_set_own_channel_config(this_ptr, val);
15862 // debug statements here
15864 // struct LDKChannelHandshakeLimits UserConfig_get_peer_channel_config_limits(const struct LDKUserConfig *NONNULL_PTR this_ptr);
15866 export function UserConfig_get_peer_channel_config_limits(this_ptr: number): number {
15867 if(!isWasmInitialized) {
15868 throw new Error("initializeWasm() must be awaited first!");
15870 const nativeResponseValue = wasm.TS_UserConfig_get_peer_channel_config_limits(this_ptr);
15871 return nativeResponseValue;
15873 // void UserConfig_set_peer_channel_config_limits(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeLimits val);
15875 export function UserConfig_set_peer_channel_config_limits(this_ptr: number, val: number): void {
15876 if(!isWasmInitialized) {
15877 throw new Error("initializeWasm() must be awaited first!");
15879 const nativeResponseValue = wasm.TS_UserConfig_set_peer_channel_config_limits(this_ptr, val);
15880 // debug statements here
15882 // struct LDKChannelConfig UserConfig_get_channel_options(const struct LDKUserConfig *NONNULL_PTR this_ptr);
15884 export function UserConfig_get_channel_options(this_ptr: number): number {
15885 if(!isWasmInitialized) {
15886 throw new Error("initializeWasm() must be awaited first!");
15888 const nativeResponseValue = wasm.TS_UserConfig_get_channel_options(this_ptr);
15889 return nativeResponseValue;
15891 // void UserConfig_set_channel_options(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
15893 export function UserConfig_set_channel_options(this_ptr: number, val: number): void {
15894 if(!isWasmInitialized) {
15895 throw new Error("initializeWasm() must be awaited first!");
15897 const nativeResponseValue = wasm.TS_UserConfig_set_channel_options(this_ptr, val);
15898 // debug statements here
15900 // bool UserConfig_get_accept_forwards_to_priv_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
15902 export function UserConfig_get_accept_forwards_to_priv_channels(this_ptr: number): boolean {
15903 if(!isWasmInitialized) {
15904 throw new Error("initializeWasm() must be awaited first!");
15906 const nativeResponseValue = wasm.TS_UserConfig_get_accept_forwards_to_priv_channels(this_ptr);
15907 return nativeResponseValue;
15909 // void UserConfig_set_accept_forwards_to_priv_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
15911 export function UserConfig_set_accept_forwards_to_priv_channels(this_ptr: number, val: boolean): void {
15912 if(!isWasmInitialized) {
15913 throw new Error("initializeWasm() must be awaited first!");
15915 const nativeResponseValue = wasm.TS_UserConfig_set_accept_forwards_to_priv_channels(this_ptr, val);
15916 // debug statements here
15918 // bool UserConfig_get_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
15920 export function UserConfig_get_accept_inbound_channels(this_ptr: number): boolean {
15921 if(!isWasmInitialized) {
15922 throw new Error("initializeWasm() must be awaited first!");
15924 const nativeResponseValue = wasm.TS_UserConfig_get_accept_inbound_channels(this_ptr);
15925 return nativeResponseValue;
15927 // void UserConfig_set_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
15929 export function UserConfig_set_accept_inbound_channels(this_ptr: number, val: boolean): void {
15930 if(!isWasmInitialized) {
15931 throw new Error("initializeWasm() must be awaited first!");
15933 const nativeResponseValue = wasm.TS_UserConfig_set_accept_inbound_channels(this_ptr, val);
15934 // debug statements here
15936 // bool UserConfig_get_manually_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
15938 export function UserConfig_get_manually_accept_inbound_channels(this_ptr: number): boolean {
15939 if(!isWasmInitialized) {
15940 throw new Error("initializeWasm() must be awaited first!");
15942 const nativeResponseValue = wasm.TS_UserConfig_get_manually_accept_inbound_channels(this_ptr);
15943 return nativeResponseValue;
15945 // void UserConfig_set_manually_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
15947 export function UserConfig_set_manually_accept_inbound_channels(this_ptr: number, val: boolean): void {
15948 if(!isWasmInitialized) {
15949 throw new Error("initializeWasm() must be awaited first!");
15951 const nativeResponseValue = wasm.TS_UserConfig_set_manually_accept_inbound_channels(this_ptr, val);
15952 // debug statements here
15954 // 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);
15956 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 {
15957 if(!isWasmInitialized) {
15958 throw new Error("initializeWasm() must be awaited first!");
15960 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);
15961 return nativeResponseValue;
15963 // uintptr_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg);
15965 export function UserConfig_clone_ptr(arg: number): number {
15966 if(!isWasmInitialized) {
15967 throw new Error("initializeWasm() must be awaited first!");
15969 const nativeResponseValue = wasm.TS_UserConfig_clone_ptr(arg);
15970 return nativeResponseValue;
15972 // struct LDKUserConfig UserConfig_clone(const struct LDKUserConfig *NONNULL_PTR orig);
15974 export function UserConfig_clone(orig: number): number {
15975 if(!isWasmInitialized) {
15976 throw new Error("initializeWasm() must be awaited first!");
15978 const nativeResponseValue = wasm.TS_UserConfig_clone(orig);
15979 return nativeResponseValue;
15981 // MUST_USE_RES struct LDKUserConfig UserConfig_default(void);
15983 export function UserConfig_default(): number {
15984 if(!isWasmInitialized) {
15985 throw new Error("initializeWasm() must be awaited first!");
15987 const nativeResponseValue = wasm.TS_UserConfig_default();
15988 return nativeResponseValue;
15990 // void BestBlock_free(struct LDKBestBlock this_obj);
15992 export function BestBlock_free(this_obj: number): void {
15993 if(!isWasmInitialized) {
15994 throw new Error("initializeWasm() must be awaited first!");
15996 const nativeResponseValue = wasm.TS_BestBlock_free(this_obj);
15997 // debug statements here
15999 // uintptr_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg);
16001 export function BestBlock_clone_ptr(arg: number): number {
16002 if(!isWasmInitialized) {
16003 throw new Error("initializeWasm() must be awaited first!");
16005 const nativeResponseValue = wasm.TS_BestBlock_clone_ptr(arg);
16006 return nativeResponseValue;
16008 // struct LDKBestBlock BestBlock_clone(const struct LDKBestBlock *NONNULL_PTR orig);
16010 export function BestBlock_clone(orig: number): number {
16011 if(!isWasmInitialized) {
16012 throw new Error("initializeWasm() must be awaited first!");
16014 const nativeResponseValue = wasm.TS_BestBlock_clone(orig);
16015 return nativeResponseValue;
16017 // MUST_USE_RES struct LDKBestBlock BestBlock_from_genesis(enum LDKNetwork network);
16019 export function BestBlock_from_genesis(network: Network): number {
16020 if(!isWasmInitialized) {
16021 throw new Error("initializeWasm() must be awaited first!");
16023 const nativeResponseValue = wasm.TS_BestBlock_from_genesis(network);
16024 return nativeResponseValue;
16026 // MUST_USE_RES struct LDKBestBlock BestBlock_new(struct LDKThirtyTwoBytes block_hash, uint32_t height);
16028 export function BestBlock_new(block_hash: number, height: number): number {
16029 if(!isWasmInitialized) {
16030 throw new Error("initializeWasm() must be awaited first!");
16032 const nativeResponseValue = wasm.TS_BestBlock_new(block_hash, height);
16033 return nativeResponseValue;
16035 // MUST_USE_RES struct LDKThirtyTwoBytes BestBlock_block_hash(const struct LDKBestBlock *NONNULL_PTR this_arg);
16037 export function BestBlock_block_hash(this_arg: number): number {
16038 if(!isWasmInitialized) {
16039 throw new Error("initializeWasm() must be awaited first!");
16041 const nativeResponseValue = wasm.TS_BestBlock_block_hash(this_arg);
16042 return nativeResponseValue;
16044 // MUST_USE_RES uint32_t BestBlock_height(const struct LDKBestBlock *NONNULL_PTR this_arg);
16046 export function BestBlock_height(this_arg: number): number {
16047 if(!isWasmInitialized) {
16048 throw new Error("initializeWasm() must be awaited first!");
16050 const nativeResponseValue = wasm.TS_BestBlock_height(this_arg);
16051 return nativeResponseValue;
16053 // enum LDKAccessError AccessError_clone(const enum LDKAccessError *NONNULL_PTR orig);
16055 export function AccessError_clone(orig: number): AccessError {
16056 if(!isWasmInitialized) {
16057 throw new Error("initializeWasm() must be awaited first!");
16059 const nativeResponseValue = wasm.TS_AccessError_clone(orig);
16060 return nativeResponseValue;
16062 // enum LDKAccessError AccessError_unknown_chain(void);
16064 export function AccessError_unknown_chain(): AccessError {
16065 if(!isWasmInitialized) {
16066 throw new Error("initializeWasm() must be awaited first!");
16068 const nativeResponseValue = wasm.TS_AccessError_unknown_chain();
16069 return nativeResponseValue;
16071 // enum LDKAccessError AccessError_unknown_tx(void);
16073 export function AccessError_unknown_tx(): AccessError {
16074 if(!isWasmInitialized) {
16075 throw new Error("initializeWasm() must be awaited first!");
16077 const nativeResponseValue = wasm.TS_AccessError_unknown_tx();
16078 return nativeResponseValue;
16080 // void Access_free(struct LDKAccess this_ptr);
16082 export function Access_free(this_ptr: number): void {
16083 if(!isWasmInitialized) {
16084 throw new Error("initializeWasm() must be awaited first!");
16086 const nativeResponseValue = wasm.TS_Access_free(this_ptr);
16087 // debug statements here
16089 // void Listen_free(struct LDKListen this_ptr);
16091 export function Listen_free(this_ptr: number): void {
16092 if(!isWasmInitialized) {
16093 throw new Error("initializeWasm() must be awaited first!");
16095 const nativeResponseValue = wasm.TS_Listen_free(this_ptr);
16096 // debug statements here
16098 // void Confirm_free(struct LDKConfirm this_ptr);
16100 export function Confirm_free(this_ptr: number): void {
16101 if(!isWasmInitialized) {
16102 throw new Error("initializeWasm() must be awaited first!");
16104 const nativeResponseValue = wasm.TS_Confirm_free(this_ptr);
16105 // debug statements here
16107 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_clone(const enum LDKChannelMonitorUpdateErr *NONNULL_PTR orig);
16109 export function ChannelMonitorUpdateErr_clone(orig: number): ChannelMonitorUpdateErr {
16110 if(!isWasmInitialized) {
16111 throw new Error("initializeWasm() must be awaited first!");
16113 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_clone(orig);
16114 return nativeResponseValue;
16116 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_temporary_failure(void);
16118 export function ChannelMonitorUpdateErr_temporary_failure(): ChannelMonitorUpdateErr {
16119 if(!isWasmInitialized) {
16120 throw new Error("initializeWasm() must be awaited first!");
16122 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_temporary_failure();
16123 return nativeResponseValue;
16125 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_permanent_failure(void);
16127 export function ChannelMonitorUpdateErr_permanent_failure(): ChannelMonitorUpdateErr {
16128 if(!isWasmInitialized) {
16129 throw new Error("initializeWasm() must be awaited first!");
16131 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_permanent_failure();
16132 return nativeResponseValue;
16134 // void Watch_free(struct LDKWatch this_ptr);
16136 export function Watch_free(this_ptr: number): void {
16137 if(!isWasmInitialized) {
16138 throw new Error("initializeWasm() must be awaited first!");
16140 const nativeResponseValue = wasm.TS_Watch_free(this_ptr);
16141 // debug statements here
16143 // void Filter_free(struct LDKFilter this_ptr);
16145 export function Filter_free(this_ptr: number): void {
16146 if(!isWasmInitialized) {
16147 throw new Error("initializeWasm() must be awaited first!");
16149 const nativeResponseValue = wasm.TS_Filter_free(this_ptr);
16150 // debug statements here
16152 // void WatchedOutput_free(struct LDKWatchedOutput this_obj);
16154 export function WatchedOutput_free(this_obj: number): void {
16155 if(!isWasmInitialized) {
16156 throw new Error("initializeWasm() must be awaited first!");
16158 const nativeResponseValue = wasm.TS_WatchedOutput_free(this_obj);
16159 // debug statements here
16161 // struct LDKThirtyTwoBytes WatchedOutput_get_block_hash(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
16163 export function WatchedOutput_get_block_hash(this_ptr: number): number {
16164 if(!isWasmInitialized) {
16165 throw new Error("initializeWasm() must be awaited first!");
16167 const nativeResponseValue = wasm.TS_WatchedOutput_get_block_hash(this_ptr);
16168 return nativeResponseValue;
16170 // void WatchedOutput_set_block_hash(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
16172 export function WatchedOutput_set_block_hash(this_ptr: number, val: number): void {
16173 if(!isWasmInitialized) {
16174 throw new Error("initializeWasm() must be awaited first!");
16176 const nativeResponseValue = wasm.TS_WatchedOutput_set_block_hash(this_ptr, val);
16177 // debug statements here
16179 // struct LDKOutPoint WatchedOutput_get_outpoint(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
16181 export function WatchedOutput_get_outpoint(this_ptr: number): number {
16182 if(!isWasmInitialized) {
16183 throw new Error("initializeWasm() must be awaited first!");
16185 const nativeResponseValue = wasm.TS_WatchedOutput_get_outpoint(this_ptr);
16186 return nativeResponseValue;
16188 // void WatchedOutput_set_outpoint(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
16190 export function WatchedOutput_set_outpoint(this_ptr: number, val: number): void {
16191 if(!isWasmInitialized) {
16192 throw new Error("initializeWasm() must be awaited first!");
16194 const nativeResponseValue = wasm.TS_WatchedOutput_set_outpoint(this_ptr, val);
16195 // debug statements here
16197 // struct LDKu8slice WatchedOutput_get_script_pubkey(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
16199 export function WatchedOutput_get_script_pubkey(this_ptr: number): number {
16200 if(!isWasmInitialized) {
16201 throw new Error("initializeWasm() must be awaited first!");
16203 const nativeResponseValue = wasm.TS_WatchedOutput_get_script_pubkey(this_ptr);
16204 return nativeResponseValue;
16206 // void WatchedOutput_set_script_pubkey(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
16208 export function WatchedOutput_set_script_pubkey(this_ptr: number, val: number): void {
16209 if(!isWasmInitialized) {
16210 throw new Error("initializeWasm() must be awaited first!");
16212 const nativeResponseValue = wasm.TS_WatchedOutput_set_script_pubkey(this_ptr, val);
16213 // debug statements here
16215 // MUST_USE_RES struct LDKWatchedOutput WatchedOutput_new(struct LDKThirtyTwoBytes block_hash_arg, struct LDKOutPoint outpoint_arg, struct LDKCVec_u8Z script_pubkey_arg);
16217 export function WatchedOutput_new(block_hash_arg: number, outpoint_arg: number, script_pubkey_arg: number): number {
16218 if(!isWasmInitialized) {
16219 throw new Error("initializeWasm() must be awaited first!");
16221 const nativeResponseValue = wasm.TS_WatchedOutput_new(block_hash_arg, outpoint_arg, script_pubkey_arg);
16222 return nativeResponseValue;
16224 // uintptr_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg);
16226 export function WatchedOutput_clone_ptr(arg: number): number {
16227 if(!isWasmInitialized) {
16228 throw new Error("initializeWasm() must be awaited first!");
16230 const nativeResponseValue = wasm.TS_WatchedOutput_clone_ptr(arg);
16231 return nativeResponseValue;
16233 // struct LDKWatchedOutput WatchedOutput_clone(const struct LDKWatchedOutput *NONNULL_PTR orig);
16235 export function WatchedOutput_clone(orig: number): number {
16236 if(!isWasmInitialized) {
16237 throw new Error("initializeWasm() must be awaited first!");
16239 const nativeResponseValue = wasm.TS_WatchedOutput_clone(orig);
16240 return nativeResponseValue;
16242 // uint64_t WatchedOutput_hash(const struct LDKWatchedOutput *NONNULL_PTR o);
16244 export function WatchedOutput_hash(o: number): bigint {
16245 if(!isWasmInitialized) {
16246 throw new Error("initializeWasm() must be awaited first!");
16248 const nativeResponseValue = wasm.TS_WatchedOutput_hash(o);
16249 return nativeResponseValue;
16251 // void BroadcasterInterface_free(struct LDKBroadcasterInterface this_ptr);
16253 export function BroadcasterInterface_free(this_ptr: number): void {
16254 if(!isWasmInitialized) {
16255 throw new Error("initializeWasm() must be awaited first!");
16257 const nativeResponseValue = wasm.TS_BroadcasterInterface_free(this_ptr);
16258 // debug statements here
16260 // enum LDKConfirmationTarget ConfirmationTarget_clone(const enum LDKConfirmationTarget *NONNULL_PTR orig);
16262 export function ConfirmationTarget_clone(orig: number): ConfirmationTarget {
16263 if(!isWasmInitialized) {
16264 throw new Error("initializeWasm() must be awaited first!");
16266 const nativeResponseValue = wasm.TS_ConfirmationTarget_clone(orig);
16267 return nativeResponseValue;
16269 // enum LDKConfirmationTarget ConfirmationTarget_background(void);
16271 export function ConfirmationTarget_background(): ConfirmationTarget {
16272 if(!isWasmInitialized) {
16273 throw new Error("initializeWasm() must be awaited first!");
16275 const nativeResponseValue = wasm.TS_ConfirmationTarget_background();
16276 return nativeResponseValue;
16278 // enum LDKConfirmationTarget ConfirmationTarget_normal(void);
16280 export function ConfirmationTarget_normal(): ConfirmationTarget {
16281 if(!isWasmInitialized) {
16282 throw new Error("initializeWasm() must be awaited first!");
16284 const nativeResponseValue = wasm.TS_ConfirmationTarget_normal();
16285 return nativeResponseValue;
16287 // enum LDKConfirmationTarget ConfirmationTarget_high_priority(void);
16289 export function ConfirmationTarget_high_priority(): ConfirmationTarget {
16290 if(!isWasmInitialized) {
16291 throw new Error("initializeWasm() must be awaited first!");
16293 const nativeResponseValue = wasm.TS_ConfirmationTarget_high_priority();
16294 return nativeResponseValue;
16296 // bool ConfirmationTarget_eq(const enum LDKConfirmationTarget *NONNULL_PTR a, const enum LDKConfirmationTarget *NONNULL_PTR b);
16298 export function ConfirmationTarget_eq(a: number, b: number): boolean {
16299 if(!isWasmInitialized) {
16300 throw new Error("initializeWasm() must be awaited first!");
16302 const nativeResponseValue = wasm.TS_ConfirmationTarget_eq(a, b);
16303 return nativeResponseValue;
16305 // void FeeEstimator_free(struct LDKFeeEstimator this_ptr);
16307 export function FeeEstimator_free(this_ptr: number): void {
16308 if(!isWasmInitialized) {
16309 throw new Error("initializeWasm() must be awaited first!");
16311 const nativeResponseValue = wasm.TS_FeeEstimator_free(this_ptr);
16312 // debug statements here
16314 // void MonitorUpdateId_free(struct LDKMonitorUpdateId this_obj);
16316 export function MonitorUpdateId_free(this_obj: number): void {
16317 if(!isWasmInitialized) {
16318 throw new Error("initializeWasm() must be awaited first!");
16320 const nativeResponseValue = wasm.TS_MonitorUpdateId_free(this_obj);
16321 // debug statements here
16323 // uintptr_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg);
16325 export function MonitorUpdateId_clone_ptr(arg: number): number {
16326 if(!isWasmInitialized) {
16327 throw new Error("initializeWasm() must be awaited first!");
16329 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone_ptr(arg);
16330 return nativeResponseValue;
16332 // struct LDKMonitorUpdateId MonitorUpdateId_clone(const struct LDKMonitorUpdateId *NONNULL_PTR orig);
16334 export function MonitorUpdateId_clone(orig: number): number {
16335 if(!isWasmInitialized) {
16336 throw new Error("initializeWasm() must be awaited first!");
16338 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone(orig);
16339 return nativeResponseValue;
16341 // uint64_t MonitorUpdateId_hash(const struct LDKMonitorUpdateId *NONNULL_PTR o);
16343 export function MonitorUpdateId_hash(o: number): bigint {
16344 if(!isWasmInitialized) {
16345 throw new Error("initializeWasm() must be awaited first!");
16347 const nativeResponseValue = wasm.TS_MonitorUpdateId_hash(o);
16348 return nativeResponseValue;
16350 // bool MonitorUpdateId_eq(const struct LDKMonitorUpdateId *NONNULL_PTR a, const struct LDKMonitorUpdateId *NONNULL_PTR b);
16352 export function MonitorUpdateId_eq(a: number, b: number): boolean {
16353 if(!isWasmInitialized) {
16354 throw new Error("initializeWasm() must be awaited first!");
16356 const nativeResponseValue = wasm.TS_MonitorUpdateId_eq(a, b);
16357 return nativeResponseValue;
16359 // void Persist_free(struct LDKPersist this_ptr);
16361 export function Persist_free(this_ptr: number): void {
16362 if(!isWasmInitialized) {
16363 throw new Error("initializeWasm() must be awaited first!");
16365 const nativeResponseValue = wasm.TS_Persist_free(this_ptr);
16366 // debug statements here
16368 // void LockedChannelMonitor_free(struct LDKLockedChannelMonitor this_obj);
16370 export function LockedChannelMonitor_free(this_obj: number): void {
16371 if(!isWasmInitialized) {
16372 throw new Error("initializeWasm() must be awaited first!");
16374 const nativeResponseValue = wasm.TS_LockedChannelMonitor_free(this_obj);
16375 // debug statements here
16377 // void ChainMonitor_free(struct LDKChainMonitor this_obj);
16379 export function ChainMonitor_free(this_obj: number): void {
16380 if(!isWasmInitialized) {
16381 throw new Error("initializeWasm() must be awaited first!");
16383 const nativeResponseValue = wasm.TS_ChainMonitor_free(this_obj);
16384 // debug statements here
16386 // MUST_USE_RES struct LDKChainMonitor ChainMonitor_new(struct LDKCOption_FilterZ chain_source, struct LDKBroadcasterInterface broadcaster, struct LDKLogger logger, struct LDKFeeEstimator feeest, struct LDKPersist persister);
16388 export function ChainMonitor_new(chain_source: number, broadcaster: number, logger: number, feeest: number, persister: number): number {
16389 if(!isWasmInitialized) {
16390 throw new Error("initializeWasm() must be awaited first!");
16392 const nativeResponseValue = wasm.TS_ChainMonitor_new(chain_source, broadcaster, logger, feeest, persister);
16393 return nativeResponseValue;
16395 // MUST_USE_RES struct LDKCVec_BalanceZ ChainMonitor_get_claimable_balances(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKCVec_ChannelDetailsZ ignored_channels);
16397 export function ChainMonitor_get_claimable_balances(this_arg: number, ignored_channels: number): number {
16398 if(!isWasmInitialized) {
16399 throw new Error("initializeWasm() must be awaited first!");
16401 const nativeResponseValue = wasm.TS_ChainMonitor_get_claimable_balances(this_arg, ignored_channels);
16402 return nativeResponseValue;
16404 // MUST_USE_RES struct LDKCResult_LockedChannelMonitorNoneZ ChainMonitor_get_monitor(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo);
16406 export function ChainMonitor_get_monitor(this_arg: number, funding_txo: number): number {
16407 if(!isWasmInitialized) {
16408 throw new Error("initializeWasm() must be awaited first!");
16410 const nativeResponseValue = wasm.TS_ChainMonitor_get_monitor(this_arg, funding_txo);
16411 return nativeResponseValue;
16413 // MUST_USE_RES struct LDKCVec_OutPointZ ChainMonitor_list_monitors(const struct LDKChainMonitor *NONNULL_PTR this_arg);
16415 export function ChainMonitor_list_monitors(this_arg: number): number {
16416 if(!isWasmInitialized) {
16417 throw new Error("initializeWasm() must be awaited first!");
16419 const nativeResponseValue = wasm.TS_ChainMonitor_list_monitors(this_arg);
16420 return nativeResponseValue;
16422 // 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);
16424 export function ChainMonitor_channel_monitor_updated(this_arg: number, funding_txo: number, completed_update_id: number): number {
16425 if(!isWasmInitialized) {
16426 throw new Error("initializeWasm() must be awaited first!");
16428 const nativeResponseValue = wasm.TS_ChainMonitor_channel_monitor_updated(this_arg, funding_txo, completed_update_id);
16429 return nativeResponseValue;
16431 // struct LDKListen ChainMonitor_as_Listen(const struct LDKChainMonitor *NONNULL_PTR this_arg);
16433 export function ChainMonitor_as_Listen(this_arg: number): number {
16434 if(!isWasmInitialized) {
16435 throw new Error("initializeWasm() must be awaited first!");
16437 const nativeResponseValue = wasm.TS_ChainMonitor_as_Listen(this_arg);
16438 return nativeResponseValue;
16440 // struct LDKConfirm ChainMonitor_as_Confirm(const struct LDKChainMonitor *NONNULL_PTR this_arg);
16442 export function ChainMonitor_as_Confirm(this_arg: number): number {
16443 if(!isWasmInitialized) {
16444 throw new Error("initializeWasm() must be awaited first!");
16446 const nativeResponseValue = wasm.TS_ChainMonitor_as_Confirm(this_arg);
16447 return nativeResponseValue;
16449 // struct LDKWatch ChainMonitor_as_Watch(const struct LDKChainMonitor *NONNULL_PTR this_arg);
16451 export function ChainMonitor_as_Watch(this_arg: number): number {
16452 if(!isWasmInitialized) {
16453 throw new Error("initializeWasm() must be awaited first!");
16455 const nativeResponseValue = wasm.TS_ChainMonitor_as_Watch(this_arg);
16456 return nativeResponseValue;
16458 // struct LDKEventsProvider ChainMonitor_as_EventsProvider(const struct LDKChainMonitor *NONNULL_PTR this_arg);
16460 export function ChainMonitor_as_EventsProvider(this_arg: number): number {
16461 if(!isWasmInitialized) {
16462 throw new Error("initializeWasm() must be awaited first!");
16464 const nativeResponseValue = wasm.TS_ChainMonitor_as_EventsProvider(this_arg);
16465 return nativeResponseValue;
16467 // void ChannelMonitorUpdate_free(struct LDKChannelMonitorUpdate this_obj);
16469 export function ChannelMonitorUpdate_free(this_obj: number): void {
16470 if(!isWasmInitialized) {
16471 throw new Error("initializeWasm() must be awaited first!");
16473 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_free(this_obj);
16474 // debug statements here
16476 // uint64_t ChannelMonitorUpdate_get_update_id(const struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr);
16478 export function ChannelMonitorUpdate_get_update_id(this_ptr: number): bigint {
16479 if(!isWasmInitialized) {
16480 throw new Error("initializeWasm() must be awaited first!");
16482 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_get_update_id(this_ptr);
16483 return nativeResponseValue;
16485 // void ChannelMonitorUpdate_set_update_id(struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr, uint64_t val);
16487 export function ChannelMonitorUpdate_set_update_id(this_ptr: number, val: bigint): void {
16488 if(!isWasmInitialized) {
16489 throw new Error("initializeWasm() must be awaited first!");
16491 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_set_update_id(this_ptr, val);
16492 // debug statements here
16494 // uintptr_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg);
16496 export function ChannelMonitorUpdate_clone_ptr(arg: number): number {
16497 if(!isWasmInitialized) {
16498 throw new Error("initializeWasm() must be awaited first!");
16500 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone_ptr(arg);
16501 return nativeResponseValue;
16503 // struct LDKChannelMonitorUpdate ChannelMonitorUpdate_clone(const struct LDKChannelMonitorUpdate *NONNULL_PTR orig);
16505 export function ChannelMonitorUpdate_clone(orig: number): number {
16506 if(!isWasmInitialized) {
16507 throw new Error("initializeWasm() must be awaited first!");
16509 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone(orig);
16510 return nativeResponseValue;
16512 // struct LDKCVec_u8Z ChannelMonitorUpdate_write(const struct LDKChannelMonitorUpdate *NONNULL_PTR obj);
16514 export function ChannelMonitorUpdate_write(obj: number): number {
16515 if(!isWasmInitialized) {
16516 throw new Error("initializeWasm() must be awaited first!");
16518 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_write(obj);
16519 return nativeResponseValue;
16521 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ ChannelMonitorUpdate_read(struct LDKu8slice ser);
16523 export function ChannelMonitorUpdate_read(ser: number): number {
16524 if(!isWasmInitialized) {
16525 throw new Error("initializeWasm() must be awaited first!");
16527 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_read(ser);
16528 return nativeResponseValue;
16530 // void MonitorEvent_free(struct LDKMonitorEvent this_ptr);
16532 export function MonitorEvent_free(this_ptr: number): void {
16533 if(!isWasmInitialized) {
16534 throw new Error("initializeWasm() must be awaited first!");
16536 const nativeResponseValue = wasm.TS_MonitorEvent_free(this_ptr);
16537 // debug statements here
16539 // uintptr_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg);
16541 export function MonitorEvent_clone_ptr(arg: number): number {
16542 if(!isWasmInitialized) {
16543 throw new Error("initializeWasm() must be awaited first!");
16545 const nativeResponseValue = wasm.TS_MonitorEvent_clone_ptr(arg);
16546 return nativeResponseValue;
16548 // struct LDKMonitorEvent MonitorEvent_clone(const struct LDKMonitorEvent *NONNULL_PTR orig);
16550 export function MonitorEvent_clone(orig: number): number {
16551 if(!isWasmInitialized) {
16552 throw new Error("initializeWasm() must be awaited first!");
16554 const nativeResponseValue = wasm.TS_MonitorEvent_clone(orig);
16555 return nativeResponseValue;
16557 // struct LDKMonitorEvent MonitorEvent_htlcevent(struct LDKHTLCUpdate a);
16559 export function MonitorEvent_htlcevent(a: number): number {
16560 if(!isWasmInitialized) {
16561 throw new Error("initializeWasm() must be awaited first!");
16563 const nativeResponseValue = wasm.TS_MonitorEvent_htlcevent(a);
16564 return nativeResponseValue;
16566 // struct LDKMonitorEvent MonitorEvent_commitment_tx_confirmed(struct LDKOutPoint a);
16568 export function MonitorEvent_commitment_tx_confirmed(a: number): number {
16569 if(!isWasmInitialized) {
16570 throw new Error("initializeWasm() must be awaited first!");
16572 const nativeResponseValue = wasm.TS_MonitorEvent_commitment_tx_confirmed(a);
16573 return nativeResponseValue;
16575 // struct LDKMonitorEvent MonitorEvent_update_completed(struct LDKOutPoint funding_txo, uint64_t monitor_update_id);
16577 export function MonitorEvent_update_completed(funding_txo: number, monitor_update_id: bigint): number {
16578 if(!isWasmInitialized) {
16579 throw new Error("initializeWasm() must be awaited first!");
16581 const nativeResponseValue = wasm.TS_MonitorEvent_update_completed(funding_txo, monitor_update_id);
16582 return nativeResponseValue;
16584 // struct LDKMonitorEvent MonitorEvent_update_failed(struct LDKOutPoint a);
16586 export function MonitorEvent_update_failed(a: number): number {
16587 if(!isWasmInitialized) {
16588 throw new Error("initializeWasm() must be awaited first!");
16590 const nativeResponseValue = wasm.TS_MonitorEvent_update_failed(a);
16591 return nativeResponseValue;
16593 // struct LDKCVec_u8Z MonitorEvent_write(const struct LDKMonitorEvent *NONNULL_PTR obj);
16595 export function MonitorEvent_write(obj: number): number {
16596 if(!isWasmInitialized) {
16597 throw new Error("initializeWasm() must be awaited first!");
16599 const nativeResponseValue = wasm.TS_MonitorEvent_write(obj);
16600 return nativeResponseValue;
16602 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ MonitorEvent_read(struct LDKu8slice ser);
16604 export function MonitorEvent_read(ser: number): number {
16605 if(!isWasmInitialized) {
16606 throw new Error("initializeWasm() must be awaited first!");
16608 const nativeResponseValue = wasm.TS_MonitorEvent_read(ser);
16609 return nativeResponseValue;
16611 // void HTLCUpdate_free(struct LDKHTLCUpdate this_obj);
16613 export function HTLCUpdate_free(this_obj: number): void {
16614 if(!isWasmInitialized) {
16615 throw new Error("initializeWasm() must be awaited first!");
16617 const nativeResponseValue = wasm.TS_HTLCUpdate_free(this_obj);
16618 // debug statements here
16620 // uintptr_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg);
16622 export function HTLCUpdate_clone_ptr(arg: number): number {
16623 if(!isWasmInitialized) {
16624 throw new Error("initializeWasm() must be awaited first!");
16626 const nativeResponseValue = wasm.TS_HTLCUpdate_clone_ptr(arg);
16627 return nativeResponseValue;
16629 // struct LDKHTLCUpdate HTLCUpdate_clone(const struct LDKHTLCUpdate *NONNULL_PTR orig);
16631 export function HTLCUpdate_clone(orig: number): number {
16632 if(!isWasmInitialized) {
16633 throw new Error("initializeWasm() must be awaited first!");
16635 const nativeResponseValue = wasm.TS_HTLCUpdate_clone(orig);
16636 return nativeResponseValue;
16638 // struct LDKCVec_u8Z HTLCUpdate_write(const struct LDKHTLCUpdate *NONNULL_PTR obj);
16640 export function HTLCUpdate_write(obj: number): number {
16641 if(!isWasmInitialized) {
16642 throw new Error("initializeWasm() must be awaited first!");
16644 const nativeResponseValue = wasm.TS_HTLCUpdate_write(obj);
16645 return nativeResponseValue;
16647 // struct LDKCResult_HTLCUpdateDecodeErrorZ HTLCUpdate_read(struct LDKu8slice ser);
16649 export function HTLCUpdate_read(ser: number): number {
16650 if(!isWasmInitialized) {
16651 throw new Error("initializeWasm() must be awaited first!");
16653 const nativeResponseValue = wasm.TS_HTLCUpdate_read(ser);
16654 return nativeResponseValue;
16656 // void Balance_free(struct LDKBalance this_ptr);
16658 export function Balance_free(this_ptr: number): void {
16659 if(!isWasmInitialized) {
16660 throw new Error("initializeWasm() must be awaited first!");
16662 const nativeResponseValue = wasm.TS_Balance_free(this_ptr);
16663 // debug statements here
16665 // uintptr_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg);
16667 export function Balance_clone_ptr(arg: number): number {
16668 if(!isWasmInitialized) {
16669 throw new Error("initializeWasm() must be awaited first!");
16671 const nativeResponseValue = wasm.TS_Balance_clone_ptr(arg);
16672 return nativeResponseValue;
16674 // struct LDKBalance Balance_clone(const struct LDKBalance *NONNULL_PTR orig);
16676 export function Balance_clone(orig: number): number {
16677 if(!isWasmInitialized) {
16678 throw new Error("initializeWasm() must be awaited first!");
16680 const nativeResponseValue = wasm.TS_Balance_clone(orig);
16681 return nativeResponseValue;
16683 // struct LDKBalance Balance_claimable_on_channel_close(uint64_t claimable_amount_satoshis);
16685 export function Balance_claimable_on_channel_close(claimable_amount_satoshis: bigint): number {
16686 if(!isWasmInitialized) {
16687 throw new Error("initializeWasm() must be awaited first!");
16689 const nativeResponseValue = wasm.TS_Balance_claimable_on_channel_close(claimable_amount_satoshis);
16690 return nativeResponseValue;
16692 // struct LDKBalance Balance_claimable_awaiting_confirmations(uint64_t claimable_amount_satoshis, uint32_t confirmation_height);
16694 export function Balance_claimable_awaiting_confirmations(claimable_amount_satoshis: bigint, confirmation_height: number): number {
16695 if(!isWasmInitialized) {
16696 throw new Error("initializeWasm() must be awaited first!");
16698 const nativeResponseValue = wasm.TS_Balance_claimable_awaiting_confirmations(claimable_amount_satoshis, confirmation_height);
16699 return nativeResponseValue;
16701 // struct LDKBalance Balance_contentious_claimable(uint64_t claimable_amount_satoshis, uint32_t timeout_height);
16703 export function Balance_contentious_claimable(claimable_amount_satoshis: bigint, timeout_height: number): number {
16704 if(!isWasmInitialized) {
16705 throw new Error("initializeWasm() must be awaited first!");
16707 const nativeResponseValue = wasm.TS_Balance_contentious_claimable(claimable_amount_satoshis, timeout_height);
16708 return nativeResponseValue;
16710 // struct LDKBalance Balance_maybe_claimable_htlcawaiting_timeout(uint64_t claimable_amount_satoshis, uint32_t claimable_height);
16712 export function Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis: bigint, claimable_height: number): number {
16713 if(!isWasmInitialized) {
16714 throw new Error("initializeWasm() must be awaited first!");
16716 const nativeResponseValue = wasm.TS_Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis, claimable_height);
16717 return nativeResponseValue;
16719 // bool Balance_eq(const struct LDKBalance *NONNULL_PTR a, const struct LDKBalance *NONNULL_PTR b);
16721 export function Balance_eq(a: number, b: number): boolean {
16722 if(!isWasmInitialized) {
16723 throw new Error("initializeWasm() must be awaited first!");
16725 const nativeResponseValue = wasm.TS_Balance_eq(a, b);
16726 return nativeResponseValue;
16728 // void ChannelMonitor_free(struct LDKChannelMonitor this_obj);
16730 export function ChannelMonitor_free(this_obj: number): void {
16731 if(!isWasmInitialized) {
16732 throw new Error("initializeWasm() must be awaited first!");
16734 const nativeResponseValue = wasm.TS_ChannelMonitor_free(this_obj);
16735 // debug statements here
16737 // uintptr_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg);
16739 export function ChannelMonitor_clone_ptr(arg: number): number {
16740 if(!isWasmInitialized) {
16741 throw new Error("initializeWasm() must be awaited first!");
16743 const nativeResponseValue = wasm.TS_ChannelMonitor_clone_ptr(arg);
16744 return nativeResponseValue;
16746 // struct LDKChannelMonitor ChannelMonitor_clone(const struct LDKChannelMonitor *NONNULL_PTR orig);
16748 export function ChannelMonitor_clone(orig: number): number {
16749 if(!isWasmInitialized) {
16750 throw new Error("initializeWasm() must be awaited first!");
16752 const nativeResponseValue = wasm.TS_ChannelMonitor_clone(orig);
16753 return nativeResponseValue;
16755 // struct LDKCVec_u8Z ChannelMonitor_write(const struct LDKChannelMonitor *NONNULL_PTR obj);
16757 export function ChannelMonitor_write(obj: number): number {
16758 if(!isWasmInitialized) {
16759 throw new Error("initializeWasm() must be awaited first!");
16761 const nativeResponseValue = wasm.TS_ChannelMonitor_write(obj);
16762 return nativeResponseValue;
16764 // 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);
16766 export function ChannelMonitor_update_monitor(this_arg: number, updates: number, broadcaster: number, fee_estimator: number, logger: number): number {
16767 if(!isWasmInitialized) {
16768 throw new Error("initializeWasm() must be awaited first!");
16770 const nativeResponseValue = wasm.TS_ChannelMonitor_update_monitor(this_arg, updates, broadcaster, fee_estimator, logger);
16771 return nativeResponseValue;
16773 // MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
16775 export function ChannelMonitor_get_latest_update_id(this_arg: number): bigint {
16776 if(!isWasmInitialized) {
16777 throw new Error("initializeWasm() must be awaited first!");
16779 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_update_id(this_arg);
16780 return nativeResponseValue;
16782 // MUST_USE_RES struct LDKC2Tuple_OutPointScriptZ ChannelMonitor_get_funding_txo(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
16784 export function ChannelMonitor_get_funding_txo(this_arg: number): number {
16785 if(!isWasmInitialized) {
16786 throw new Error("initializeWasm() must be awaited first!");
16788 const nativeResponseValue = wasm.TS_ChannelMonitor_get_funding_txo(this_arg);
16789 return nativeResponseValue;
16791 // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ChannelMonitor_get_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
16793 export function ChannelMonitor_get_outputs_to_watch(this_arg: number): number {
16794 if(!isWasmInitialized) {
16795 throw new Error("initializeWasm() must be awaited first!");
16797 const nativeResponseValue = wasm.TS_ChannelMonitor_get_outputs_to_watch(this_arg);
16798 return nativeResponseValue;
16800 // void ChannelMonitor_load_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKFilter *NONNULL_PTR filter);
16802 export function ChannelMonitor_load_outputs_to_watch(this_arg: number, filter: number): void {
16803 if(!isWasmInitialized) {
16804 throw new Error("initializeWasm() must be awaited first!");
16806 const nativeResponseValue = wasm.TS_ChannelMonitor_load_outputs_to_watch(this_arg, filter);
16807 // debug statements here
16809 // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
16811 export function ChannelMonitor_get_and_clear_pending_monitor_events(this_arg: number): number {
16812 if(!isWasmInitialized) {
16813 throw new Error("initializeWasm() must be awaited first!");
16815 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_monitor_events(this_arg);
16816 return nativeResponseValue;
16818 // MUST_USE_RES struct LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
16820 export function ChannelMonitor_get_and_clear_pending_events(this_arg: number): number {
16821 if(!isWasmInitialized) {
16822 throw new Error("initializeWasm() must be awaited first!");
16824 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_events(this_arg);
16825 return nativeResponseValue;
16827 // 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);
16829 export function ChannelMonitor_get_latest_holder_commitment_txn(this_arg: number, logger: number): number {
16830 if(!isWasmInitialized) {
16831 throw new Error("initializeWasm() must be awaited first!");
16833 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_holder_commitment_txn(this_arg, logger);
16834 return nativeResponseValue;
16836 // 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);
16838 export function ChannelMonitor_block_connected(this_arg: number, header: number, txdata: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
16839 if(!isWasmInitialized) {
16840 throw new Error("initializeWasm() must be awaited first!");
16842 const nativeResponseValue = wasm.TS_ChannelMonitor_block_connected(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
16843 return nativeResponseValue;
16845 // 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);
16847 export function ChannelMonitor_block_disconnected(this_arg: number, header: number, height: number, broadcaster: number, fee_estimator: number, logger: number): void {
16848 if(!isWasmInitialized) {
16849 throw new Error("initializeWasm() must be awaited first!");
16851 const nativeResponseValue = wasm.TS_ChannelMonitor_block_disconnected(this_arg, header, height, broadcaster, fee_estimator, logger);
16852 // debug statements here
16854 // 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);
16856 export function ChannelMonitor_transactions_confirmed(this_arg: number, header: number, txdata: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
16857 if(!isWasmInitialized) {
16858 throw new Error("initializeWasm() must be awaited first!");
16860 const nativeResponseValue = wasm.TS_ChannelMonitor_transactions_confirmed(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
16861 return nativeResponseValue;
16863 // 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);
16865 export function ChannelMonitor_transaction_unconfirmed(this_arg: number, txid: number, broadcaster: number, fee_estimator: number, logger: number): void {
16866 if(!isWasmInitialized) {
16867 throw new Error("initializeWasm() must be awaited first!");
16869 const nativeResponseValue = wasm.TS_ChannelMonitor_transaction_unconfirmed(this_arg, txid, broadcaster, fee_estimator, logger);
16870 // debug statements here
16872 // 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);
16874 export function ChannelMonitor_best_block_updated(this_arg: number, header: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
16875 if(!isWasmInitialized) {
16876 throw new Error("initializeWasm() must be awaited first!");
16878 const nativeResponseValue = wasm.TS_ChannelMonitor_best_block_updated(this_arg, header, height, broadcaster, fee_estimator, logger);
16879 return nativeResponseValue;
16881 // MUST_USE_RES struct LDKCVec_TxidZ ChannelMonitor_get_relevant_txids(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
16883 export function ChannelMonitor_get_relevant_txids(this_arg: number): number {
16884 if(!isWasmInitialized) {
16885 throw new Error("initializeWasm() must be awaited first!");
16887 const nativeResponseValue = wasm.TS_ChannelMonitor_get_relevant_txids(this_arg);
16888 return nativeResponseValue;
16890 // MUST_USE_RES struct LDKBestBlock ChannelMonitor_current_best_block(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
16892 export function ChannelMonitor_current_best_block(this_arg: number): number {
16893 if(!isWasmInitialized) {
16894 throw new Error("initializeWasm() must be awaited first!");
16896 const nativeResponseValue = wasm.TS_ChannelMonitor_current_best_block(this_arg);
16897 return nativeResponseValue;
16899 // MUST_USE_RES struct LDKCVec_BalanceZ ChannelMonitor_get_claimable_balances(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
16901 export function ChannelMonitor_get_claimable_balances(this_arg: number): number {
16902 if(!isWasmInitialized) {
16903 throw new Error("initializeWasm() must be awaited first!");
16905 const nativeResponseValue = wasm.TS_ChannelMonitor_get_claimable_balances(this_arg);
16906 return nativeResponseValue;
16908 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ C2Tuple_BlockHashChannelMonitorZ_read(struct LDKu8slice ser, const struct LDKKeysInterface *NONNULL_PTR arg);
16910 export function C2Tuple_BlockHashChannelMonitorZ_read(ser: number, arg: number): number {
16911 if(!isWasmInitialized) {
16912 throw new Error("initializeWasm() must be awaited first!");
16914 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_read(ser, arg);
16915 return nativeResponseValue;
16917 // void OutPoint_free(struct LDKOutPoint this_obj);
16919 export function OutPoint_free(this_obj: number): void {
16920 if(!isWasmInitialized) {
16921 throw new Error("initializeWasm() must be awaited first!");
16923 const nativeResponseValue = wasm.TS_OutPoint_free(this_obj);
16924 // debug statements here
16926 // const uint8_t (*OutPoint_get_txid(const struct LDKOutPoint *NONNULL_PTR this_ptr))[32];
16928 export function OutPoint_get_txid(this_ptr: number): number {
16929 if(!isWasmInitialized) {
16930 throw new Error("initializeWasm() must be awaited first!");
16932 const nativeResponseValue = wasm.TS_OutPoint_get_txid(this_ptr);
16933 return nativeResponseValue;
16935 // void OutPoint_set_txid(struct LDKOutPoint *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
16937 export function OutPoint_set_txid(this_ptr: number, val: number): void {
16938 if(!isWasmInitialized) {
16939 throw new Error("initializeWasm() must be awaited first!");
16941 const nativeResponseValue = wasm.TS_OutPoint_set_txid(this_ptr, val);
16942 // debug statements here
16944 // uint16_t OutPoint_get_index(const struct LDKOutPoint *NONNULL_PTR this_ptr);
16946 export function OutPoint_get_index(this_ptr: number): number {
16947 if(!isWasmInitialized) {
16948 throw new Error("initializeWasm() must be awaited first!");
16950 const nativeResponseValue = wasm.TS_OutPoint_get_index(this_ptr);
16951 return nativeResponseValue;
16953 // void OutPoint_set_index(struct LDKOutPoint *NONNULL_PTR this_ptr, uint16_t val);
16955 export function OutPoint_set_index(this_ptr: number, val: number): void {
16956 if(!isWasmInitialized) {
16957 throw new Error("initializeWasm() must be awaited first!");
16959 const nativeResponseValue = wasm.TS_OutPoint_set_index(this_ptr, val);
16960 // debug statements here
16962 // MUST_USE_RES struct LDKOutPoint OutPoint_new(struct LDKThirtyTwoBytes txid_arg, uint16_t index_arg);
16964 export function OutPoint_new(txid_arg: number, index_arg: number): number {
16965 if(!isWasmInitialized) {
16966 throw new Error("initializeWasm() must be awaited first!");
16968 const nativeResponseValue = wasm.TS_OutPoint_new(txid_arg, index_arg);
16969 return nativeResponseValue;
16971 // uintptr_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg);
16973 export function OutPoint_clone_ptr(arg: number): number {
16974 if(!isWasmInitialized) {
16975 throw new Error("initializeWasm() must be awaited first!");
16977 const nativeResponseValue = wasm.TS_OutPoint_clone_ptr(arg);
16978 return nativeResponseValue;
16980 // struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig);
16982 export function OutPoint_clone(orig: number): number {
16983 if(!isWasmInitialized) {
16984 throw new Error("initializeWasm() must be awaited first!");
16986 const nativeResponseValue = wasm.TS_OutPoint_clone(orig);
16987 return nativeResponseValue;
16989 // bool OutPoint_eq(const struct LDKOutPoint *NONNULL_PTR a, const struct LDKOutPoint *NONNULL_PTR b);
16991 export function OutPoint_eq(a: number, b: number): boolean {
16992 if(!isWasmInitialized) {
16993 throw new Error("initializeWasm() must be awaited first!");
16995 const nativeResponseValue = wasm.TS_OutPoint_eq(a, b);
16996 return nativeResponseValue;
16998 // uint64_t OutPoint_hash(const struct LDKOutPoint *NONNULL_PTR o);
17000 export function OutPoint_hash(o: number): bigint {
17001 if(!isWasmInitialized) {
17002 throw new Error("initializeWasm() must be awaited first!");
17004 const nativeResponseValue = wasm.TS_OutPoint_hash(o);
17005 return nativeResponseValue;
17007 // MUST_USE_RES struct LDKThirtyTwoBytes OutPoint_to_channel_id(const struct LDKOutPoint *NONNULL_PTR this_arg);
17009 export function OutPoint_to_channel_id(this_arg: number): number {
17010 if(!isWasmInitialized) {
17011 throw new Error("initializeWasm() must be awaited first!");
17013 const nativeResponseValue = wasm.TS_OutPoint_to_channel_id(this_arg);
17014 return nativeResponseValue;
17016 // struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj);
17018 export function OutPoint_write(obj: number): number {
17019 if(!isWasmInitialized) {
17020 throw new Error("initializeWasm() must be awaited first!");
17022 const nativeResponseValue = wasm.TS_OutPoint_write(obj);
17023 return nativeResponseValue;
17025 // struct LDKCResult_OutPointDecodeErrorZ OutPoint_read(struct LDKu8slice ser);
17027 export function OutPoint_read(ser: number): number {
17028 if(!isWasmInitialized) {
17029 throw new Error("initializeWasm() must be awaited first!");
17031 const nativeResponseValue = wasm.TS_OutPoint_read(ser);
17032 return nativeResponseValue;
17034 // void DelayedPaymentOutputDescriptor_free(struct LDKDelayedPaymentOutputDescriptor this_obj);
17036 export function DelayedPaymentOutputDescriptor_free(this_obj: number): void {
17037 if(!isWasmInitialized) {
17038 throw new Error("initializeWasm() must be awaited first!");
17040 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_free(this_obj);
17041 // debug statements here
17043 // struct LDKOutPoint DelayedPaymentOutputDescriptor_get_outpoint(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17045 export function DelayedPaymentOutputDescriptor_get_outpoint(this_ptr: number): number {
17046 if(!isWasmInitialized) {
17047 throw new Error("initializeWasm() must be awaited first!");
17049 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_outpoint(this_ptr);
17050 return nativeResponseValue;
17052 // void DelayedPaymentOutputDescriptor_set_outpoint(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
17054 export function DelayedPaymentOutputDescriptor_set_outpoint(this_ptr: number, val: number): void {
17055 if(!isWasmInitialized) {
17056 throw new Error("initializeWasm() must be awaited first!");
17058 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_outpoint(this_ptr, val);
17059 // debug statements here
17061 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_per_commitment_point(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17063 export function DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr: number): number {
17064 if(!isWasmInitialized) {
17065 throw new Error("initializeWasm() must be awaited first!");
17067 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr);
17068 return nativeResponseValue;
17070 // void DelayedPaymentOutputDescriptor_set_per_commitment_point(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17072 export function DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr: number, val: number): void {
17073 if(!isWasmInitialized) {
17074 throw new Error("initializeWasm() must be awaited first!");
17076 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr, val);
17077 // debug statements here
17079 // uint16_t DelayedPaymentOutputDescriptor_get_to_self_delay(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17081 export function DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr: number): number {
17082 if(!isWasmInitialized) {
17083 throw new Error("initializeWasm() must be awaited first!");
17085 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr);
17086 return nativeResponseValue;
17088 // void DelayedPaymentOutputDescriptor_set_to_self_delay(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint16_t val);
17090 export function DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr: number, val: number): void {
17091 if(!isWasmInitialized) {
17092 throw new Error("initializeWasm() must be awaited first!");
17094 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr, val);
17095 // debug statements here
17097 // void DelayedPaymentOutputDescriptor_set_output(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
17099 export function DelayedPaymentOutputDescriptor_set_output(this_ptr: number, val: number): void {
17100 if(!isWasmInitialized) {
17101 throw new Error("initializeWasm() must be awaited first!");
17103 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_output(this_ptr, val);
17104 // debug statements here
17106 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_revocation_pubkey(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17108 export function DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr: number): number {
17109 if(!isWasmInitialized) {
17110 throw new Error("initializeWasm() must be awaited first!");
17112 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr);
17113 return nativeResponseValue;
17115 // void DelayedPaymentOutputDescriptor_set_revocation_pubkey(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17117 export function DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr: number, val: number): void {
17118 if(!isWasmInitialized) {
17119 throw new Error("initializeWasm() must be awaited first!");
17121 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr, val);
17122 // debug statements here
17124 // const uint8_t (*DelayedPaymentOutputDescriptor_get_channel_keys_id(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
17126 export function DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr: number): number {
17127 if(!isWasmInitialized) {
17128 throw new Error("initializeWasm() must be awaited first!");
17130 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
17131 return nativeResponseValue;
17133 // void DelayedPaymentOutputDescriptor_set_channel_keys_id(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17135 export function DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr: number, val: number): void {
17136 if(!isWasmInitialized) {
17137 throw new Error("initializeWasm() must be awaited first!");
17139 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
17140 // debug statements here
17142 // uint64_t DelayedPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17144 export function DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: number): bigint {
17145 if(!isWasmInitialized) {
17146 throw new Error("initializeWasm() must be awaited first!");
17148 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
17149 return nativeResponseValue;
17151 // void DelayedPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
17153 export function DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
17154 if(!isWasmInitialized) {
17155 throw new Error("initializeWasm() must be awaited first!");
17157 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
17158 // debug statements here
17160 // 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);
17162 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 {
17163 if(!isWasmInitialized) {
17164 throw new Error("initializeWasm() must be awaited first!");
17166 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);
17167 return nativeResponseValue;
17169 // uintptr_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg);
17171 export function DelayedPaymentOutputDescriptor_clone_ptr(arg: number): number {
17172 if(!isWasmInitialized) {
17173 throw new Error("initializeWasm() must be awaited first!");
17175 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone_ptr(arg);
17176 return nativeResponseValue;
17178 // struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_clone(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR orig);
17180 export function DelayedPaymentOutputDescriptor_clone(orig: number): number {
17181 if(!isWasmInitialized) {
17182 throw new Error("initializeWasm() must be awaited first!");
17184 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone(orig);
17185 return nativeResponseValue;
17187 // struct LDKCVec_u8Z DelayedPaymentOutputDescriptor_write(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR obj);
17189 export function DelayedPaymentOutputDescriptor_write(obj: number): number {
17190 if(!isWasmInitialized) {
17191 throw new Error("initializeWasm() must be awaited first!");
17193 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_write(obj);
17194 return nativeResponseValue;
17196 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ DelayedPaymentOutputDescriptor_read(struct LDKu8slice ser);
17198 export function DelayedPaymentOutputDescriptor_read(ser: number): number {
17199 if(!isWasmInitialized) {
17200 throw new Error("initializeWasm() must be awaited first!");
17202 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_read(ser);
17203 return nativeResponseValue;
17205 // void StaticPaymentOutputDescriptor_free(struct LDKStaticPaymentOutputDescriptor this_obj);
17207 export function StaticPaymentOutputDescriptor_free(this_obj: number): void {
17208 if(!isWasmInitialized) {
17209 throw new Error("initializeWasm() must be awaited first!");
17211 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_free(this_obj);
17212 // debug statements here
17214 // struct LDKOutPoint StaticPaymentOutputDescriptor_get_outpoint(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17216 export function StaticPaymentOutputDescriptor_get_outpoint(this_ptr: number): number {
17217 if(!isWasmInitialized) {
17218 throw new Error("initializeWasm() must be awaited first!");
17220 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_outpoint(this_ptr);
17221 return nativeResponseValue;
17223 // void StaticPaymentOutputDescriptor_set_outpoint(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
17225 export function StaticPaymentOutputDescriptor_set_outpoint(this_ptr: number, val: number): void {
17226 if(!isWasmInitialized) {
17227 throw new Error("initializeWasm() must be awaited first!");
17229 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_outpoint(this_ptr, val);
17230 // debug statements here
17232 // void StaticPaymentOutputDescriptor_set_output(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
17234 export function StaticPaymentOutputDescriptor_set_output(this_ptr: number, val: number): void {
17235 if(!isWasmInitialized) {
17236 throw new Error("initializeWasm() must be awaited first!");
17238 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_output(this_ptr, val);
17239 // debug statements here
17241 // const uint8_t (*StaticPaymentOutputDescriptor_get_channel_keys_id(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
17243 export function StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr: number): number {
17244 if(!isWasmInitialized) {
17245 throw new Error("initializeWasm() must be awaited first!");
17247 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
17248 return nativeResponseValue;
17250 // void StaticPaymentOutputDescriptor_set_channel_keys_id(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17252 export function StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr: number, val: number): void {
17253 if(!isWasmInitialized) {
17254 throw new Error("initializeWasm() must be awaited first!");
17256 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
17257 // debug statements here
17259 // uint64_t StaticPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17261 export function StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: number): bigint {
17262 if(!isWasmInitialized) {
17263 throw new Error("initializeWasm() must be awaited first!");
17265 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
17266 return nativeResponseValue;
17268 // void StaticPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
17270 export function StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
17271 if(!isWasmInitialized) {
17272 throw new Error("initializeWasm() must be awaited first!");
17274 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
17275 // debug statements here
17277 // 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);
17279 export function StaticPaymentOutputDescriptor_new(outpoint_arg: number, output_arg: number, channel_keys_id_arg: number, channel_value_satoshis_arg: bigint): number {
17280 if(!isWasmInitialized) {
17281 throw new Error("initializeWasm() must be awaited first!");
17283 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_new(outpoint_arg, output_arg, channel_keys_id_arg, channel_value_satoshis_arg);
17284 return nativeResponseValue;
17286 // uintptr_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg);
17288 export function StaticPaymentOutputDescriptor_clone_ptr(arg: number): number {
17289 if(!isWasmInitialized) {
17290 throw new Error("initializeWasm() must be awaited first!");
17292 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone_ptr(arg);
17293 return nativeResponseValue;
17295 // struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_clone(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR orig);
17297 export function StaticPaymentOutputDescriptor_clone(orig: number): number {
17298 if(!isWasmInitialized) {
17299 throw new Error("initializeWasm() must be awaited first!");
17301 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone(orig);
17302 return nativeResponseValue;
17304 // struct LDKCVec_u8Z StaticPaymentOutputDescriptor_write(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR obj);
17306 export function StaticPaymentOutputDescriptor_write(obj: number): number {
17307 if(!isWasmInitialized) {
17308 throw new Error("initializeWasm() must be awaited first!");
17310 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_write(obj);
17311 return nativeResponseValue;
17313 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ StaticPaymentOutputDescriptor_read(struct LDKu8slice ser);
17315 export function StaticPaymentOutputDescriptor_read(ser: number): number {
17316 if(!isWasmInitialized) {
17317 throw new Error("initializeWasm() must be awaited first!");
17319 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_read(ser);
17320 return nativeResponseValue;
17322 // void SpendableOutputDescriptor_free(struct LDKSpendableOutputDescriptor this_ptr);
17324 export function SpendableOutputDescriptor_free(this_ptr: number): void {
17325 if(!isWasmInitialized) {
17326 throw new Error("initializeWasm() must be awaited first!");
17328 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_free(this_ptr);
17329 // debug statements here
17331 // uintptr_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg);
17333 export function SpendableOutputDescriptor_clone_ptr(arg: number): number {
17334 if(!isWasmInitialized) {
17335 throw new Error("initializeWasm() must be awaited first!");
17337 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone_ptr(arg);
17338 return nativeResponseValue;
17340 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_clone(const struct LDKSpendableOutputDescriptor *NONNULL_PTR orig);
17342 export function SpendableOutputDescriptor_clone(orig: number): number {
17343 if(!isWasmInitialized) {
17344 throw new Error("initializeWasm() must be awaited first!");
17346 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone(orig);
17347 return nativeResponseValue;
17349 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_output(struct LDKOutPoint outpoint, struct LDKTxOut output);
17351 export function SpendableOutputDescriptor_static_output(outpoint: number, output: number): number {
17352 if(!isWasmInitialized) {
17353 throw new Error("initializeWasm() must be awaited first!");
17355 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_output(outpoint, output);
17356 return nativeResponseValue;
17358 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_delayed_payment_output(struct LDKDelayedPaymentOutputDescriptor a);
17360 export function SpendableOutputDescriptor_delayed_payment_output(a: number): number {
17361 if(!isWasmInitialized) {
17362 throw new Error("initializeWasm() must be awaited first!");
17364 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_delayed_payment_output(a);
17365 return nativeResponseValue;
17367 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_payment_output(struct LDKStaticPaymentOutputDescriptor a);
17369 export function SpendableOutputDescriptor_static_payment_output(a: number): number {
17370 if(!isWasmInitialized) {
17371 throw new Error("initializeWasm() must be awaited first!");
17373 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_payment_output(a);
17374 return nativeResponseValue;
17376 // struct LDKCVec_u8Z SpendableOutputDescriptor_write(const struct LDKSpendableOutputDescriptor *NONNULL_PTR obj);
17378 export function SpendableOutputDescriptor_write(obj: number): number {
17379 if(!isWasmInitialized) {
17380 throw new Error("initializeWasm() must be awaited first!");
17382 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_write(obj);
17383 return nativeResponseValue;
17385 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ SpendableOutputDescriptor_read(struct LDKu8slice ser);
17387 export function SpendableOutputDescriptor_read(ser: number): number {
17388 if(!isWasmInitialized) {
17389 throw new Error("initializeWasm() must be awaited first!");
17391 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_read(ser);
17392 return nativeResponseValue;
17394 // void BaseSign_free(struct LDKBaseSign this_ptr);
17396 export function BaseSign_free(this_ptr: number): void {
17397 if(!isWasmInitialized) {
17398 throw new Error("initializeWasm() must be awaited first!");
17400 const nativeResponseValue = wasm.TS_BaseSign_free(this_ptr);
17401 // debug statements here
17403 // uintptr_t Sign_clone_ptr(LDKSign *NONNULL_PTR arg);
17405 export function Sign_clone_ptr(arg: number): number {
17406 if(!isWasmInitialized) {
17407 throw new Error("initializeWasm() must be awaited first!");
17409 const nativeResponseValue = wasm.TS_Sign_clone_ptr(arg);
17410 return nativeResponseValue;
17412 // struct LDKSign Sign_clone(const struct LDKSign *NONNULL_PTR orig);
17414 export function Sign_clone(orig: number): number {
17415 if(!isWasmInitialized) {
17416 throw new Error("initializeWasm() must be awaited first!");
17418 const nativeResponseValue = wasm.TS_Sign_clone(orig);
17419 return nativeResponseValue;
17421 // void Sign_free(struct LDKSign this_ptr);
17423 export function Sign_free(this_ptr: number): void {
17424 if(!isWasmInitialized) {
17425 throw new Error("initializeWasm() must be awaited first!");
17427 const nativeResponseValue = wasm.TS_Sign_free(this_ptr);
17428 // debug statements here
17430 // enum LDKRecipient Recipient_clone(const enum LDKRecipient *NONNULL_PTR orig);
17432 export function Recipient_clone(orig: number): Recipient {
17433 if(!isWasmInitialized) {
17434 throw new Error("initializeWasm() must be awaited first!");
17436 const nativeResponseValue = wasm.TS_Recipient_clone(orig);
17437 return nativeResponseValue;
17439 // enum LDKRecipient Recipient_node(void);
17441 export function Recipient_node(): Recipient {
17442 if(!isWasmInitialized) {
17443 throw new Error("initializeWasm() must be awaited first!");
17445 const nativeResponseValue = wasm.TS_Recipient_node();
17446 return nativeResponseValue;
17448 // enum LDKRecipient Recipient_phantom_node(void);
17450 export function Recipient_phantom_node(): Recipient {
17451 if(!isWasmInitialized) {
17452 throw new Error("initializeWasm() must be awaited first!");
17454 const nativeResponseValue = wasm.TS_Recipient_phantom_node();
17455 return nativeResponseValue;
17457 // void KeysInterface_free(struct LDKKeysInterface this_ptr);
17459 export function KeysInterface_free(this_ptr: number): void {
17460 if(!isWasmInitialized) {
17461 throw new Error("initializeWasm() must be awaited first!");
17463 const nativeResponseValue = wasm.TS_KeysInterface_free(this_ptr);
17464 // debug statements here
17466 // void InMemorySigner_free(struct LDKInMemorySigner this_obj);
17468 export function InMemorySigner_free(this_obj: number): void {
17469 if(!isWasmInitialized) {
17470 throw new Error("initializeWasm() must be awaited first!");
17472 const nativeResponseValue = wasm.TS_InMemorySigner_free(this_obj);
17473 // debug statements here
17475 // const uint8_t (*InMemorySigner_get_funding_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
17477 export function InMemorySigner_get_funding_key(this_ptr: number): number {
17478 if(!isWasmInitialized) {
17479 throw new Error("initializeWasm() must be awaited first!");
17481 const nativeResponseValue = wasm.TS_InMemorySigner_get_funding_key(this_ptr);
17482 return nativeResponseValue;
17484 // void InMemorySigner_set_funding_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
17486 export function InMemorySigner_set_funding_key(this_ptr: number, val: number): void {
17487 if(!isWasmInitialized) {
17488 throw new Error("initializeWasm() must be awaited first!");
17490 const nativeResponseValue = wasm.TS_InMemorySigner_set_funding_key(this_ptr, val);
17491 // debug statements here
17493 // const uint8_t (*InMemorySigner_get_revocation_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
17495 export function InMemorySigner_get_revocation_base_key(this_ptr: number): number {
17496 if(!isWasmInitialized) {
17497 throw new Error("initializeWasm() must be awaited first!");
17499 const nativeResponseValue = wasm.TS_InMemorySigner_get_revocation_base_key(this_ptr);
17500 return nativeResponseValue;
17502 // void InMemorySigner_set_revocation_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
17504 export function InMemorySigner_set_revocation_base_key(this_ptr: number, val: number): void {
17505 if(!isWasmInitialized) {
17506 throw new Error("initializeWasm() must be awaited first!");
17508 const nativeResponseValue = wasm.TS_InMemorySigner_set_revocation_base_key(this_ptr, val);
17509 // debug statements here
17511 // const uint8_t (*InMemorySigner_get_payment_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
17513 export function InMemorySigner_get_payment_key(this_ptr: number): number {
17514 if(!isWasmInitialized) {
17515 throw new Error("initializeWasm() must be awaited first!");
17517 const nativeResponseValue = wasm.TS_InMemorySigner_get_payment_key(this_ptr);
17518 return nativeResponseValue;
17520 // void InMemorySigner_set_payment_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
17522 export function InMemorySigner_set_payment_key(this_ptr: number, val: number): void {
17523 if(!isWasmInitialized) {
17524 throw new Error("initializeWasm() must be awaited first!");
17526 const nativeResponseValue = wasm.TS_InMemorySigner_set_payment_key(this_ptr, val);
17527 // debug statements here
17529 // const uint8_t (*InMemorySigner_get_delayed_payment_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
17531 export function InMemorySigner_get_delayed_payment_base_key(this_ptr: number): number {
17532 if(!isWasmInitialized) {
17533 throw new Error("initializeWasm() must be awaited first!");
17535 const nativeResponseValue = wasm.TS_InMemorySigner_get_delayed_payment_base_key(this_ptr);
17536 return nativeResponseValue;
17538 // void InMemorySigner_set_delayed_payment_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
17540 export function InMemorySigner_set_delayed_payment_base_key(this_ptr: number, val: number): void {
17541 if(!isWasmInitialized) {
17542 throw new Error("initializeWasm() must be awaited first!");
17544 const nativeResponseValue = wasm.TS_InMemorySigner_set_delayed_payment_base_key(this_ptr, val);
17545 // debug statements here
17547 // const uint8_t (*InMemorySigner_get_htlc_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
17549 export function InMemorySigner_get_htlc_base_key(this_ptr: number): number {
17550 if(!isWasmInitialized) {
17551 throw new Error("initializeWasm() must be awaited first!");
17553 const nativeResponseValue = wasm.TS_InMemorySigner_get_htlc_base_key(this_ptr);
17554 return nativeResponseValue;
17556 // void InMemorySigner_set_htlc_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
17558 export function InMemorySigner_set_htlc_base_key(this_ptr: number, val: number): void {
17559 if(!isWasmInitialized) {
17560 throw new Error("initializeWasm() must be awaited first!");
17562 const nativeResponseValue = wasm.TS_InMemorySigner_set_htlc_base_key(this_ptr, val);
17563 // debug statements here
17565 // const uint8_t (*InMemorySigner_get_commitment_seed(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
17567 export function InMemorySigner_get_commitment_seed(this_ptr: number): number {
17568 if(!isWasmInitialized) {
17569 throw new Error("initializeWasm() must be awaited first!");
17571 const nativeResponseValue = wasm.TS_InMemorySigner_get_commitment_seed(this_ptr);
17572 return nativeResponseValue;
17574 // void InMemorySigner_set_commitment_seed(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17576 export function InMemorySigner_set_commitment_seed(this_ptr: number, val: number): void {
17577 if(!isWasmInitialized) {
17578 throw new Error("initializeWasm() must be awaited first!");
17580 const nativeResponseValue = wasm.TS_InMemorySigner_set_commitment_seed(this_ptr, val);
17581 // debug statements here
17583 // uintptr_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg);
17585 export function InMemorySigner_clone_ptr(arg: number): number {
17586 if(!isWasmInitialized) {
17587 throw new Error("initializeWasm() must be awaited first!");
17589 const nativeResponseValue = wasm.TS_InMemorySigner_clone_ptr(arg);
17590 return nativeResponseValue;
17592 // struct LDKInMemorySigner InMemorySigner_clone(const struct LDKInMemorySigner *NONNULL_PTR orig);
17594 export function InMemorySigner_clone(orig: number): number {
17595 if(!isWasmInitialized) {
17596 throw new Error("initializeWasm() must be awaited first!");
17598 const nativeResponseValue = wasm.TS_InMemorySigner_clone(orig);
17599 return nativeResponseValue;
17601 // 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);
17603 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 {
17604 if(!isWasmInitialized) {
17605 throw new Error("initializeWasm() must be awaited first!");
17607 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);
17608 return nativeResponseValue;
17610 // MUST_USE_RES struct LDKChannelPublicKeys InMemorySigner_counterparty_pubkeys(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
17612 export function InMemorySigner_counterparty_pubkeys(this_arg: number): number {
17613 if(!isWasmInitialized) {
17614 throw new Error("initializeWasm() must be awaited first!");
17616 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_pubkeys(this_arg);
17617 return nativeResponseValue;
17619 // MUST_USE_RES uint16_t InMemorySigner_counterparty_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
17621 export function InMemorySigner_counterparty_selected_contest_delay(this_arg: number): number {
17622 if(!isWasmInitialized) {
17623 throw new Error("initializeWasm() must be awaited first!");
17625 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_selected_contest_delay(this_arg);
17626 return nativeResponseValue;
17628 // MUST_USE_RES uint16_t InMemorySigner_holder_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
17630 export function InMemorySigner_holder_selected_contest_delay(this_arg: number): number {
17631 if(!isWasmInitialized) {
17632 throw new Error("initializeWasm() must be awaited first!");
17634 const nativeResponseValue = wasm.TS_InMemorySigner_holder_selected_contest_delay(this_arg);
17635 return nativeResponseValue;
17637 // MUST_USE_RES bool InMemorySigner_is_outbound(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
17639 export function InMemorySigner_is_outbound(this_arg: number): boolean {
17640 if(!isWasmInitialized) {
17641 throw new Error("initializeWasm() must be awaited first!");
17643 const nativeResponseValue = wasm.TS_InMemorySigner_is_outbound(this_arg);
17644 return nativeResponseValue;
17646 // MUST_USE_RES struct LDKOutPoint InMemorySigner_funding_outpoint(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
17648 export function InMemorySigner_funding_outpoint(this_arg: number): number {
17649 if(!isWasmInitialized) {
17650 throw new Error("initializeWasm() must be awaited first!");
17652 const nativeResponseValue = wasm.TS_InMemorySigner_funding_outpoint(this_arg);
17653 return nativeResponseValue;
17655 // MUST_USE_RES struct LDKChannelTransactionParameters InMemorySigner_get_channel_parameters(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
17657 export function InMemorySigner_get_channel_parameters(this_arg: number): number {
17658 if(!isWasmInitialized) {
17659 throw new Error("initializeWasm() must be awaited first!");
17661 const nativeResponseValue = wasm.TS_InMemorySigner_get_channel_parameters(this_arg);
17662 return nativeResponseValue;
17664 // MUST_USE_RES bool InMemorySigner_opt_anchors(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
17666 export function InMemorySigner_opt_anchors(this_arg: number): boolean {
17667 if(!isWasmInitialized) {
17668 throw new Error("initializeWasm() must be awaited first!");
17670 const nativeResponseValue = wasm.TS_InMemorySigner_opt_anchors(this_arg);
17671 return nativeResponseValue;
17673 // 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);
17675 export function InMemorySigner_sign_counterparty_payment_input(this_arg: number, spend_tx: number, input_idx: number, descriptor: number): number {
17676 if(!isWasmInitialized) {
17677 throw new Error("initializeWasm() must be awaited first!");
17679 const nativeResponseValue = wasm.TS_InMemorySigner_sign_counterparty_payment_input(this_arg, spend_tx, input_idx, descriptor);
17680 return nativeResponseValue;
17682 // 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);
17684 export function InMemorySigner_sign_dynamic_p2wsh_input(this_arg: number, spend_tx: number, input_idx: number, descriptor: number): number {
17685 if(!isWasmInitialized) {
17686 throw new Error("initializeWasm() must be awaited first!");
17688 const nativeResponseValue = wasm.TS_InMemorySigner_sign_dynamic_p2wsh_input(this_arg, spend_tx, input_idx, descriptor);
17689 return nativeResponseValue;
17691 // struct LDKBaseSign InMemorySigner_as_BaseSign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
17693 export function InMemorySigner_as_BaseSign(this_arg: number): number {
17694 if(!isWasmInitialized) {
17695 throw new Error("initializeWasm() must be awaited first!");
17697 const nativeResponseValue = wasm.TS_InMemorySigner_as_BaseSign(this_arg);
17698 return nativeResponseValue;
17700 // struct LDKSign InMemorySigner_as_Sign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
17702 export function InMemorySigner_as_Sign(this_arg: number): number {
17703 if(!isWasmInitialized) {
17704 throw new Error("initializeWasm() must be awaited first!");
17706 const nativeResponseValue = wasm.TS_InMemorySigner_as_Sign(this_arg);
17707 return nativeResponseValue;
17709 // struct LDKCVec_u8Z InMemorySigner_write(const struct LDKInMemorySigner *NONNULL_PTR obj);
17711 export function InMemorySigner_write(obj: number): number {
17712 if(!isWasmInitialized) {
17713 throw new Error("initializeWasm() must be awaited first!");
17715 const nativeResponseValue = wasm.TS_InMemorySigner_write(obj);
17716 return nativeResponseValue;
17718 // struct LDKCResult_InMemorySignerDecodeErrorZ InMemorySigner_read(struct LDKu8slice ser, struct LDKSecretKey arg);
17720 export function InMemorySigner_read(ser: number, arg: number): number {
17721 if(!isWasmInitialized) {
17722 throw new Error("initializeWasm() must be awaited first!");
17724 const nativeResponseValue = wasm.TS_InMemorySigner_read(ser, arg);
17725 return nativeResponseValue;
17727 // void KeysManager_free(struct LDKKeysManager this_obj);
17729 export function KeysManager_free(this_obj: number): void {
17730 if(!isWasmInitialized) {
17731 throw new Error("initializeWasm() must be awaited first!");
17733 const nativeResponseValue = wasm.TS_KeysManager_free(this_obj);
17734 // debug statements here
17736 // MUST_USE_RES struct LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], uint64_t starting_time_secs, uint32_t starting_time_nanos);
17738 export function KeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number): number {
17739 if(!isWasmInitialized) {
17740 throw new Error("initializeWasm() must be awaited first!");
17742 const nativeResponseValue = wasm.TS_KeysManager_new(seed, starting_time_secs, starting_time_nanos);
17743 return nativeResponseValue;
17745 // 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]);
17747 export function KeysManager_derive_channel_keys(this_arg: number, channel_value_satoshis: bigint, params: number): number {
17748 if(!isWasmInitialized) {
17749 throw new Error("initializeWasm() must be awaited first!");
17751 const nativeResponseValue = wasm.TS_KeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
17752 return nativeResponseValue;
17754 // 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);
17756 export function KeysManager_spend_spendable_outputs(this_arg: number, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): number {
17757 if(!isWasmInitialized) {
17758 throw new Error("initializeWasm() must be awaited first!");
17760 const nativeResponseValue = wasm.TS_KeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
17761 return nativeResponseValue;
17763 // struct LDKKeysInterface KeysManager_as_KeysInterface(const struct LDKKeysManager *NONNULL_PTR this_arg);
17765 export function KeysManager_as_KeysInterface(this_arg: number): number {
17766 if(!isWasmInitialized) {
17767 throw new Error("initializeWasm() must be awaited first!");
17769 const nativeResponseValue = wasm.TS_KeysManager_as_KeysInterface(this_arg);
17770 return nativeResponseValue;
17772 // void PhantomKeysManager_free(struct LDKPhantomKeysManager this_obj);
17774 export function PhantomKeysManager_free(this_obj: number): void {
17775 if(!isWasmInitialized) {
17776 throw new Error("initializeWasm() must be awaited first!");
17778 const nativeResponseValue = wasm.TS_PhantomKeysManager_free(this_obj);
17779 // debug statements here
17781 // struct LDKKeysInterface PhantomKeysManager_as_KeysInterface(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
17783 export function PhantomKeysManager_as_KeysInterface(this_arg: number): number {
17784 if(!isWasmInitialized) {
17785 throw new Error("initializeWasm() must be awaited first!");
17787 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_KeysInterface(this_arg);
17788 return nativeResponseValue;
17790 // 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]);
17792 export function PhantomKeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number, cross_node_seed: number): number {
17793 if(!isWasmInitialized) {
17794 throw new Error("initializeWasm() must be awaited first!");
17796 const nativeResponseValue = wasm.TS_PhantomKeysManager_new(seed, starting_time_secs, starting_time_nanos, cross_node_seed);
17797 return nativeResponseValue;
17799 // 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);
17801 export function PhantomKeysManager_spend_spendable_outputs(this_arg: number, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): number {
17802 if(!isWasmInitialized) {
17803 throw new Error("initializeWasm() must be awaited first!");
17805 const nativeResponseValue = wasm.TS_PhantomKeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
17806 return nativeResponseValue;
17808 // 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]);
17810 export function PhantomKeysManager_derive_channel_keys(this_arg: number, channel_value_satoshis: bigint, params: number): number {
17811 if(!isWasmInitialized) {
17812 throw new Error("initializeWasm() must be awaited first!");
17814 const nativeResponseValue = wasm.TS_PhantomKeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
17815 return nativeResponseValue;
17817 // void ChannelManager_free(struct LDKChannelManager this_obj);
17819 export function ChannelManager_free(this_obj: number): void {
17820 if(!isWasmInitialized) {
17821 throw new Error("initializeWasm() must be awaited first!");
17823 const nativeResponseValue = wasm.TS_ChannelManager_free(this_obj);
17824 // debug statements here
17826 // void ChainParameters_free(struct LDKChainParameters this_obj);
17828 export function ChainParameters_free(this_obj: number): void {
17829 if(!isWasmInitialized) {
17830 throw new Error("initializeWasm() must be awaited first!");
17832 const nativeResponseValue = wasm.TS_ChainParameters_free(this_obj);
17833 // debug statements here
17835 // enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr);
17837 export function ChainParameters_get_network(this_ptr: number): Network {
17838 if(!isWasmInitialized) {
17839 throw new Error("initializeWasm() must be awaited first!");
17841 const nativeResponseValue = wasm.TS_ChainParameters_get_network(this_ptr);
17842 return nativeResponseValue;
17844 // void ChainParameters_set_network(struct LDKChainParameters *NONNULL_PTR this_ptr, enum LDKNetwork val);
17846 export function ChainParameters_set_network(this_ptr: number, val: Network): void {
17847 if(!isWasmInitialized) {
17848 throw new Error("initializeWasm() must be awaited first!");
17850 const nativeResponseValue = wasm.TS_ChainParameters_set_network(this_ptr, val);
17851 // debug statements here
17853 // struct LDKBestBlock ChainParameters_get_best_block(const struct LDKChainParameters *NONNULL_PTR this_ptr);
17855 export function ChainParameters_get_best_block(this_ptr: number): number {
17856 if(!isWasmInitialized) {
17857 throw new Error("initializeWasm() must be awaited first!");
17859 const nativeResponseValue = wasm.TS_ChainParameters_get_best_block(this_ptr);
17860 return nativeResponseValue;
17862 // void ChainParameters_set_best_block(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKBestBlock val);
17864 export function ChainParameters_set_best_block(this_ptr: number, val: number): void {
17865 if(!isWasmInitialized) {
17866 throw new Error("initializeWasm() must be awaited first!");
17868 const nativeResponseValue = wasm.TS_ChainParameters_set_best_block(this_ptr, val);
17869 // debug statements here
17871 // MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKBestBlock best_block_arg);
17873 export function ChainParameters_new(network_arg: Network, best_block_arg: number): number {
17874 if(!isWasmInitialized) {
17875 throw new Error("initializeWasm() must be awaited first!");
17877 const nativeResponseValue = wasm.TS_ChainParameters_new(network_arg, best_block_arg);
17878 return nativeResponseValue;
17880 // uintptr_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg);
17882 export function ChainParameters_clone_ptr(arg: number): number {
17883 if(!isWasmInitialized) {
17884 throw new Error("initializeWasm() must be awaited first!");
17886 const nativeResponseValue = wasm.TS_ChainParameters_clone_ptr(arg);
17887 return nativeResponseValue;
17889 // struct LDKChainParameters ChainParameters_clone(const struct LDKChainParameters *NONNULL_PTR orig);
17891 export function ChainParameters_clone(orig: number): number {
17892 if(!isWasmInitialized) {
17893 throw new Error("initializeWasm() must be awaited first!");
17895 const nativeResponseValue = wasm.TS_ChainParameters_clone(orig);
17896 return nativeResponseValue;
17898 // void CounterpartyForwardingInfo_free(struct LDKCounterpartyForwardingInfo this_obj);
17900 export function CounterpartyForwardingInfo_free(this_obj: number): void {
17901 if(!isWasmInitialized) {
17902 throw new Error("initializeWasm() must be awaited first!");
17904 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_free(this_obj);
17905 // debug statements here
17907 // uint32_t CounterpartyForwardingInfo_get_fee_base_msat(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
17909 export function CounterpartyForwardingInfo_get_fee_base_msat(this_ptr: number): number {
17910 if(!isWasmInitialized) {
17911 throw new Error("initializeWasm() must be awaited first!");
17913 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_base_msat(this_ptr);
17914 return nativeResponseValue;
17916 // void CounterpartyForwardingInfo_set_fee_base_msat(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
17918 export function CounterpartyForwardingInfo_set_fee_base_msat(this_ptr: number, val: number): void {
17919 if(!isWasmInitialized) {
17920 throw new Error("initializeWasm() must be awaited first!");
17922 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_base_msat(this_ptr, val);
17923 // debug statements here
17925 // uint32_t CounterpartyForwardingInfo_get_fee_proportional_millionths(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
17927 export function CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr: number): number {
17928 if(!isWasmInitialized) {
17929 throw new Error("initializeWasm() must be awaited first!");
17931 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr);
17932 return nativeResponseValue;
17934 // void CounterpartyForwardingInfo_set_fee_proportional_millionths(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
17936 export function CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr: number, val: number): void {
17937 if(!isWasmInitialized) {
17938 throw new Error("initializeWasm() must be awaited first!");
17940 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr, val);
17941 // debug statements here
17943 // uint16_t CounterpartyForwardingInfo_get_cltv_expiry_delta(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
17945 export function CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr: number): number {
17946 if(!isWasmInitialized) {
17947 throw new Error("initializeWasm() must be awaited first!");
17949 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr);
17950 return nativeResponseValue;
17952 // void CounterpartyForwardingInfo_set_cltv_expiry_delta(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint16_t val);
17954 export function CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr: number, val: number): void {
17955 if(!isWasmInitialized) {
17956 throw new Error("initializeWasm() must be awaited first!");
17958 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr, val);
17959 // debug statements here
17961 // 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);
17963 export function CounterpartyForwardingInfo_new(fee_base_msat_arg: number, fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number): number {
17964 if(!isWasmInitialized) {
17965 throw new Error("initializeWasm() must be awaited first!");
17967 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
17968 return nativeResponseValue;
17970 // uintptr_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg);
17972 export function CounterpartyForwardingInfo_clone_ptr(arg: number): number {
17973 if(!isWasmInitialized) {
17974 throw new Error("initializeWasm() must be awaited first!");
17976 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone_ptr(arg);
17977 return nativeResponseValue;
17979 // struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_clone(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR orig);
17981 export function CounterpartyForwardingInfo_clone(orig: number): number {
17982 if(!isWasmInitialized) {
17983 throw new Error("initializeWasm() must be awaited first!");
17985 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone(orig);
17986 return nativeResponseValue;
17988 // void ChannelCounterparty_free(struct LDKChannelCounterparty this_obj);
17990 export function ChannelCounterparty_free(this_obj: number): void {
17991 if(!isWasmInitialized) {
17992 throw new Error("initializeWasm() must be awaited first!");
17994 const nativeResponseValue = wasm.TS_ChannelCounterparty_free(this_obj);
17995 // debug statements here
17997 // struct LDKPublicKey ChannelCounterparty_get_node_id(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
17999 export function ChannelCounterparty_get_node_id(this_ptr: number): number {
18000 if(!isWasmInitialized) {
18001 throw new Error("initializeWasm() must be awaited first!");
18003 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_node_id(this_ptr);
18004 return nativeResponseValue;
18006 // void ChannelCounterparty_set_node_id(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKPublicKey val);
18008 export function ChannelCounterparty_set_node_id(this_ptr: number, val: number): void {
18009 if(!isWasmInitialized) {
18010 throw new Error("initializeWasm() must be awaited first!");
18012 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_node_id(this_ptr, val);
18013 // debug statements here
18015 // struct LDKInitFeatures ChannelCounterparty_get_features(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18017 export function ChannelCounterparty_get_features(this_ptr: number): number {
18018 if(!isWasmInitialized) {
18019 throw new Error("initializeWasm() must be awaited first!");
18021 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_features(this_ptr);
18022 return nativeResponseValue;
18024 // void ChannelCounterparty_set_features(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
18026 export function ChannelCounterparty_set_features(this_ptr: number, val: number): void {
18027 if(!isWasmInitialized) {
18028 throw new Error("initializeWasm() must be awaited first!");
18030 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_features(this_ptr, val);
18031 // debug statements here
18033 // uint64_t ChannelCounterparty_get_unspendable_punishment_reserve(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18035 export function ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr: number): bigint {
18036 if(!isWasmInitialized) {
18037 throw new Error("initializeWasm() must be awaited first!");
18039 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr);
18040 return nativeResponseValue;
18042 // void ChannelCounterparty_set_unspendable_punishment_reserve(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, uint64_t val);
18044 export function ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr: number, val: bigint): void {
18045 if(!isWasmInitialized) {
18046 throw new Error("initializeWasm() must be awaited first!");
18048 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr, val);
18049 // debug statements here
18051 // struct LDKCounterpartyForwardingInfo ChannelCounterparty_get_forwarding_info(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18053 export function ChannelCounterparty_get_forwarding_info(this_ptr: number): number {
18054 if(!isWasmInitialized) {
18055 throw new Error("initializeWasm() must be awaited first!");
18057 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_forwarding_info(this_ptr);
18058 return nativeResponseValue;
18060 // void ChannelCounterparty_set_forwarding_info(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCounterpartyForwardingInfo val);
18062 export function ChannelCounterparty_set_forwarding_info(this_ptr: number, val: number): void {
18063 if(!isWasmInitialized) {
18064 throw new Error("initializeWasm() must be awaited first!");
18066 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_forwarding_info(this_ptr, val);
18067 // debug statements here
18069 // 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);
18071 export function ChannelCounterparty_new(node_id_arg: number, features_arg: number, unspendable_punishment_reserve_arg: bigint, forwarding_info_arg: number): number {
18072 if(!isWasmInitialized) {
18073 throw new Error("initializeWasm() must be awaited first!");
18075 const nativeResponseValue = wasm.TS_ChannelCounterparty_new(node_id_arg, features_arg, unspendable_punishment_reserve_arg, forwarding_info_arg);
18076 return nativeResponseValue;
18078 // uintptr_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg);
18080 export function ChannelCounterparty_clone_ptr(arg: number): number {
18081 if(!isWasmInitialized) {
18082 throw new Error("initializeWasm() must be awaited first!");
18084 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone_ptr(arg);
18085 return nativeResponseValue;
18087 // struct LDKChannelCounterparty ChannelCounterparty_clone(const struct LDKChannelCounterparty *NONNULL_PTR orig);
18089 export function ChannelCounterparty_clone(orig: number): number {
18090 if(!isWasmInitialized) {
18091 throw new Error("initializeWasm() must be awaited first!");
18093 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone(orig);
18094 return nativeResponseValue;
18096 // void ChannelDetails_free(struct LDKChannelDetails this_obj);
18098 export function ChannelDetails_free(this_obj: number): void {
18099 if(!isWasmInitialized) {
18100 throw new Error("initializeWasm() must be awaited first!");
18102 const nativeResponseValue = wasm.TS_ChannelDetails_free(this_obj);
18103 // debug statements here
18105 // const uint8_t (*ChannelDetails_get_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr))[32];
18107 export function ChannelDetails_get_channel_id(this_ptr: number): number {
18108 if(!isWasmInitialized) {
18109 throw new Error("initializeWasm() must be awaited first!");
18111 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_id(this_ptr);
18112 return nativeResponseValue;
18114 // void ChannelDetails_set_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18116 export function ChannelDetails_set_channel_id(this_ptr: number, val: number): void {
18117 if(!isWasmInitialized) {
18118 throw new Error("initializeWasm() must be awaited first!");
18120 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_id(this_ptr, val);
18121 // debug statements here
18123 // struct LDKChannelCounterparty ChannelDetails_get_counterparty(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18125 export function ChannelDetails_get_counterparty(this_ptr: number): number {
18126 if(!isWasmInitialized) {
18127 throw new Error("initializeWasm() must be awaited first!");
18129 const nativeResponseValue = wasm.TS_ChannelDetails_get_counterparty(this_ptr);
18130 return nativeResponseValue;
18132 // void ChannelDetails_set_counterparty(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelCounterparty val);
18134 export function ChannelDetails_set_counterparty(this_ptr: number, val: number): void {
18135 if(!isWasmInitialized) {
18136 throw new Error("initializeWasm() must be awaited first!");
18138 const nativeResponseValue = wasm.TS_ChannelDetails_set_counterparty(this_ptr, val);
18139 // debug statements here
18141 // struct LDKOutPoint ChannelDetails_get_funding_txo(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18143 export function ChannelDetails_get_funding_txo(this_ptr: number): number {
18144 if(!isWasmInitialized) {
18145 throw new Error("initializeWasm() must be awaited first!");
18147 const nativeResponseValue = wasm.TS_ChannelDetails_get_funding_txo(this_ptr);
18148 return nativeResponseValue;
18150 // void ChannelDetails_set_funding_txo(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKOutPoint val);
18152 export function ChannelDetails_set_funding_txo(this_ptr: number, val: number): void {
18153 if(!isWasmInitialized) {
18154 throw new Error("initializeWasm() must be awaited first!");
18156 const nativeResponseValue = wasm.TS_ChannelDetails_set_funding_txo(this_ptr, val);
18157 // debug statements here
18159 // struct LDKCOption_u64Z ChannelDetails_get_short_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18161 export function ChannelDetails_get_short_channel_id(this_ptr: number): number {
18162 if(!isWasmInitialized) {
18163 throw new Error("initializeWasm() must be awaited first!");
18165 const nativeResponseValue = wasm.TS_ChannelDetails_get_short_channel_id(this_ptr);
18166 return nativeResponseValue;
18168 // void ChannelDetails_set_short_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
18170 export function ChannelDetails_set_short_channel_id(this_ptr: number, val: number): void {
18171 if(!isWasmInitialized) {
18172 throw new Error("initializeWasm() must be awaited first!");
18174 const nativeResponseValue = wasm.TS_ChannelDetails_set_short_channel_id(this_ptr, val);
18175 // debug statements here
18177 // uint64_t ChannelDetails_get_channel_value_satoshis(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18179 export function ChannelDetails_get_channel_value_satoshis(this_ptr: number): bigint {
18180 if(!isWasmInitialized) {
18181 throw new Error("initializeWasm() must be awaited first!");
18183 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_value_satoshis(this_ptr);
18184 return nativeResponseValue;
18186 // void ChannelDetails_set_channel_value_satoshis(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
18188 export function ChannelDetails_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
18189 if(!isWasmInitialized) {
18190 throw new Error("initializeWasm() must be awaited first!");
18192 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_value_satoshis(this_ptr, val);
18193 // debug statements here
18195 // struct LDKCOption_u64Z ChannelDetails_get_unspendable_punishment_reserve(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18197 export function ChannelDetails_get_unspendable_punishment_reserve(this_ptr: number): number {
18198 if(!isWasmInitialized) {
18199 throw new Error("initializeWasm() must be awaited first!");
18201 const nativeResponseValue = wasm.TS_ChannelDetails_get_unspendable_punishment_reserve(this_ptr);
18202 return nativeResponseValue;
18204 // void ChannelDetails_set_unspendable_punishment_reserve(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
18206 export function ChannelDetails_set_unspendable_punishment_reserve(this_ptr: number, val: number): void {
18207 if(!isWasmInitialized) {
18208 throw new Error("initializeWasm() must be awaited first!");
18210 const nativeResponseValue = wasm.TS_ChannelDetails_set_unspendable_punishment_reserve(this_ptr, val);
18211 // debug statements here
18213 // uint64_t ChannelDetails_get_user_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18215 export function ChannelDetails_get_user_channel_id(this_ptr: number): bigint {
18216 if(!isWasmInitialized) {
18217 throw new Error("initializeWasm() must be awaited first!");
18219 const nativeResponseValue = wasm.TS_ChannelDetails_get_user_channel_id(this_ptr);
18220 return nativeResponseValue;
18222 // void ChannelDetails_set_user_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
18224 export function ChannelDetails_set_user_channel_id(this_ptr: number, val: bigint): void {
18225 if(!isWasmInitialized) {
18226 throw new Error("initializeWasm() must be awaited first!");
18228 const nativeResponseValue = wasm.TS_ChannelDetails_set_user_channel_id(this_ptr, val);
18229 // debug statements here
18231 // uint64_t ChannelDetails_get_balance_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18233 export function ChannelDetails_get_balance_msat(this_ptr: number): bigint {
18234 if(!isWasmInitialized) {
18235 throw new Error("initializeWasm() must be awaited first!");
18237 const nativeResponseValue = wasm.TS_ChannelDetails_get_balance_msat(this_ptr);
18238 return nativeResponseValue;
18240 // void ChannelDetails_set_balance_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
18242 export function ChannelDetails_set_balance_msat(this_ptr: number, val: bigint): void {
18243 if(!isWasmInitialized) {
18244 throw new Error("initializeWasm() must be awaited first!");
18246 const nativeResponseValue = wasm.TS_ChannelDetails_set_balance_msat(this_ptr, val);
18247 // debug statements here
18249 // uint64_t ChannelDetails_get_outbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18251 export function ChannelDetails_get_outbound_capacity_msat(this_ptr: number): bigint {
18252 if(!isWasmInitialized) {
18253 throw new Error("initializeWasm() must be awaited first!");
18255 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_capacity_msat(this_ptr);
18256 return nativeResponseValue;
18258 // void ChannelDetails_set_outbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
18260 export function ChannelDetails_set_outbound_capacity_msat(this_ptr: number, val: bigint): void {
18261 if(!isWasmInitialized) {
18262 throw new Error("initializeWasm() must be awaited first!");
18264 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_capacity_msat(this_ptr, val);
18265 // debug statements here
18267 // uint64_t ChannelDetails_get_inbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18269 export function ChannelDetails_get_inbound_capacity_msat(this_ptr: number): bigint {
18270 if(!isWasmInitialized) {
18271 throw new Error("initializeWasm() must be awaited first!");
18273 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_capacity_msat(this_ptr);
18274 return nativeResponseValue;
18276 // void ChannelDetails_set_inbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
18278 export function ChannelDetails_set_inbound_capacity_msat(this_ptr: number, val: bigint): void {
18279 if(!isWasmInitialized) {
18280 throw new Error("initializeWasm() must be awaited first!");
18282 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_capacity_msat(this_ptr, val);
18283 // debug statements here
18285 // struct LDKCOption_u32Z ChannelDetails_get_confirmations_required(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18287 export function ChannelDetails_get_confirmations_required(this_ptr: number): number {
18288 if(!isWasmInitialized) {
18289 throw new Error("initializeWasm() must be awaited first!");
18291 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations_required(this_ptr);
18292 return nativeResponseValue;
18294 // void ChannelDetails_set_confirmations_required(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
18296 export function ChannelDetails_set_confirmations_required(this_ptr: number, val: number): void {
18297 if(!isWasmInitialized) {
18298 throw new Error("initializeWasm() must be awaited first!");
18300 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations_required(this_ptr, val);
18301 // debug statements here
18303 // struct LDKCOption_u16Z ChannelDetails_get_force_close_spend_delay(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18305 export function ChannelDetails_get_force_close_spend_delay(this_ptr: number): number {
18306 if(!isWasmInitialized) {
18307 throw new Error("initializeWasm() must be awaited first!");
18309 const nativeResponseValue = wasm.TS_ChannelDetails_get_force_close_spend_delay(this_ptr);
18310 return nativeResponseValue;
18312 // void ChannelDetails_set_force_close_spend_delay(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
18314 export function ChannelDetails_set_force_close_spend_delay(this_ptr: number, val: number): void {
18315 if(!isWasmInitialized) {
18316 throw new Error("initializeWasm() must be awaited first!");
18318 const nativeResponseValue = wasm.TS_ChannelDetails_set_force_close_spend_delay(this_ptr, val);
18319 // debug statements here
18321 // bool ChannelDetails_get_is_outbound(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18323 export function ChannelDetails_get_is_outbound(this_ptr: number): boolean {
18324 if(!isWasmInitialized) {
18325 throw new Error("initializeWasm() must be awaited first!");
18327 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_outbound(this_ptr);
18328 return nativeResponseValue;
18330 // void ChannelDetails_set_is_outbound(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
18332 export function ChannelDetails_set_is_outbound(this_ptr: number, val: boolean): void {
18333 if(!isWasmInitialized) {
18334 throw new Error("initializeWasm() must be awaited first!");
18336 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_outbound(this_ptr, val);
18337 // debug statements here
18339 // bool ChannelDetails_get_is_funding_locked(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18341 export function ChannelDetails_get_is_funding_locked(this_ptr: number): boolean {
18342 if(!isWasmInitialized) {
18343 throw new Error("initializeWasm() must be awaited first!");
18345 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_funding_locked(this_ptr);
18346 return nativeResponseValue;
18348 // void ChannelDetails_set_is_funding_locked(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
18350 export function ChannelDetails_set_is_funding_locked(this_ptr: number, val: boolean): void {
18351 if(!isWasmInitialized) {
18352 throw new Error("initializeWasm() must be awaited first!");
18354 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_funding_locked(this_ptr, val);
18355 // debug statements here
18357 // bool ChannelDetails_get_is_usable(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18359 export function ChannelDetails_get_is_usable(this_ptr: number): boolean {
18360 if(!isWasmInitialized) {
18361 throw new Error("initializeWasm() must be awaited first!");
18363 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_usable(this_ptr);
18364 return nativeResponseValue;
18366 // void ChannelDetails_set_is_usable(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
18368 export function ChannelDetails_set_is_usable(this_ptr: number, val: boolean): void {
18369 if(!isWasmInitialized) {
18370 throw new Error("initializeWasm() must be awaited first!");
18372 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_usable(this_ptr, val);
18373 // debug statements here
18375 // bool ChannelDetails_get_is_public(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18377 export function ChannelDetails_get_is_public(this_ptr: number): boolean {
18378 if(!isWasmInitialized) {
18379 throw new Error("initializeWasm() must be awaited first!");
18381 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_public(this_ptr);
18382 return nativeResponseValue;
18384 // void ChannelDetails_set_is_public(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
18386 export function ChannelDetails_set_is_public(this_ptr: number, val: boolean): void {
18387 if(!isWasmInitialized) {
18388 throw new Error("initializeWasm() must be awaited first!");
18390 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_public(this_ptr, val);
18391 // debug statements here
18393 // MUST_USE_RES struct LDKChannelDetails ChannelDetails_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKChannelCounterparty counterparty_arg, struct LDKOutPoint funding_txo_arg, struct LDKCOption_u64Z short_channel_id_arg, uint64_t channel_value_satoshis_arg, struct LDKCOption_u64Z unspendable_punishment_reserve_arg, uint64_t user_channel_id_arg, uint64_t balance_msat_arg, uint64_t outbound_capacity_msat_arg, uint64_t inbound_capacity_msat_arg, struct LDKCOption_u32Z confirmations_required_arg, struct LDKCOption_u16Z force_close_spend_delay_arg, bool is_outbound_arg, bool is_funding_locked_arg, bool is_usable_arg, bool is_public_arg);
18395 export function ChannelDetails_new(channel_id_arg: number, counterparty_arg: number, funding_txo_arg: number, short_channel_id_arg: number, channel_value_satoshis_arg: bigint, unspendable_punishment_reserve_arg: number, user_channel_id_arg: bigint, balance_msat_arg: bigint, outbound_capacity_msat_arg: bigint, inbound_capacity_msat_arg: bigint, confirmations_required_arg: number, force_close_spend_delay_arg: number, is_outbound_arg: boolean, is_funding_locked_arg: boolean, is_usable_arg: boolean, is_public_arg: boolean): number {
18396 if(!isWasmInitialized) {
18397 throw new Error("initializeWasm() must be awaited first!");
18399 const nativeResponseValue = wasm.TS_ChannelDetails_new(channel_id_arg, counterparty_arg, funding_txo_arg, short_channel_id_arg, channel_value_satoshis_arg, unspendable_punishment_reserve_arg, user_channel_id_arg, balance_msat_arg, outbound_capacity_msat_arg, inbound_capacity_msat_arg, confirmations_required_arg, force_close_spend_delay_arg, is_outbound_arg, is_funding_locked_arg, is_usable_arg, is_public_arg);
18400 return nativeResponseValue;
18402 // uintptr_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg);
18404 export function ChannelDetails_clone_ptr(arg: number): number {
18405 if(!isWasmInitialized) {
18406 throw new Error("initializeWasm() must be awaited first!");
18408 const nativeResponseValue = wasm.TS_ChannelDetails_clone_ptr(arg);
18409 return nativeResponseValue;
18411 // struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
18413 export function ChannelDetails_clone(orig: number): number {
18414 if(!isWasmInitialized) {
18415 throw new Error("initializeWasm() must be awaited first!");
18417 const nativeResponseValue = wasm.TS_ChannelDetails_clone(orig);
18418 return nativeResponseValue;
18420 // void PaymentSendFailure_free(struct LDKPaymentSendFailure this_ptr);
18422 export function PaymentSendFailure_free(this_ptr: number): void {
18423 if(!isWasmInitialized) {
18424 throw new Error("initializeWasm() must be awaited first!");
18426 const nativeResponseValue = wasm.TS_PaymentSendFailure_free(this_ptr);
18427 // debug statements here
18429 // uintptr_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg);
18431 export function PaymentSendFailure_clone_ptr(arg: number): number {
18432 if(!isWasmInitialized) {
18433 throw new Error("initializeWasm() must be awaited first!");
18435 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone_ptr(arg);
18436 return nativeResponseValue;
18438 // struct LDKPaymentSendFailure PaymentSendFailure_clone(const struct LDKPaymentSendFailure *NONNULL_PTR orig);
18440 export function PaymentSendFailure_clone(orig: number): number {
18441 if(!isWasmInitialized) {
18442 throw new Error("initializeWasm() must be awaited first!");
18444 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone(orig);
18445 return nativeResponseValue;
18447 // struct LDKPaymentSendFailure PaymentSendFailure_parameter_error(struct LDKAPIError a);
18449 export function PaymentSendFailure_parameter_error(a: number): number {
18450 if(!isWasmInitialized) {
18451 throw new Error("initializeWasm() must be awaited first!");
18453 const nativeResponseValue = wasm.TS_PaymentSendFailure_parameter_error(a);
18454 return nativeResponseValue;
18456 // struct LDKPaymentSendFailure PaymentSendFailure_path_parameter_error(struct LDKCVec_CResult_NoneAPIErrorZZ a);
18458 export function PaymentSendFailure_path_parameter_error(a: number): number {
18459 if(!isWasmInitialized) {
18460 throw new Error("initializeWasm() must be awaited first!");
18462 const nativeResponseValue = wasm.TS_PaymentSendFailure_path_parameter_error(a);
18463 return nativeResponseValue;
18465 // struct LDKPaymentSendFailure PaymentSendFailure_all_failed_retry_safe(struct LDKCVec_APIErrorZ a);
18467 export function PaymentSendFailure_all_failed_retry_safe(a: number): number {
18468 if(!isWasmInitialized) {
18469 throw new Error("initializeWasm() must be awaited first!");
18471 const nativeResponseValue = wasm.TS_PaymentSendFailure_all_failed_retry_safe(a);
18472 return nativeResponseValue;
18474 // struct LDKPaymentSendFailure PaymentSendFailure_partial_failure(struct LDKCVec_CResult_NoneAPIErrorZZ results, struct LDKRouteParameters failed_paths_retry, struct LDKThirtyTwoBytes payment_id);
18476 export function PaymentSendFailure_partial_failure(results: number, failed_paths_retry: number, payment_id: number): number {
18477 if(!isWasmInitialized) {
18478 throw new Error("initializeWasm() must be awaited first!");
18480 const nativeResponseValue = wasm.TS_PaymentSendFailure_partial_failure(results, failed_paths_retry, payment_id);
18481 return nativeResponseValue;
18483 // void PhantomRouteHints_free(struct LDKPhantomRouteHints this_obj);
18485 export function PhantomRouteHints_free(this_obj: number): void {
18486 if(!isWasmInitialized) {
18487 throw new Error("initializeWasm() must be awaited first!");
18489 const nativeResponseValue = wasm.TS_PhantomRouteHints_free(this_obj);
18490 // debug statements here
18492 // struct LDKCVec_ChannelDetailsZ PhantomRouteHints_get_channels(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
18494 export function PhantomRouteHints_get_channels(this_ptr: number): number {
18495 if(!isWasmInitialized) {
18496 throw new Error("initializeWasm() must be awaited first!");
18498 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_channels(this_ptr);
18499 return nativeResponseValue;
18501 // void PhantomRouteHints_set_channels(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKCVec_ChannelDetailsZ val);
18503 export function PhantomRouteHints_set_channels(this_ptr: number, val: number): void {
18504 if(!isWasmInitialized) {
18505 throw new Error("initializeWasm() must be awaited first!");
18507 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_channels(this_ptr, val);
18508 // debug statements here
18510 // uint64_t PhantomRouteHints_get_phantom_scid(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
18512 export function PhantomRouteHints_get_phantom_scid(this_ptr: number): bigint {
18513 if(!isWasmInitialized) {
18514 throw new Error("initializeWasm() must be awaited first!");
18516 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_phantom_scid(this_ptr);
18517 return nativeResponseValue;
18519 // void PhantomRouteHints_set_phantom_scid(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, uint64_t val);
18521 export function PhantomRouteHints_set_phantom_scid(this_ptr: number, val: bigint): void {
18522 if(!isWasmInitialized) {
18523 throw new Error("initializeWasm() must be awaited first!");
18525 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_phantom_scid(this_ptr, val);
18526 // debug statements here
18528 // struct LDKPublicKey PhantomRouteHints_get_real_node_pubkey(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
18530 export function PhantomRouteHints_get_real_node_pubkey(this_ptr: number): number {
18531 if(!isWasmInitialized) {
18532 throw new Error("initializeWasm() must be awaited first!");
18534 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_real_node_pubkey(this_ptr);
18535 return nativeResponseValue;
18537 // void PhantomRouteHints_set_real_node_pubkey(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKPublicKey val);
18539 export function PhantomRouteHints_set_real_node_pubkey(this_ptr: number, val: number): void {
18540 if(!isWasmInitialized) {
18541 throw new Error("initializeWasm() must be awaited first!");
18543 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_real_node_pubkey(this_ptr, val);
18544 // debug statements here
18546 // MUST_USE_RES struct LDKPhantomRouteHints PhantomRouteHints_new(struct LDKCVec_ChannelDetailsZ channels_arg, uint64_t phantom_scid_arg, struct LDKPublicKey real_node_pubkey_arg);
18548 export function PhantomRouteHints_new(channels_arg: number, phantom_scid_arg: bigint, real_node_pubkey_arg: number): number {
18549 if(!isWasmInitialized) {
18550 throw new Error("initializeWasm() must be awaited first!");
18552 const nativeResponseValue = wasm.TS_PhantomRouteHints_new(channels_arg, phantom_scid_arg, real_node_pubkey_arg);
18553 return nativeResponseValue;
18555 // uintptr_t PhantomRouteHints_clone_ptr(LDKPhantomRouteHints *NONNULL_PTR arg);
18557 export function PhantomRouteHints_clone_ptr(arg: number): number {
18558 if(!isWasmInitialized) {
18559 throw new Error("initializeWasm() must be awaited first!");
18561 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone_ptr(arg);
18562 return nativeResponseValue;
18564 // struct LDKPhantomRouteHints PhantomRouteHints_clone(const struct LDKPhantomRouteHints *NONNULL_PTR orig);
18566 export function PhantomRouteHints_clone(orig: number): number {
18567 if(!isWasmInitialized) {
18568 throw new Error("initializeWasm() must be awaited first!");
18570 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone(orig);
18571 return nativeResponseValue;
18573 // 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);
18575 export function ChannelManager_new(fee_est: number, chain_monitor: number, tx_broadcaster: number, logger: number, keys_manager: number, config: number, params: number): number {
18576 if(!isWasmInitialized) {
18577 throw new Error("initializeWasm() must be awaited first!");
18579 const nativeResponseValue = wasm.TS_ChannelManager_new(fee_est, chain_monitor, tx_broadcaster, logger, keys_manager, config, params);
18580 return nativeResponseValue;
18582 // MUST_USE_RES struct LDKUserConfig ChannelManager_get_current_default_configuration(const struct LDKChannelManager *NONNULL_PTR this_arg);
18584 export function ChannelManager_get_current_default_configuration(this_arg: number): number {
18585 if(!isWasmInitialized) {
18586 throw new Error("initializeWasm() must be awaited first!");
18588 const nativeResponseValue = wasm.TS_ChannelManager_get_current_default_configuration(this_arg);
18589 return nativeResponseValue;
18591 // 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);
18593 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 {
18594 if(!isWasmInitialized) {
18595 throw new Error("initializeWasm() must be awaited first!");
18597 const nativeResponseValue = wasm.TS_ChannelManager_create_channel(this_arg, their_network_key, channel_value_satoshis, push_msat, user_channel_id, override_config);
18598 return nativeResponseValue;
18600 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
18602 export function ChannelManager_list_channels(this_arg: number): number {
18603 if(!isWasmInitialized) {
18604 throw new Error("initializeWasm() must be awaited first!");
18606 const nativeResponseValue = wasm.TS_ChannelManager_list_channels(this_arg);
18607 return nativeResponseValue;
18609 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_usable_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
18611 export function ChannelManager_list_usable_channels(this_arg: number): number {
18612 if(!isWasmInitialized) {
18613 throw new Error("initializeWasm() must be awaited first!");
18615 const nativeResponseValue = wasm.TS_ChannelManager_list_usable_channels(this_arg);
18616 return nativeResponseValue;
18618 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_close_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32]);
18620 export function ChannelManager_close_channel(this_arg: number, channel_id: number): number {
18621 if(!isWasmInitialized) {
18622 throw new Error("initializeWasm() must be awaited first!");
18624 const nativeResponseValue = wasm.TS_ChannelManager_close_channel(this_arg, channel_id);
18625 return nativeResponseValue;
18627 // 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);
18629 export function ChannelManager_close_channel_with_target_feerate(this_arg: number, channel_id: number, target_feerate_sats_per_1000_weight: number): number {
18630 if(!isWasmInitialized) {
18631 throw new Error("initializeWasm() must be awaited first!");
18633 const nativeResponseValue = wasm.TS_ChannelManager_close_channel_with_target_feerate(this_arg, channel_id, target_feerate_sats_per_1000_weight);
18634 return nativeResponseValue;
18636 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_force_close_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32]);
18638 export function ChannelManager_force_close_channel(this_arg: number, channel_id: number): number {
18639 if(!isWasmInitialized) {
18640 throw new Error("initializeWasm() must be awaited first!");
18642 const nativeResponseValue = wasm.TS_ChannelManager_force_close_channel(this_arg, channel_id);
18643 return nativeResponseValue;
18645 // void ChannelManager_force_close_all_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
18647 export function ChannelManager_force_close_all_channels(this_arg: number): void {
18648 if(!isWasmInitialized) {
18649 throw new Error("initializeWasm() must be awaited first!");
18651 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels(this_arg);
18652 // debug statements here
18654 // 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);
18656 export function ChannelManager_send_payment(this_arg: number, route: number, payment_hash: number, payment_secret: number): number {
18657 if(!isWasmInitialized) {
18658 throw new Error("initializeWasm() must be awaited first!");
18660 const nativeResponseValue = wasm.TS_ChannelManager_send_payment(this_arg, route, payment_hash, payment_secret);
18661 return nativeResponseValue;
18663 // 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);
18665 export function ChannelManager_retry_payment(this_arg: number, route: number, payment_id: number): number {
18666 if(!isWasmInitialized) {
18667 throw new Error("initializeWasm() must be awaited first!");
18669 const nativeResponseValue = wasm.TS_ChannelManager_retry_payment(this_arg, route, payment_id);
18670 return nativeResponseValue;
18672 // void ChannelManager_abandon_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id);
18674 export function ChannelManager_abandon_payment(this_arg: number, payment_id: number): void {
18675 if(!isWasmInitialized) {
18676 throw new Error("initializeWasm() must be awaited first!");
18678 const nativeResponseValue = wasm.TS_ChannelManager_abandon_payment(this_arg, payment_id);
18679 // debug statements here
18681 // 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);
18683 export function ChannelManager_send_spontaneous_payment(this_arg: number, route: number, payment_preimage: number): number {
18684 if(!isWasmInitialized) {
18685 throw new Error("initializeWasm() must be awaited first!");
18687 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment(this_arg, route, payment_preimage);
18688 return nativeResponseValue;
18690 // 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);
18692 export function ChannelManager_funding_transaction_generated(this_arg: number, temporary_channel_id: number, funding_transaction: number): number {
18693 if(!isWasmInitialized) {
18694 throw new Error("initializeWasm() must be awaited first!");
18696 const nativeResponseValue = wasm.TS_ChannelManager_funding_transaction_generated(this_arg, temporary_channel_id, funding_transaction);
18697 return nativeResponseValue;
18699 // void ChannelManager_broadcast_node_announcement(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThreeBytes rgb, struct LDKThirtyTwoBytes alias, struct LDKCVec_NetAddressZ addresses);
18701 export function ChannelManager_broadcast_node_announcement(this_arg: number, rgb: number, alias: number, addresses: number): void {
18702 if(!isWasmInitialized) {
18703 throw new Error("initializeWasm() must be awaited first!");
18705 const nativeResponseValue = wasm.TS_ChannelManager_broadcast_node_announcement(this_arg, rgb, alias, addresses);
18706 // debug statements here
18708 // void ChannelManager_process_pending_htlc_forwards(const struct LDKChannelManager *NONNULL_PTR this_arg);
18710 export function ChannelManager_process_pending_htlc_forwards(this_arg: number): void {
18711 if(!isWasmInitialized) {
18712 throw new Error("initializeWasm() must be awaited first!");
18714 const nativeResponseValue = wasm.TS_ChannelManager_process_pending_htlc_forwards(this_arg);
18715 // debug statements here
18717 // void ChannelManager_timer_tick_occurred(const struct LDKChannelManager *NONNULL_PTR this_arg);
18719 export function ChannelManager_timer_tick_occurred(this_arg: number): void {
18720 if(!isWasmInitialized) {
18721 throw new Error("initializeWasm() must be awaited first!");
18723 const nativeResponseValue = wasm.TS_ChannelManager_timer_tick_occurred(this_arg);
18724 // debug statements here
18726 // MUST_USE_RES bool ChannelManager_fail_htlc_backwards(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
18728 export function ChannelManager_fail_htlc_backwards(this_arg: number, payment_hash: number): boolean {
18729 if(!isWasmInitialized) {
18730 throw new Error("initializeWasm() must be awaited first!");
18732 const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards(this_arg, payment_hash);
18733 return nativeResponseValue;
18735 // MUST_USE_RES bool ChannelManager_claim_funds(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
18737 export function ChannelManager_claim_funds(this_arg: number, payment_preimage: number): boolean {
18738 if(!isWasmInitialized) {
18739 throw new Error("initializeWasm() must be awaited first!");
18741 const nativeResponseValue = wasm.TS_ChannelManager_claim_funds(this_arg, payment_preimage);
18742 return nativeResponseValue;
18744 // MUST_USE_RES struct LDKPublicKey ChannelManager_get_our_node_id(const struct LDKChannelManager *NONNULL_PTR this_arg);
18746 export function ChannelManager_get_our_node_id(this_arg: number): number {
18747 if(!isWasmInitialized) {
18748 throw new Error("initializeWasm() must be awaited first!");
18750 const nativeResponseValue = wasm.TS_ChannelManager_get_our_node_id(this_arg);
18751 return nativeResponseValue;
18753 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_accept_inbound_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*temporary_channel_id)[32]);
18755 export function ChannelManager_accept_inbound_channel(this_arg: number, temporary_channel_id: number): number {
18756 if(!isWasmInitialized) {
18757 throw new Error("initializeWasm() must be awaited first!");
18759 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel(this_arg, temporary_channel_id);
18760 return nativeResponseValue;
18762 // 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);
18764 export function ChannelManager_create_inbound_payment(this_arg: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
18765 if(!isWasmInitialized) {
18766 throw new Error("initializeWasm() must be awaited first!");
18768 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment(this_arg, min_value_msat, invoice_expiry_delta_secs);
18769 return nativeResponseValue;
18771 // 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);
18773 export function ChannelManager_create_inbound_payment_legacy(this_arg: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
18774 if(!isWasmInitialized) {
18775 throw new Error("initializeWasm() must be awaited first!");
18777 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_legacy(this_arg, min_value_msat, invoice_expiry_delta_secs);
18778 return nativeResponseValue;
18780 // 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);
18782 export function ChannelManager_create_inbound_payment_for_hash(this_arg: number, payment_hash: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
18783 if(!isWasmInitialized) {
18784 throw new Error("initializeWasm() must be awaited first!");
18786 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
18787 return nativeResponseValue;
18789 // 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);
18791 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 {
18792 if(!isWasmInitialized) {
18793 throw new Error("initializeWasm() must be awaited first!");
18795 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash_legacy(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
18796 return nativeResponseValue;
18798 // 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);
18800 export function ChannelManager_get_payment_preimage(this_arg: number, payment_hash: number, payment_secret: number): number {
18801 if(!isWasmInitialized) {
18802 throw new Error("initializeWasm() must be awaited first!");
18804 const nativeResponseValue = wasm.TS_ChannelManager_get_payment_preimage(this_arg, payment_hash, payment_secret);
18805 return nativeResponseValue;
18807 // MUST_USE_RES uint64_t ChannelManager_get_phantom_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
18809 export function ChannelManager_get_phantom_scid(this_arg: number): bigint {
18810 if(!isWasmInitialized) {
18811 throw new Error("initializeWasm() must be awaited first!");
18813 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_scid(this_arg);
18814 return nativeResponseValue;
18816 // MUST_USE_RES struct LDKPhantomRouteHints ChannelManager_get_phantom_route_hints(const struct LDKChannelManager *NONNULL_PTR this_arg);
18818 export function ChannelManager_get_phantom_route_hints(this_arg: number): number {
18819 if(!isWasmInitialized) {
18820 throw new Error("initializeWasm() must be awaited first!");
18822 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_route_hints(this_arg);
18823 return nativeResponseValue;
18825 // struct LDKMessageSendEventsProvider ChannelManager_as_MessageSendEventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
18827 export function ChannelManager_as_MessageSendEventsProvider(this_arg: number): number {
18828 if(!isWasmInitialized) {
18829 throw new Error("initializeWasm() must be awaited first!");
18831 const nativeResponseValue = wasm.TS_ChannelManager_as_MessageSendEventsProvider(this_arg);
18832 return nativeResponseValue;
18834 // struct LDKEventsProvider ChannelManager_as_EventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
18836 export function ChannelManager_as_EventsProvider(this_arg: number): number {
18837 if(!isWasmInitialized) {
18838 throw new Error("initializeWasm() must be awaited first!");
18840 const nativeResponseValue = wasm.TS_ChannelManager_as_EventsProvider(this_arg);
18841 return nativeResponseValue;
18843 // struct LDKListen ChannelManager_as_Listen(const struct LDKChannelManager *NONNULL_PTR this_arg);
18845 export function ChannelManager_as_Listen(this_arg: number): number {
18846 if(!isWasmInitialized) {
18847 throw new Error("initializeWasm() must be awaited first!");
18849 const nativeResponseValue = wasm.TS_ChannelManager_as_Listen(this_arg);
18850 return nativeResponseValue;
18852 // struct LDKConfirm ChannelManager_as_Confirm(const struct LDKChannelManager *NONNULL_PTR this_arg);
18854 export function ChannelManager_as_Confirm(this_arg: number): number {
18855 if(!isWasmInitialized) {
18856 throw new Error("initializeWasm() must be awaited first!");
18858 const nativeResponseValue = wasm.TS_ChannelManager_as_Confirm(this_arg);
18859 return nativeResponseValue;
18861 // void ChannelManager_await_persistable_update(const struct LDKChannelManager *NONNULL_PTR this_arg);
18863 export function ChannelManager_await_persistable_update(this_arg: number): void {
18864 if(!isWasmInitialized) {
18865 throw new Error("initializeWasm() must be awaited first!");
18867 const nativeResponseValue = wasm.TS_ChannelManager_await_persistable_update(this_arg);
18868 // debug statements here
18870 // MUST_USE_RES struct LDKBestBlock ChannelManager_current_best_block(const struct LDKChannelManager *NONNULL_PTR this_arg);
18872 export function ChannelManager_current_best_block(this_arg: number): number {
18873 if(!isWasmInitialized) {
18874 throw new Error("initializeWasm() must be awaited first!");
18876 const nativeResponseValue = wasm.TS_ChannelManager_current_best_block(this_arg);
18877 return nativeResponseValue;
18879 // struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
18881 export function ChannelManager_as_ChannelMessageHandler(this_arg: number): number {
18882 if(!isWasmInitialized) {
18883 throw new Error("initializeWasm() must be awaited first!");
18885 const nativeResponseValue = wasm.TS_ChannelManager_as_ChannelMessageHandler(this_arg);
18886 return nativeResponseValue;
18888 // struct LDKCVec_u8Z CounterpartyForwardingInfo_write(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR obj);
18890 export function CounterpartyForwardingInfo_write(obj: number): number {
18891 if(!isWasmInitialized) {
18892 throw new Error("initializeWasm() must be awaited first!");
18894 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_write(obj);
18895 return nativeResponseValue;
18897 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CounterpartyForwardingInfo_read(struct LDKu8slice ser);
18899 export function CounterpartyForwardingInfo_read(ser: number): number {
18900 if(!isWasmInitialized) {
18901 throw new Error("initializeWasm() must be awaited first!");
18903 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_read(ser);
18904 return nativeResponseValue;
18906 // struct LDKCVec_u8Z ChannelCounterparty_write(const struct LDKChannelCounterparty *NONNULL_PTR obj);
18908 export function ChannelCounterparty_write(obj: number): number {
18909 if(!isWasmInitialized) {
18910 throw new Error("initializeWasm() must be awaited first!");
18912 const nativeResponseValue = wasm.TS_ChannelCounterparty_write(obj);
18913 return nativeResponseValue;
18915 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ ChannelCounterparty_read(struct LDKu8slice ser);
18917 export function ChannelCounterparty_read(ser: number): number {
18918 if(!isWasmInitialized) {
18919 throw new Error("initializeWasm() must be awaited first!");
18921 const nativeResponseValue = wasm.TS_ChannelCounterparty_read(ser);
18922 return nativeResponseValue;
18924 // struct LDKCVec_u8Z ChannelDetails_write(const struct LDKChannelDetails *NONNULL_PTR obj);
18926 export function ChannelDetails_write(obj: number): number {
18927 if(!isWasmInitialized) {
18928 throw new Error("initializeWasm() must be awaited first!");
18930 const nativeResponseValue = wasm.TS_ChannelDetails_write(obj);
18931 return nativeResponseValue;
18933 // struct LDKCResult_ChannelDetailsDecodeErrorZ ChannelDetails_read(struct LDKu8slice ser);
18935 export function ChannelDetails_read(ser: number): number {
18936 if(!isWasmInitialized) {
18937 throw new Error("initializeWasm() must be awaited first!");
18939 const nativeResponseValue = wasm.TS_ChannelDetails_read(ser);
18940 return nativeResponseValue;
18942 // struct LDKCVec_u8Z PhantomRouteHints_write(const struct LDKPhantomRouteHints *NONNULL_PTR obj);
18944 export function PhantomRouteHints_write(obj: number): number {
18945 if(!isWasmInitialized) {
18946 throw new Error("initializeWasm() must be awaited first!");
18948 const nativeResponseValue = wasm.TS_PhantomRouteHints_write(obj);
18949 return nativeResponseValue;
18951 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ PhantomRouteHints_read(struct LDKu8slice ser);
18953 export function PhantomRouteHints_read(ser: number): number {
18954 if(!isWasmInitialized) {
18955 throw new Error("initializeWasm() must be awaited first!");
18957 const nativeResponseValue = wasm.TS_PhantomRouteHints_read(ser);
18958 return nativeResponseValue;
18960 // struct LDKCVec_u8Z ChannelManager_write(const struct LDKChannelManager *NONNULL_PTR obj);
18962 export function ChannelManager_write(obj: number): number {
18963 if(!isWasmInitialized) {
18964 throw new Error("initializeWasm() must be awaited first!");
18966 const nativeResponseValue = wasm.TS_ChannelManager_write(obj);
18967 return nativeResponseValue;
18969 // void ChannelManagerReadArgs_free(struct LDKChannelManagerReadArgs this_obj);
18971 export function ChannelManagerReadArgs_free(this_obj: number): void {
18972 if(!isWasmInitialized) {
18973 throw new Error("initializeWasm() must be awaited first!");
18975 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_free(this_obj);
18976 // debug statements here
18978 // const struct LDKKeysInterface *ChannelManagerReadArgs_get_keys_manager(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
18980 export function ChannelManagerReadArgs_get_keys_manager(this_ptr: number): number {
18981 if(!isWasmInitialized) {
18982 throw new Error("initializeWasm() must be awaited first!");
18984 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_keys_manager(this_ptr);
18985 return nativeResponseValue;
18987 // void ChannelManagerReadArgs_set_keys_manager(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKKeysInterface val);
18989 export function ChannelManagerReadArgs_set_keys_manager(this_ptr: number, val: number): void {
18990 if(!isWasmInitialized) {
18991 throw new Error("initializeWasm() must be awaited first!");
18993 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_keys_manager(this_ptr, val);
18994 // debug statements here
18996 // const struct LDKFeeEstimator *ChannelManagerReadArgs_get_fee_estimator(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
18998 export function ChannelManagerReadArgs_get_fee_estimator(this_ptr: number): number {
18999 if(!isWasmInitialized) {
19000 throw new Error("initializeWasm() must be awaited first!");
19002 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_fee_estimator(this_ptr);
19003 return nativeResponseValue;
19005 // void ChannelManagerReadArgs_set_fee_estimator(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKFeeEstimator val);
19007 export function ChannelManagerReadArgs_set_fee_estimator(this_ptr: number, val: number): void {
19008 if(!isWasmInitialized) {
19009 throw new Error("initializeWasm() must be awaited first!");
19011 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_fee_estimator(this_ptr, val);
19012 // debug statements here
19014 // const struct LDKWatch *ChannelManagerReadArgs_get_chain_monitor(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19016 export function ChannelManagerReadArgs_get_chain_monitor(this_ptr: number): number {
19017 if(!isWasmInitialized) {
19018 throw new Error("initializeWasm() must be awaited first!");
19020 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_chain_monitor(this_ptr);
19021 return nativeResponseValue;
19023 // void ChannelManagerReadArgs_set_chain_monitor(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKWatch val);
19025 export function ChannelManagerReadArgs_set_chain_monitor(this_ptr: number, val: number): void {
19026 if(!isWasmInitialized) {
19027 throw new Error("initializeWasm() must be awaited first!");
19029 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_chain_monitor(this_ptr, val);
19030 // debug statements here
19032 // const struct LDKBroadcasterInterface *ChannelManagerReadArgs_get_tx_broadcaster(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19034 export function ChannelManagerReadArgs_get_tx_broadcaster(this_ptr: number): number {
19035 if(!isWasmInitialized) {
19036 throw new Error("initializeWasm() must be awaited first!");
19038 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_tx_broadcaster(this_ptr);
19039 return nativeResponseValue;
19041 // void ChannelManagerReadArgs_set_tx_broadcaster(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKBroadcasterInterface val);
19043 export function ChannelManagerReadArgs_set_tx_broadcaster(this_ptr: number, val: number): void {
19044 if(!isWasmInitialized) {
19045 throw new Error("initializeWasm() must be awaited first!");
19047 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_tx_broadcaster(this_ptr, val);
19048 // debug statements here
19050 // const struct LDKLogger *ChannelManagerReadArgs_get_logger(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19052 export function ChannelManagerReadArgs_get_logger(this_ptr: number): number {
19053 if(!isWasmInitialized) {
19054 throw new Error("initializeWasm() must be awaited first!");
19056 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_logger(this_ptr);
19057 return nativeResponseValue;
19059 // void ChannelManagerReadArgs_set_logger(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKLogger val);
19061 export function ChannelManagerReadArgs_set_logger(this_ptr: number, val: number): void {
19062 if(!isWasmInitialized) {
19063 throw new Error("initializeWasm() must be awaited first!");
19065 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_logger(this_ptr, val);
19066 // debug statements here
19068 // struct LDKUserConfig ChannelManagerReadArgs_get_default_config(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19070 export function ChannelManagerReadArgs_get_default_config(this_ptr: number): number {
19071 if(!isWasmInitialized) {
19072 throw new Error("initializeWasm() must be awaited first!");
19074 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_default_config(this_ptr);
19075 return nativeResponseValue;
19077 // void ChannelManagerReadArgs_set_default_config(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKUserConfig val);
19079 export function ChannelManagerReadArgs_set_default_config(this_ptr: number, val: number): void {
19080 if(!isWasmInitialized) {
19081 throw new Error("initializeWasm() must be awaited first!");
19083 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_default_config(this_ptr, val);
19084 // debug statements here
19086 // 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);
19088 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 {
19089 if(!isWasmInitialized) {
19090 throw new Error("initializeWasm() must be awaited first!");
19092 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_new(keys_manager, fee_estimator, chain_monitor, tx_broadcaster, logger, default_config, channel_monitors);
19093 return nativeResponseValue;
19095 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ C2Tuple_BlockHashChannelManagerZ_read(struct LDKu8slice ser, struct LDKChannelManagerReadArgs arg);
19097 export function C2Tuple_BlockHashChannelManagerZ_read(ser: number, arg: number): number {
19098 if(!isWasmInitialized) {
19099 throw new Error("initializeWasm() must be awaited first!");
19101 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_read(ser, arg);
19102 return nativeResponseValue;
19104 // void DecodeError_free(struct LDKDecodeError this_obj);
19106 export function DecodeError_free(this_obj: number): void {
19107 if(!isWasmInitialized) {
19108 throw new Error("initializeWasm() must be awaited first!");
19110 const nativeResponseValue = wasm.TS_DecodeError_free(this_obj);
19111 // debug statements here
19113 // uintptr_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg);
19115 export function DecodeError_clone_ptr(arg: number): number {
19116 if(!isWasmInitialized) {
19117 throw new Error("initializeWasm() must be awaited first!");
19119 const nativeResponseValue = wasm.TS_DecodeError_clone_ptr(arg);
19120 return nativeResponseValue;
19122 // struct LDKDecodeError DecodeError_clone(const struct LDKDecodeError *NONNULL_PTR orig);
19124 export function DecodeError_clone(orig: number): number {
19125 if(!isWasmInitialized) {
19126 throw new Error("initializeWasm() must be awaited first!");
19128 const nativeResponseValue = wasm.TS_DecodeError_clone(orig);
19129 return nativeResponseValue;
19131 // void Init_free(struct LDKInit this_obj);
19133 export function Init_free(this_obj: number): void {
19134 if(!isWasmInitialized) {
19135 throw new Error("initializeWasm() must be awaited first!");
19137 const nativeResponseValue = wasm.TS_Init_free(this_obj);
19138 // debug statements here
19140 // struct LDKInitFeatures Init_get_features(const struct LDKInit *NONNULL_PTR this_ptr);
19142 export function Init_get_features(this_ptr: number): number {
19143 if(!isWasmInitialized) {
19144 throw new Error("initializeWasm() must be awaited first!");
19146 const nativeResponseValue = wasm.TS_Init_get_features(this_ptr);
19147 return nativeResponseValue;
19149 // void Init_set_features(struct LDKInit *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
19151 export function Init_set_features(this_ptr: number, val: number): void {
19152 if(!isWasmInitialized) {
19153 throw new Error("initializeWasm() must be awaited first!");
19155 const nativeResponseValue = wasm.TS_Init_set_features(this_ptr, val);
19156 // debug statements here
19158 // MUST_USE_RES struct LDKInit Init_new(struct LDKInitFeatures features_arg);
19160 export function Init_new(features_arg: number): number {
19161 if(!isWasmInitialized) {
19162 throw new Error("initializeWasm() must be awaited first!");
19164 const nativeResponseValue = wasm.TS_Init_new(features_arg);
19165 return nativeResponseValue;
19167 // uintptr_t Init_clone_ptr(LDKInit *NONNULL_PTR arg);
19169 export function Init_clone_ptr(arg: number): number {
19170 if(!isWasmInitialized) {
19171 throw new Error("initializeWasm() must be awaited first!");
19173 const nativeResponseValue = wasm.TS_Init_clone_ptr(arg);
19174 return nativeResponseValue;
19176 // struct LDKInit Init_clone(const struct LDKInit *NONNULL_PTR orig);
19178 export function Init_clone(orig: number): number {
19179 if(!isWasmInitialized) {
19180 throw new Error("initializeWasm() must be awaited first!");
19182 const nativeResponseValue = wasm.TS_Init_clone(orig);
19183 return nativeResponseValue;
19185 // void ErrorMessage_free(struct LDKErrorMessage this_obj);
19187 export function ErrorMessage_free(this_obj: number): void {
19188 if(!isWasmInitialized) {
19189 throw new Error("initializeWasm() must be awaited first!");
19191 const nativeResponseValue = wasm.TS_ErrorMessage_free(this_obj);
19192 // debug statements here
19194 // const uint8_t (*ErrorMessage_get_channel_id(const struct LDKErrorMessage *NONNULL_PTR this_ptr))[32];
19196 export function ErrorMessage_get_channel_id(this_ptr: number): number {
19197 if(!isWasmInitialized) {
19198 throw new Error("initializeWasm() must be awaited first!");
19200 const nativeResponseValue = wasm.TS_ErrorMessage_get_channel_id(this_ptr);
19201 return nativeResponseValue;
19203 // void ErrorMessage_set_channel_id(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19205 export function ErrorMessage_set_channel_id(this_ptr: number, val: number): void {
19206 if(!isWasmInitialized) {
19207 throw new Error("initializeWasm() must be awaited first!");
19209 const nativeResponseValue = wasm.TS_ErrorMessage_set_channel_id(this_ptr, val);
19210 // debug statements here
19212 // struct LDKStr ErrorMessage_get_data(const struct LDKErrorMessage *NONNULL_PTR this_ptr);
19214 export function ErrorMessage_get_data(this_ptr: number): number {
19215 if(!isWasmInitialized) {
19216 throw new Error("initializeWasm() must be awaited first!");
19218 const nativeResponseValue = wasm.TS_ErrorMessage_get_data(this_ptr);
19219 return nativeResponseValue;
19221 // void ErrorMessage_set_data(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKStr val);
19223 export function ErrorMessage_set_data(this_ptr: number, val: number): void {
19224 if(!isWasmInitialized) {
19225 throw new Error("initializeWasm() must be awaited first!");
19227 const nativeResponseValue = wasm.TS_ErrorMessage_set_data(this_ptr, val);
19228 // debug statements here
19230 // MUST_USE_RES struct LDKErrorMessage ErrorMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
19232 export function ErrorMessage_new(channel_id_arg: number, data_arg: number): number {
19233 if(!isWasmInitialized) {
19234 throw new Error("initializeWasm() must be awaited first!");
19236 const nativeResponseValue = wasm.TS_ErrorMessage_new(channel_id_arg, data_arg);
19237 return nativeResponseValue;
19239 // uintptr_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg);
19241 export function ErrorMessage_clone_ptr(arg: number): number {
19242 if(!isWasmInitialized) {
19243 throw new Error("initializeWasm() must be awaited first!");
19245 const nativeResponseValue = wasm.TS_ErrorMessage_clone_ptr(arg);
19246 return nativeResponseValue;
19248 // struct LDKErrorMessage ErrorMessage_clone(const struct LDKErrorMessage *NONNULL_PTR orig);
19250 export function ErrorMessage_clone(orig: number): number {
19251 if(!isWasmInitialized) {
19252 throw new Error("initializeWasm() must be awaited first!");
19254 const nativeResponseValue = wasm.TS_ErrorMessage_clone(orig);
19255 return nativeResponseValue;
19257 // void WarningMessage_free(struct LDKWarningMessage this_obj);
19259 export function WarningMessage_free(this_obj: number): void {
19260 if(!isWasmInitialized) {
19261 throw new Error("initializeWasm() must be awaited first!");
19263 const nativeResponseValue = wasm.TS_WarningMessage_free(this_obj);
19264 // debug statements here
19266 // const uint8_t (*WarningMessage_get_channel_id(const struct LDKWarningMessage *NONNULL_PTR this_ptr))[32];
19268 export function WarningMessage_get_channel_id(this_ptr: number): number {
19269 if(!isWasmInitialized) {
19270 throw new Error("initializeWasm() must be awaited first!");
19272 const nativeResponseValue = wasm.TS_WarningMessage_get_channel_id(this_ptr);
19273 return nativeResponseValue;
19275 // void WarningMessage_set_channel_id(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19277 export function WarningMessage_set_channel_id(this_ptr: number, val: number): void {
19278 if(!isWasmInitialized) {
19279 throw new Error("initializeWasm() must be awaited first!");
19281 const nativeResponseValue = wasm.TS_WarningMessage_set_channel_id(this_ptr, val);
19282 // debug statements here
19284 // struct LDKStr WarningMessage_get_data(const struct LDKWarningMessage *NONNULL_PTR this_ptr);
19286 export function WarningMessage_get_data(this_ptr: number): number {
19287 if(!isWasmInitialized) {
19288 throw new Error("initializeWasm() must be awaited first!");
19290 const nativeResponseValue = wasm.TS_WarningMessage_get_data(this_ptr);
19291 return nativeResponseValue;
19293 // void WarningMessage_set_data(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKStr val);
19295 export function WarningMessage_set_data(this_ptr: number, val: number): void {
19296 if(!isWasmInitialized) {
19297 throw new Error("initializeWasm() must be awaited first!");
19299 const nativeResponseValue = wasm.TS_WarningMessage_set_data(this_ptr, val);
19300 // debug statements here
19302 // MUST_USE_RES struct LDKWarningMessage WarningMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
19304 export function WarningMessage_new(channel_id_arg: number, data_arg: number): number {
19305 if(!isWasmInitialized) {
19306 throw new Error("initializeWasm() must be awaited first!");
19308 const nativeResponseValue = wasm.TS_WarningMessage_new(channel_id_arg, data_arg);
19309 return nativeResponseValue;
19311 // uintptr_t WarningMessage_clone_ptr(LDKWarningMessage *NONNULL_PTR arg);
19313 export function WarningMessage_clone_ptr(arg: number): number {
19314 if(!isWasmInitialized) {
19315 throw new Error("initializeWasm() must be awaited first!");
19317 const nativeResponseValue = wasm.TS_WarningMessage_clone_ptr(arg);
19318 return nativeResponseValue;
19320 // struct LDKWarningMessage WarningMessage_clone(const struct LDKWarningMessage *NONNULL_PTR orig);
19322 export function WarningMessage_clone(orig: number): number {
19323 if(!isWasmInitialized) {
19324 throw new Error("initializeWasm() must be awaited first!");
19326 const nativeResponseValue = wasm.TS_WarningMessage_clone(orig);
19327 return nativeResponseValue;
19329 // void Ping_free(struct LDKPing this_obj);
19331 export function Ping_free(this_obj: number): void {
19332 if(!isWasmInitialized) {
19333 throw new Error("initializeWasm() must be awaited first!");
19335 const nativeResponseValue = wasm.TS_Ping_free(this_obj);
19336 // debug statements here
19338 // uint16_t Ping_get_ponglen(const struct LDKPing *NONNULL_PTR this_ptr);
19340 export function Ping_get_ponglen(this_ptr: number): number {
19341 if(!isWasmInitialized) {
19342 throw new Error("initializeWasm() must be awaited first!");
19344 const nativeResponseValue = wasm.TS_Ping_get_ponglen(this_ptr);
19345 return nativeResponseValue;
19347 // void Ping_set_ponglen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
19349 export function Ping_set_ponglen(this_ptr: number, val: number): void {
19350 if(!isWasmInitialized) {
19351 throw new Error("initializeWasm() must be awaited first!");
19353 const nativeResponseValue = wasm.TS_Ping_set_ponglen(this_ptr, val);
19354 // debug statements here
19356 // uint16_t Ping_get_byteslen(const struct LDKPing *NONNULL_PTR this_ptr);
19358 export function Ping_get_byteslen(this_ptr: number): number {
19359 if(!isWasmInitialized) {
19360 throw new Error("initializeWasm() must be awaited first!");
19362 const nativeResponseValue = wasm.TS_Ping_get_byteslen(this_ptr);
19363 return nativeResponseValue;
19365 // void Ping_set_byteslen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
19367 export function Ping_set_byteslen(this_ptr: number, val: number): void {
19368 if(!isWasmInitialized) {
19369 throw new Error("initializeWasm() must be awaited first!");
19371 const nativeResponseValue = wasm.TS_Ping_set_byteslen(this_ptr, val);
19372 // debug statements here
19374 // MUST_USE_RES struct LDKPing Ping_new(uint16_t ponglen_arg, uint16_t byteslen_arg);
19376 export function Ping_new(ponglen_arg: number, byteslen_arg: number): number {
19377 if(!isWasmInitialized) {
19378 throw new Error("initializeWasm() must be awaited first!");
19380 const nativeResponseValue = wasm.TS_Ping_new(ponglen_arg, byteslen_arg);
19381 return nativeResponseValue;
19383 // uintptr_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg);
19385 export function Ping_clone_ptr(arg: number): number {
19386 if(!isWasmInitialized) {
19387 throw new Error("initializeWasm() must be awaited first!");
19389 const nativeResponseValue = wasm.TS_Ping_clone_ptr(arg);
19390 return nativeResponseValue;
19392 // struct LDKPing Ping_clone(const struct LDKPing *NONNULL_PTR orig);
19394 export function Ping_clone(orig: number): number {
19395 if(!isWasmInitialized) {
19396 throw new Error("initializeWasm() must be awaited first!");
19398 const nativeResponseValue = wasm.TS_Ping_clone(orig);
19399 return nativeResponseValue;
19401 // void Pong_free(struct LDKPong this_obj);
19403 export function Pong_free(this_obj: number): void {
19404 if(!isWasmInitialized) {
19405 throw new Error("initializeWasm() must be awaited first!");
19407 const nativeResponseValue = wasm.TS_Pong_free(this_obj);
19408 // debug statements here
19410 // uint16_t Pong_get_byteslen(const struct LDKPong *NONNULL_PTR this_ptr);
19412 export function Pong_get_byteslen(this_ptr: number): number {
19413 if(!isWasmInitialized) {
19414 throw new Error("initializeWasm() must be awaited first!");
19416 const nativeResponseValue = wasm.TS_Pong_get_byteslen(this_ptr);
19417 return nativeResponseValue;
19419 // void Pong_set_byteslen(struct LDKPong *NONNULL_PTR this_ptr, uint16_t val);
19421 export function Pong_set_byteslen(this_ptr: number, val: number): void {
19422 if(!isWasmInitialized) {
19423 throw new Error("initializeWasm() must be awaited first!");
19425 const nativeResponseValue = wasm.TS_Pong_set_byteslen(this_ptr, val);
19426 // debug statements here
19428 // MUST_USE_RES struct LDKPong Pong_new(uint16_t byteslen_arg);
19430 export function Pong_new(byteslen_arg: number): number {
19431 if(!isWasmInitialized) {
19432 throw new Error("initializeWasm() must be awaited first!");
19434 const nativeResponseValue = wasm.TS_Pong_new(byteslen_arg);
19435 return nativeResponseValue;
19437 // uintptr_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg);
19439 export function Pong_clone_ptr(arg: number): number {
19440 if(!isWasmInitialized) {
19441 throw new Error("initializeWasm() must be awaited first!");
19443 const nativeResponseValue = wasm.TS_Pong_clone_ptr(arg);
19444 return nativeResponseValue;
19446 // struct LDKPong Pong_clone(const struct LDKPong *NONNULL_PTR orig);
19448 export function Pong_clone(orig: number): number {
19449 if(!isWasmInitialized) {
19450 throw new Error("initializeWasm() must be awaited first!");
19452 const nativeResponseValue = wasm.TS_Pong_clone(orig);
19453 return nativeResponseValue;
19455 // void OpenChannel_free(struct LDKOpenChannel this_obj);
19457 export function OpenChannel_free(this_obj: number): void {
19458 if(!isWasmInitialized) {
19459 throw new Error("initializeWasm() must be awaited first!");
19461 const nativeResponseValue = wasm.TS_OpenChannel_free(this_obj);
19462 // debug statements here
19464 // const uint8_t (*OpenChannel_get_chain_hash(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
19466 export function OpenChannel_get_chain_hash(this_ptr: number): number {
19467 if(!isWasmInitialized) {
19468 throw new Error("initializeWasm() must be awaited first!");
19470 const nativeResponseValue = wasm.TS_OpenChannel_get_chain_hash(this_ptr);
19471 return nativeResponseValue;
19473 // void OpenChannel_set_chain_hash(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19475 export function OpenChannel_set_chain_hash(this_ptr: number, val: number): void {
19476 if(!isWasmInitialized) {
19477 throw new Error("initializeWasm() must be awaited first!");
19479 const nativeResponseValue = wasm.TS_OpenChannel_set_chain_hash(this_ptr, val);
19480 // debug statements here
19482 // const uint8_t (*OpenChannel_get_temporary_channel_id(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
19484 export function OpenChannel_get_temporary_channel_id(this_ptr: number): number {
19485 if(!isWasmInitialized) {
19486 throw new Error("initializeWasm() must be awaited first!");
19488 const nativeResponseValue = wasm.TS_OpenChannel_get_temporary_channel_id(this_ptr);
19489 return nativeResponseValue;
19491 // void OpenChannel_set_temporary_channel_id(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19493 export function OpenChannel_set_temporary_channel_id(this_ptr: number, val: number): void {
19494 if(!isWasmInitialized) {
19495 throw new Error("initializeWasm() must be awaited first!");
19497 const nativeResponseValue = wasm.TS_OpenChannel_set_temporary_channel_id(this_ptr, val);
19498 // debug statements here
19500 // uint64_t OpenChannel_get_funding_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19502 export function OpenChannel_get_funding_satoshis(this_ptr: number): bigint {
19503 if(!isWasmInitialized) {
19504 throw new Error("initializeWasm() must be awaited first!");
19506 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_satoshis(this_ptr);
19507 return nativeResponseValue;
19509 // void OpenChannel_set_funding_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
19511 export function OpenChannel_set_funding_satoshis(this_ptr: number, val: bigint): void {
19512 if(!isWasmInitialized) {
19513 throw new Error("initializeWasm() must be awaited first!");
19515 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_satoshis(this_ptr, val);
19516 // debug statements here
19518 // uint64_t OpenChannel_get_push_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19520 export function OpenChannel_get_push_msat(this_ptr: number): bigint {
19521 if(!isWasmInitialized) {
19522 throw new Error("initializeWasm() must be awaited first!");
19524 const nativeResponseValue = wasm.TS_OpenChannel_get_push_msat(this_ptr);
19525 return nativeResponseValue;
19527 // void OpenChannel_set_push_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
19529 export function OpenChannel_set_push_msat(this_ptr: number, val: bigint): void {
19530 if(!isWasmInitialized) {
19531 throw new Error("initializeWasm() must be awaited first!");
19533 const nativeResponseValue = wasm.TS_OpenChannel_set_push_msat(this_ptr, val);
19534 // debug statements here
19536 // uint64_t OpenChannel_get_dust_limit_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19538 export function OpenChannel_get_dust_limit_satoshis(this_ptr: number): bigint {
19539 if(!isWasmInitialized) {
19540 throw new Error("initializeWasm() must be awaited first!");
19542 const nativeResponseValue = wasm.TS_OpenChannel_get_dust_limit_satoshis(this_ptr);
19543 return nativeResponseValue;
19545 // void OpenChannel_set_dust_limit_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
19547 export function OpenChannel_set_dust_limit_satoshis(this_ptr: number, val: bigint): void {
19548 if(!isWasmInitialized) {
19549 throw new Error("initializeWasm() must be awaited first!");
19551 const nativeResponseValue = wasm.TS_OpenChannel_set_dust_limit_satoshis(this_ptr, val);
19552 // debug statements here
19554 // uint64_t OpenChannel_get_max_htlc_value_in_flight_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19556 export function OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
19557 if(!isWasmInitialized) {
19558 throw new Error("initializeWasm() must be awaited first!");
19560 const nativeResponseValue = wasm.TS_OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr);
19561 return nativeResponseValue;
19563 // void OpenChannel_set_max_htlc_value_in_flight_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
19565 export function OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
19566 if(!isWasmInitialized) {
19567 throw new Error("initializeWasm() must be awaited first!");
19569 const nativeResponseValue = wasm.TS_OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
19570 // debug statements here
19572 // uint64_t OpenChannel_get_channel_reserve_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19574 export function OpenChannel_get_channel_reserve_satoshis(this_ptr: number): bigint {
19575 if(!isWasmInitialized) {
19576 throw new Error("initializeWasm() must be awaited first!");
19578 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_reserve_satoshis(this_ptr);
19579 return nativeResponseValue;
19581 // void OpenChannel_set_channel_reserve_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
19583 export function OpenChannel_set_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
19584 if(!isWasmInitialized) {
19585 throw new Error("initializeWasm() must be awaited first!");
19587 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_reserve_satoshis(this_ptr, val);
19588 // debug statements here
19590 // uint64_t OpenChannel_get_htlc_minimum_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19592 export function OpenChannel_get_htlc_minimum_msat(this_ptr: number): bigint {
19593 if(!isWasmInitialized) {
19594 throw new Error("initializeWasm() must be awaited first!");
19596 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_minimum_msat(this_ptr);
19597 return nativeResponseValue;
19599 // void OpenChannel_set_htlc_minimum_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
19601 export function OpenChannel_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
19602 if(!isWasmInitialized) {
19603 throw new Error("initializeWasm() must be awaited first!");
19605 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_minimum_msat(this_ptr, val);
19606 // debug statements here
19608 // uint32_t OpenChannel_get_feerate_per_kw(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19610 export function OpenChannel_get_feerate_per_kw(this_ptr: number): number {
19611 if(!isWasmInitialized) {
19612 throw new Error("initializeWasm() must be awaited first!");
19614 const nativeResponseValue = wasm.TS_OpenChannel_get_feerate_per_kw(this_ptr);
19615 return nativeResponseValue;
19617 // void OpenChannel_set_feerate_per_kw(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint32_t val);
19619 export function OpenChannel_set_feerate_per_kw(this_ptr: number, val: number): void {
19620 if(!isWasmInitialized) {
19621 throw new Error("initializeWasm() must be awaited first!");
19623 const nativeResponseValue = wasm.TS_OpenChannel_set_feerate_per_kw(this_ptr, val);
19624 // debug statements here
19626 // uint16_t OpenChannel_get_to_self_delay(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19628 export function OpenChannel_get_to_self_delay(this_ptr: number): number {
19629 if(!isWasmInitialized) {
19630 throw new Error("initializeWasm() must be awaited first!");
19632 const nativeResponseValue = wasm.TS_OpenChannel_get_to_self_delay(this_ptr);
19633 return nativeResponseValue;
19635 // void OpenChannel_set_to_self_delay(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
19637 export function OpenChannel_set_to_self_delay(this_ptr: number, val: number): void {
19638 if(!isWasmInitialized) {
19639 throw new Error("initializeWasm() must be awaited first!");
19641 const nativeResponseValue = wasm.TS_OpenChannel_set_to_self_delay(this_ptr, val);
19642 // debug statements here
19644 // uint16_t OpenChannel_get_max_accepted_htlcs(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19646 export function OpenChannel_get_max_accepted_htlcs(this_ptr: number): number {
19647 if(!isWasmInitialized) {
19648 throw new Error("initializeWasm() must be awaited first!");
19650 const nativeResponseValue = wasm.TS_OpenChannel_get_max_accepted_htlcs(this_ptr);
19651 return nativeResponseValue;
19653 // void OpenChannel_set_max_accepted_htlcs(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
19655 export function OpenChannel_set_max_accepted_htlcs(this_ptr: number, val: number): void {
19656 if(!isWasmInitialized) {
19657 throw new Error("initializeWasm() must be awaited first!");
19659 const nativeResponseValue = wasm.TS_OpenChannel_set_max_accepted_htlcs(this_ptr, val);
19660 // debug statements here
19662 // struct LDKPublicKey OpenChannel_get_funding_pubkey(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19664 export function OpenChannel_get_funding_pubkey(this_ptr: number): number {
19665 if(!isWasmInitialized) {
19666 throw new Error("initializeWasm() must be awaited first!");
19668 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_pubkey(this_ptr);
19669 return nativeResponseValue;
19671 // void OpenChannel_set_funding_pubkey(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19673 export function OpenChannel_set_funding_pubkey(this_ptr: number, val: number): void {
19674 if(!isWasmInitialized) {
19675 throw new Error("initializeWasm() must be awaited first!");
19677 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_pubkey(this_ptr, val);
19678 // debug statements here
19680 // struct LDKPublicKey OpenChannel_get_revocation_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19682 export function OpenChannel_get_revocation_basepoint(this_ptr: number): number {
19683 if(!isWasmInitialized) {
19684 throw new Error("initializeWasm() must be awaited first!");
19686 const nativeResponseValue = wasm.TS_OpenChannel_get_revocation_basepoint(this_ptr);
19687 return nativeResponseValue;
19689 // void OpenChannel_set_revocation_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19691 export function OpenChannel_set_revocation_basepoint(this_ptr: number, val: number): void {
19692 if(!isWasmInitialized) {
19693 throw new Error("initializeWasm() must be awaited first!");
19695 const nativeResponseValue = wasm.TS_OpenChannel_set_revocation_basepoint(this_ptr, val);
19696 // debug statements here
19698 // struct LDKPublicKey OpenChannel_get_payment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19700 export function OpenChannel_get_payment_point(this_ptr: number): number {
19701 if(!isWasmInitialized) {
19702 throw new Error("initializeWasm() must be awaited first!");
19704 const nativeResponseValue = wasm.TS_OpenChannel_get_payment_point(this_ptr);
19705 return nativeResponseValue;
19707 // void OpenChannel_set_payment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19709 export function OpenChannel_set_payment_point(this_ptr: number, val: number): void {
19710 if(!isWasmInitialized) {
19711 throw new Error("initializeWasm() must be awaited first!");
19713 const nativeResponseValue = wasm.TS_OpenChannel_set_payment_point(this_ptr, val);
19714 // debug statements here
19716 // struct LDKPublicKey OpenChannel_get_delayed_payment_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19718 export function OpenChannel_get_delayed_payment_basepoint(this_ptr: number): number {
19719 if(!isWasmInitialized) {
19720 throw new Error("initializeWasm() must be awaited first!");
19722 const nativeResponseValue = wasm.TS_OpenChannel_get_delayed_payment_basepoint(this_ptr);
19723 return nativeResponseValue;
19725 // void OpenChannel_set_delayed_payment_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19727 export function OpenChannel_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
19728 if(!isWasmInitialized) {
19729 throw new Error("initializeWasm() must be awaited first!");
19731 const nativeResponseValue = wasm.TS_OpenChannel_set_delayed_payment_basepoint(this_ptr, val);
19732 // debug statements here
19734 // struct LDKPublicKey OpenChannel_get_htlc_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19736 export function OpenChannel_get_htlc_basepoint(this_ptr: number): number {
19737 if(!isWasmInitialized) {
19738 throw new Error("initializeWasm() must be awaited first!");
19740 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_basepoint(this_ptr);
19741 return nativeResponseValue;
19743 // void OpenChannel_set_htlc_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19745 export function OpenChannel_set_htlc_basepoint(this_ptr: number, val: number): void {
19746 if(!isWasmInitialized) {
19747 throw new Error("initializeWasm() must be awaited first!");
19749 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_basepoint(this_ptr, val);
19750 // debug statements here
19752 // struct LDKPublicKey OpenChannel_get_first_per_commitment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19754 export function OpenChannel_get_first_per_commitment_point(this_ptr: number): number {
19755 if(!isWasmInitialized) {
19756 throw new Error("initializeWasm() must be awaited first!");
19758 const nativeResponseValue = wasm.TS_OpenChannel_get_first_per_commitment_point(this_ptr);
19759 return nativeResponseValue;
19761 // void OpenChannel_set_first_per_commitment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19763 export function OpenChannel_set_first_per_commitment_point(this_ptr: number, val: number): void {
19764 if(!isWasmInitialized) {
19765 throw new Error("initializeWasm() must be awaited first!");
19767 const nativeResponseValue = wasm.TS_OpenChannel_set_first_per_commitment_point(this_ptr, val);
19768 // debug statements here
19770 // uint8_t OpenChannel_get_channel_flags(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19772 export function OpenChannel_get_channel_flags(this_ptr: number): number {
19773 if(!isWasmInitialized) {
19774 throw new Error("initializeWasm() must be awaited first!");
19776 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_flags(this_ptr);
19777 return nativeResponseValue;
19779 // void OpenChannel_set_channel_flags(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint8_t val);
19781 export function OpenChannel_set_channel_flags(this_ptr: number, val: number): void {
19782 if(!isWasmInitialized) {
19783 throw new Error("initializeWasm() must be awaited first!");
19785 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_flags(this_ptr, val);
19786 // debug statements here
19788 // struct LDKChannelTypeFeatures OpenChannel_get_channel_type(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19790 export function OpenChannel_get_channel_type(this_ptr: number): number {
19791 if(!isWasmInitialized) {
19792 throw new Error("initializeWasm() must be awaited first!");
19794 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_type(this_ptr);
19795 return nativeResponseValue;
19797 // void OpenChannel_set_channel_type(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
19799 export function OpenChannel_set_channel_type(this_ptr: number, val: number): void {
19800 if(!isWasmInitialized) {
19801 throw new Error("initializeWasm() must be awaited first!");
19803 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_type(this_ptr, val);
19804 // debug statements here
19806 // uintptr_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg);
19808 export function OpenChannel_clone_ptr(arg: number): number {
19809 if(!isWasmInitialized) {
19810 throw new Error("initializeWasm() must be awaited first!");
19812 const nativeResponseValue = wasm.TS_OpenChannel_clone_ptr(arg);
19813 return nativeResponseValue;
19815 // struct LDKOpenChannel OpenChannel_clone(const struct LDKOpenChannel *NONNULL_PTR orig);
19817 export function OpenChannel_clone(orig: number): number {
19818 if(!isWasmInitialized) {
19819 throw new Error("initializeWasm() must be awaited first!");
19821 const nativeResponseValue = wasm.TS_OpenChannel_clone(orig);
19822 return nativeResponseValue;
19824 // void AcceptChannel_free(struct LDKAcceptChannel this_obj);
19826 export function AcceptChannel_free(this_obj: number): void {
19827 if(!isWasmInitialized) {
19828 throw new Error("initializeWasm() must be awaited first!");
19830 const nativeResponseValue = wasm.TS_AcceptChannel_free(this_obj);
19831 // debug statements here
19833 // const uint8_t (*AcceptChannel_get_temporary_channel_id(const struct LDKAcceptChannel *NONNULL_PTR this_ptr))[32];
19835 export function AcceptChannel_get_temporary_channel_id(this_ptr: number): number {
19836 if(!isWasmInitialized) {
19837 throw new Error("initializeWasm() must be awaited first!");
19839 const nativeResponseValue = wasm.TS_AcceptChannel_get_temporary_channel_id(this_ptr);
19840 return nativeResponseValue;
19842 // void AcceptChannel_set_temporary_channel_id(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19844 export function AcceptChannel_set_temporary_channel_id(this_ptr: number, val: number): void {
19845 if(!isWasmInitialized) {
19846 throw new Error("initializeWasm() must be awaited first!");
19848 const nativeResponseValue = wasm.TS_AcceptChannel_set_temporary_channel_id(this_ptr, val);
19849 // debug statements here
19851 // uint64_t AcceptChannel_get_dust_limit_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
19853 export function AcceptChannel_get_dust_limit_satoshis(this_ptr: number): bigint {
19854 if(!isWasmInitialized) {
19855 throw new Error("initializeWasm() must be awaited first!");
19857 const nativeResponseValue = wasm.TS_AcceptChannel_get_dust_limit_satoshis(this_ptr);
19858 return nativeResponseValue;
19860 // void AcceptChannel_set_dust_limit_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
19862 export function AcceptChannel_set_dust_limit_satoshis(this_ptr: number, val: bigint): void {
19863 if(!isWasmInitialized) {
19864 throw new Error("initializeWasm() must be awaited first!");
19866 const nativeResponseValue = wasm.TS_AcceptChannel_set_dust_limit_satoshis(this_ptr, val);
19867 // debug statements here
19869 // uint64_t AcceptChannel_get_max_htlc_value_in_flight_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
19871 export function AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
19872 if(!isWasmInitialized) {
19873 throw new Error("initializeWasm() must be awaited first!");
19875 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr);
19876 return nativeResponseValue;
19878 // void AcceptChannel_set_max_htlc_value_in_flight_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
19880 export function AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
19881 if(!isWasmInitialized) {
19882 throw new Error("initializeWasm() must be awaited first!");
19884 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
19885 // debug statements here
19887 // uint64_t AcceptChannel_get_channel_reserve_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
19889 export function AcceptChannel_get_channel_reserve_satoshis(this_ptr: number): bigint {
19890 if(!isWasmInitialized) {
19891 throw new Error("initializeWasm() must be awaited first!");
19893 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_reserve_satoshis(this_ptr);
19894 return nativeResponseValue;
19896 // void AcceptChannel_set_channel_reserve_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
19898 export function AcceptChannel_set_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
19899 if(!isWasmInitialized) {
19900 throw new Error("initializeWasm() must be awaited first!");
19902 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_reserve_satoshis(this_ptr, val);
19903 // debug statements here
19905 // uint64_t AcceptChannel_get_htlc_minimum_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
19907 export function AcceptChannel_get_htlc_minimum_msat(this_ptr: number): bigint {
19908 if(!isWasmInitialized) {
19909 throw new Error("initializeWasm() must be awaited first!");
19911 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_minimum_msat(this_ptr);
19912 return nativeResponseValue;
19914 // void AcceptChannel_set_htlc_minimum_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
19916 export function AcceptChannel_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
19917 if(!isWasmInitialized) {
19918 throw new Error("initializeWasm() must be awaited first!");
19920 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_minimum_msat(this_ptr, val);
19921 // debug statements here
19923 // uint32_t AcceptChannel_get_minimum_depth(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
19925 export function AcceptChannel_get_minimum_depth(this_ptr: number): number {
19926 if(!isWasmInitialized) {
19927 throw new Error("initializeWasm() must be awaited first!");
19929 const nativeResponseValue = wasm.TS_AcceptChannel_get_minimum_depth(this_ptr);
19930 return nativeResponseValue;
19932 // void AcceptChannel_set_minimum_depth(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint32_t val);
19934 export function AcceptChannel_set_minimum_depth(this_ptr: number, val: number): void {
19935 if(!isWasmInitialized) {
19936 throw new Error("initializeWasm() must be awaited first!");
19938 const nativeResponseValue = wasm.TS_AcceptChannel_set_minimum_depth(this_ptr, val);
19939 // debug statements here
19941 // uint16_t AcceptChannel_get_to_self_delay(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
19943 export function AcceptChannel_get_to_self_delay(this_ptr: number): number {
19944 if(!isWasmInitialized) {
19945 throw new Error("initializeWasm() must be awaited first!");
19947 const nativeResponseValue = wasm.TS_AcceptChannel_get_to_self_delay(this_ptr);
19948 return nativeResponseValue;
19950 // void AcceptChannel_set_to_self_delay(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
19952 export function AcceptChannel_set_to_self_delay(this_ptr: number, val: number): void {
19953 if(!isWasmInitialized) {
19954 throw new Error("initializeWasm() must be awaited first!");
19956 const nativeResponseValue = wasm.TS_AcceptChannel_set_to_self_delay(this_ptr, val);
19957 // debug statements here
19959 // uint16_t AcceptChannel_get_max_accepted_htlcs(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
19961 export function AcceptChannel_get_max_accepted_htlcs(this_ptr: number): number {
19962 if(!isWasmInitialized) {
19963 throw new Error("initializeWasm() must be awaited first!");
19965 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_accepted_htlcs(this_ptr);
19966 return nativeResponseValue;
19968 // void AcceptChannel_set_max_accepted_htlcs(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
19970 export function AcceptChannel_set_max_accepted_htlcs(this_ptr: number, val: number): void {
19971 if(!isWasmInitialized) {
19972 throw new Error("initializeWasm() must be awaited first!");
19974 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_accepted_htlcs(this_ptr, val);
19975 // debug statements here
19977 // struct LDKPublicKey AcceptChannel_get_funding_pubkey(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
19979 export function AcceptChannel_get_funding_pubkey(this_ptr: number): number {
19980 if(!isWasmInitialized) {
19981 throw new Error("initializeWasm() must be awaited first!");
19983 const nativeResponseValue = wasm.TS_AcceptChannel_get_funding_pubkey(this_ptr);
19984 return nativeResponseValue;
19986 // void AcceptChannel_set_funding_pubkey(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19988 export function AcceptChannel_set_funding_pubkey(this_ptr: number, val: number): void {
19989 if(!isWasmInitialized) {
19990 throw new Error("initializeWasm() must be awaited first!");
19992 const nativeResponseValue = wasm.TS_AcceptChannel_set_funding_pubkey(this_ptr, val);
19993 // debug statements here
19995 // struct LDKPublicKey AcceptChannel_get_revocation_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
19997 export function AcceptChannel_get_revocation_basepoint(this_ptr: number): number {
19998 if(!isWasmInitialized) {
19999 throw new Error("initializeWasm() must be awaited first!");
20001 const nativeResponseValue = wasm.TS_AcceptChannel_get_revocation_basepoint(this_ptr);
20002 return nativeResponseValue;
20004 // void AcceptChannel_set_revocation_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20006 export function AcceptChannel_set_revocation_basepoint(this_ptr: number, val: number): void {
20007 if(!isWasmInitialized) {
20008 throw new Error("initializeWasm() must be awaited first!");
20010 const nativeResponseValue = wasm.TS_AcceptChannel_set_revocation_basepoint(this_ptr, val);
20011 // debug statements here
20013 // struct LDKPublicKey AcceptChannel_get_payment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20015 export function AcceptChannel_get_payment_point(this_ptr: number): number {
20016 if(!isWasmInitialized) {
20017 throw new Error("initializeWasm() must be awaited first!");
20019 const nativeResponseValue = wasm.TS_AcceptChannel_get_payment_point(this_ptr);
20020 return nativeResponseValue;
20022 // void AcceptChannel_set_payment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20024 export function AcceptChannel_set_payment_point(this_ptr: number, val: number): void {
20025 if(!isWasmInitialized) {
20026 throw new Error("initializeWasm() must be awaited first!");
20028 const nativeResponseValue = wasm.TS_AcceptChannel_set_payment_point(this_ptr, val);
20029 // debug statements here
20031 // struct LDKPublicKey AcceptChannel_get_delayed_payment_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20033 export function AcceptChannel_get_delayed_payment_basepoint(this_ptr: number): number {
20034 if(!isWasmInitialized) {
20035 throw new Error("initializeWasm() must be awaited first!");
20037 const nativeResponseValue = wasm.TS_AcceptChannel_get_delayed_payment_basepoint(this_ptr);
20038 return nativeResponseValue;
20040 // void AcceptChannel_set_delayed_payment_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20042 export function AcceptChannel_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
20043 if(!isWasmInitialized) {
20044 throw new Error("initializeWasm() must be awaited first!");
20046 const nativeResponseValue = wasm.TS_AcceptChannel_set_delayed_payment_basepoint(this_ptr, val);
20047 // debug statements here
20049 // struct LDKPublicKey AcceptChannel_get_htlc_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20051 export function AcceptChannel_get_htlc_basepoint(this_ptr: number): number {
20052 if(!isWasmInitialized) {
20053 throw new Error("initializeWasm() must be awaited first!");
20055 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_basepoint(this_ptr);
20056 return nativeResponseValue;
20058 // void AcceptChannel_set_htlc_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20060 export function AcceptChannel_set_htlc_basepoint(this_ptr: number, val: number): void {
20061 if(!isWasmInitialized) {
20062 throw new Error("initializeWasm() must be awaited first!");
20064 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_basepoint(this_ptr, val);
20065 // debug statements here
20067 // struct LDKPublicKey AcceptChannel_get_first_per_commitment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20069 export function AcceptChannel_get_first_per_commitment_point(this_ptr: number): number {
20070 if(!isWasmInitialized) {
20071 throw new Error("initializeWasm() must be awaited first!");
20073 const nativeResponseValue = wasm.TS_AcceptChannel_get_first_per_commitment_point(this_ptr);
20074 return nativeResponseValue;
20076 // void AcceptChannel_set_first_per_commitment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20078 export function AcceptChannel_set_first_per_commitment_point(this_ptr: number, val: number): void {
20079 if(!isWasmInitialized) {
20080 throw new Error("initializeWasm() must be awaited first!");
20082 const nativeResponseValue = wasm.TS_AcceptChannel_set_first_per_commitment_point(this_ptr, val);
20083 // debug statements here
20085 // struct LDKChannelTypeFeatures AcceptChannel_get_channel_type(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20087 export function AcceptChannel_get_channel_type(this_ptr: number): number {
20088 if(!isWasmInitialized) {
20089 throw new Error("initializeWasm() must be awaited first!");
20091 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_type(this_ptr);
20092 return nativeResponseValue;
20094 // void AcceptChannel_set_channel_type(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
20096 export function AcceptChannel_set_channel_type(this_ptr: number, val: number): void {
20097 if(!isWasmInitialized) {
20098 throw new Error("initializeWasm() must be awaited first!");
20100 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_type(this_ptr, val);
20101 // debug statements here
20103 // uintptr_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg);
20105 export function AcceptChannel_clone_ptr(arg: number): number {
20106 if(!isWasmInitialized) {
20107 throw new Error("initializeWasm() must be awaited first!");
20109 const nativeResponseValue = wasm.TS_AcceptChannel_clone_ptr(arg);
20110 return nativeResponseValue;
20112 // struct LDKAcceptChannel AcceptChannel_clone(const struct LDKAcceptChannel *NONNULL_PTR orig);
20114 export function AcceptChannel_clone(orig: number): number {
20115 if(!isWasmInitialized) {
20116 throw new Error("initializeWasm() must be awaited first!");
20118 const nativeResponseValue = wasm.TS_AcceptChannel_clone(orig);
20119 return nativeResponseValue;
20121 // void FundingCreated_free(struct LDKFundingCreated this_obj);
20123 export function FundingCreated_free(this_obj: number): void {
20124 if(!isWasmInitialized) {
20125 throw new Error("initializeWasm() must be awaited first!");
20127 const nativeResponseValue = wasm.TS_FundingCreated_free(this_obj);
20128 // debug statements here
20130 // const uint8_t (*FundingCreated_get_temporary_channel_id(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
20132 export function FundingCreated_get_temporary_channel_id(this_ptr: number): number {
20133 if(!isWasmInitialized) {
20134 throw new Error("initializeWasm() must be awaited first!");
20136 const nativeResponseValue = wasm.TS_FundingCreated_get_temporary_channel_id(this_ptr);
20137 return nativeResponseValue;
20139 // void FundingCreated_set_temporary_channel_id(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20141 export function FundingCreated_set_temporary_channel_id(this_ptr: number, val: number): void {
20142 if(!isWasmInitialized) {
20143 throw new Error("initializeWasm() must be awaited first!");
20145 const nativeResponseValue = wasm.TS_FundingCreated_set_temporary_channel_id(this_ptr, val);
20146 // debug statements here
20148 // const uint8_t (*FundingCreated_get_funding_txid(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
20150 export function FundingCreated_get_funding_txid(this_ptr: number): number {
20151 if(!isWasmInitialized) {
20152 throw new Error("initializeWasm() must be awaited first!");
20154 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_txid(this_ptr);
20155 return nativeResponseValue;
20157 // void FundingCreated_set_funding_txid(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20159 export function FundingCreated_set_funding_txid(this_ptr: number, val: number): void {
20160 if(!isWasmInitialized) {
20161 throw new Error("initializeWasm() must be awaited first!");
20163 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_txid(this_ptr, val);
20164 // debug statements here
20166 // uint16_t FundingCreated_get_funding_output_index(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
20168 export function FundingCreated_get_funding_output_index(this_ptr: number): number {
20169 if(!isWasmInitialized) {
20170 throw new Error("initializeWasm() must be awaited first!");
20172 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_output_index(this_ptr);
20173 return nativeResponseValue;
20175 // void FundingCreated_set_funding_output_index(struct LDKFundingCreated *NONNULL_PTR this_ptr, uint16_t val);
20177 export function FundingCreated_set_funding_output_index(this_ptr: number, val: number): void {
20178 if(!isWasmInitialized) {
20179 throw new Error("initializeWasm() must be awaited first!");
20181 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_output_index(this_ptr, val);
20182 // debug statements here
20184 // struct LDKSignature FundingCreated_get_signature(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
20186 export function FundingCreated_get_signature(this_ptr: number): number {
20187 if(!isWasmInitialized) {
20188 throw new Error("initializeWasm() must be awaited first!");
20190 const nativeResponseValue = wasm.TS_FundingCreated_get_signature(this_ptr);
20191 return nativeResponseValue;
20193 // void FundingCreated_set_signature(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKSignature val);
20195 export function FundingCreated_set_signature(this_ptr: number, val: number): void {
20196 if(!isWasmInitialized) {
20197 throw new Error("initializeWasm() must be awaited first!");
20199 const nativeResponseValue = wasm.TS_FundingCreated_set_signature(this_ptr, val);
20200 // debug statements here
20202 // 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);
20204 export function FundingCreated_new(temporary_channel_id_arg: number, funding_txid_arg: number, funding_output_index_arg: number, signature_arg: number): number {
20205 if(!isWasmInitialized) {
20206 throw new Error("initializeWasm() must be awaited first!");
20208 const nativeResponseValue = wasm.TS_FundingCreated_new(temporary_channel_id_arg, funding_txid_arg, funding_output_index_arg, signature_arg);
20209 return nativeResponseValue;
20211 // uintptr_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg);
20213 export function FundingCreated_clone_ptr(arg: number): number {
20214 if(!isWasmInitialized) {
20215 throw new Error("initializeWasm() must be awaited first!");
20217 const nativeResponseValue = wasm.TS_FundingCreated_clone_ptr(arg);
20218 return nativeResponseValue;
20220 // struct LDKFundingCreated FundingCreated_clone(const struct LDKFundingCreated *NONNULL_PTR orig);
20222 export function FundingCreated_clone(orig: number): number {
20223 if(!isWasmInitialized) {
20224 throw new Error("initializeWasm() must be awaited first!");
20226 const nativeResponseValue = wasm.TS_FundingCreated_clone(orig);
20227 return nativeResponseValue;
20229 // void FundingSigned_free(struct LDKFundingSigned this_obj);
20231 export function FundingSigned_free(this_obj: number): void {
20232 if(!isWasmInitialized) {
20233 throw new Error("initializeWasm() must be awaited first!");
20235 const nativeResponseValue = wasm.TS_FundingSigned_free(this_obj);
20236 // debug statements here
20238 // const uint8_t (*FundingSigned_get_channel_id(const struct LDKFundingSigned *NONNULL_PTR this_ptr))[32];
20240 export function FundingSigned_get_channel_id(this_ptr: number): number {
20241 if(!isWasmInitialized) {
20242 throw new Error("initializeWasm() must be awaited first!");
20244 const nativeResponseValue = wasm.TS_FundingSigned_get_channel_id(this_ptr);
20245 return nativeResponseValue;
20247 // void FundingSigned_set_channel_id(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20249 export function FundingSigned_set_channel_id(this_ptr: number, val: number): void {
20250 if(!isWasmInitialized) {
20251 throw new Error("initializeWasm() must be awaited first!");
20253 const nativeResponseValue = wasm.TS_FundingSigned_set_channel_id(this_ptr, val);
20254 // debug statements here
20256 // struct LDKSignature FundingSigned_get_signature(const struct LDKFundingSigned *NONNULL_PTR this_ptr);
20258 export function FundingSigned_get_signature(this_ptr: number): number {
20259 if(!isWasmInitialized) {
20260 throw new Error("initializeWasm() must be awaited first!");
20262 const nativeResponseValue = wasm.TS_FundingSigned_get_signature(this_ptr);
20263 return nativeResponseValue;
20265 // void FundingSigned_set_signature(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
20267 export function FundingSigned_set_signature(this_ptr: number, val: number): void {
20268 if(!isWasmInitialized) {
20269 throw new Error("initializeWasm() must be awaited first!");
20271 const nativeResponseValue = wasm.TS_FundingSigned_set_signature(this_ptr, val);
20272 // debug statements here
20274 // MUST_USE_RES struct LDKFundingSigned FundingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg);
20276 export function FundingSigned_new(channel_id_arg: number, signature_arg: number): number {
20277 if(!isWasmInitialized) {
20278 throw new Error("initializeWasm() must be awaited first!");
20280 const nativeResponseValue = wasm.TS_FundingSigned_new(channel_id_arg, signature_arg);
20281 return nativeResponseValue;
20283 // uintptr_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg);
20285 export function FundingSigned_clone_ptr(arg: number): number {
20286 if(!isWasmInitialized) {
20287 throw new Error("initializeWasm() must be awaited first!");
20289 const nativeResponseValue = wasm.TS_FundingSigned_clone_ptr(arg);
20290 return nativeResponseValue;
20292 // struct LDKFundingSigned FundingSigned_clone(const struct LDKFundingSigned *NONNULL_PTR orig);
20294 export function FundingSigned_clone(orig: number): number {
20295 if(!isWasmInitialized) {
20296 throw new Error("initializeWasm() must be awaited first!");
20298 const nativeResponseValue = wasm.TS_FundingSigned_clone(orig);
20299 return nativeResponseValue;
20301 // void FundingLocked_free(struct LDKFundingLocked this_obj);
20303 export function FundingLocked_free(this_obj: number): void {
20304 if(!isWasmInitialized) {
20305 throw new Error("initializeWasm() must be awaited first!");
20307 const nativeResponseValue = wasm.TS_FundingLocked_free(this_obj);
20308 // debug statements here
20310 // const uint8_t (*FundingLocked_get_channel_id(const struct LDKFundingLocked *NONNULL_PTR this_ptr))[32];
20312 export function FundingLocked_get_channel_id(this_ptr: number): number {
20313 if(!isWasmInitialized) {
20314 throw new Error("initializeWasm() must be awaited first!");
20316 const nativeResponseValue = wasm.TS_FundingLocked_get_channel_id(this_ptr);
20317 return nativeResponseValue;
20319 // void FundingLocked_set_channel_id(struct LDKFundingLocked *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20321 export function FundingLocked_set_channel_id(this_ptr: number, val: number): void {
20322 if(!isWasmInitialized) {
20323 throw new Error("initializeWasm() must be awaited first!");
20325 const nativeResponseValue = wasm.TS_FundingLocked_set_channel_id(this_ptr, val);
20326 // debug statements here
20328 // struct LDKPublicKey FundingLocked_get_next_per_commitment_point(const struct LDKFundingLocked *NONNULL_PTR this_ptr);
20330 export function FundingLocked_get_next_per_commitment_point(this_ptr: number): number {
20331 if(!isWasmInitialized) {
20332 throw new Error("initializeWasm() must be awaited first!");
20334 const nativeResponseValue = wasm.TS_FundingLocked_get_next_per_commitment_point(this_ptr);
20335 return nativeResponseValue;
20337 // void FundingLocked_set_next_per_commitment_point(struct LDKFundingLocked *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20339 export function FundingLocked_set_next_per_commitment_point(this_ptr: number, val: number): void {
20340 if(!isWasmInitialized) {
20341 throw new Error("initializeWasm() must be awaited first!");
20343 const nativeResponseValue = wasm.TS_FundingLocked_set_next_per_commitment_point(this_ptr, val);
20344 // debug statements here
20346 // MUST_USE_RES struct LDKFundingLocked FundingLocked_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKPublicKey next_per_commitment_point_arg);
20348 export function FundingLocked_new(channel_id_arg: number, next_per_commitment_point_arg: number): number {
20349 if(!isWasmInitialized) {
20350 throw new Error("initializeWasm() must be awaited first!");
20352 const nativeResponseValue = wasm.TS_FundingLocked_new(channel_id_arg, next_per_commitment_point_arg);
20353 return nativeResponseValue;
20355 // uintptr_t FundingLocked_clone_ptr(LDKFundingLocked *NONNULL_PTR arg);
20357 export function FundingLocked_clone_ptr(arg: number): number {
20358 if(!isWasmInitialized) {
20359 throw new Error("initializeWasm() must be awaited first!");
20361 const nativeResponseValue = wasm.TS_FundingLocked_clone_ptr(arg);
20362 return nativeResponseValue;
20364 // struct LDKFundingLocked FundingLocked_clone(const struct LDKFundingLocked *NONNULL_PTR orig);
20366 export function FundingLocked_clone(orig: number): number {
20367 if(!isWasmInitialized) {
20368 throw new Error("initializeWasm() must be awaited first!");
20370 const nativeResponseValue = wasm.TS_FundingLocked_clone(orig);
20371 return nativeResponseValue;
20373 // void Shutdown_free(struct LDKShutdown this_obj);
20375 export function Shutdown_free(this_obj: number): void {
20376 if(!isWasmInitialized) {
20377 throw new Error("initializeWasm() must be awaited first!");
20379 const nativeResponseValue = wasm.TS_Shutdown_free(this_obj);
20380 // debug statements here
20382 // const uint8_t (*Shutdown_get_channel_id(const struct LDKShutdown *NONNULL_PTR this_ptr))[32];
20384 export function Shutdown_get_channel_id(this_ptr: number): number {
20385 if(!isWasmInitialized) {
20386 throw new Error("initializeWasm() must be awaited first!");
20388 const nativeResponseValue = wasm.TS_Shutdown_get_channel_id(this_ptr);
20389 return nativeResponseValue;
20391 // void Shutdown_set_channel_id(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20393 export function Shutdown_set_channel_id(this_ptr: number, val: number): void {
20394 if(!isWasmInitialized) {
20395 throw new Error("initializeWasm() must be awaited first!");
20397 const nativeResponseValue = wasm.TS_Shutdown_set_channel_id(this_ptr, val);
20398 // debug statements here
20400 // struct LDKu8slice Shutdown_get_scriptpubkey(const struct LDKShutdown *NONNULL_PTR this_ptr);
20402 export function Shutdown_get_scriptpubkey(this_ptr: number): number {
20403 if(!isWasmInitialized) {
20404 throw new Error("initializeWasm() must be awaited first!");
20406 const nativeResponseValue = wasm.TS_Shutdown_get_scriptpubkey(this_ptr);
20407 return nativeResponseValue;
20409 // void Shutdown_set_scriptpubkey(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
20411 export function Shutdown_set_scriptpubkey(this_ptr: number, val: number): void {
20412 if(!isWasmInitialized) {
20413 throw new Error("initializeWasm() must be awaited first!");
20415 const nativeResponseValue = wasm.TS_Shutdown_set_scriptpubkey(this_ptr, val);
20416 // debug statements here
20418 // MUST_USE_RES struct LDKShutdown Shutdown_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z scriptpubkey_arg);
20420 export function Shutdown_new(channel_id_arg: number, scriptpubkey_arg: number): number {
20421 if(!isWasmInitialized) {
20422 throw new Error("initializeWasm() must be awaited first!");
20424 const nativeResponseValue = wasm.TS_Shutdown_new(channel_id_arg, scriptpubkey_arg);
20425 return nativeResponseValue;
20427 // uintptr_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg);
20429 export function Shutdown_clone_ptr(arg: number): number {
20430 if(!isWasmInitialized) {
20431 throw new Error("initializeWasm() must be awaited first!");
20433 const nativeResponseValue = wasm.TS_Shutdown_clone_ptr(arg);
20434 return nativeResponseValue;
20436 // struct LDKShutdown Shutdown_clone(const struct LDKShutdown *NONNULL_PTR orig);
20438 export function Shutdown_clone(orig: number): number {
20439 if(!isWasmInitialized) {
20440 throw new Error("initializeWasm() must be awaited first!");
20442 const nativeResponseValue = wasm.TS_Shutdown_clone(orig);
20443 return nativeResponseValue;
20445 // void ClosingSignedFeeRange_free(struct LDKClosingSignedFeeRange this_obj);
20447 export function ClosingSignedFeeRange_free(this_obj: number): void {
20448 if(!isWasmInitialized) {
20449 throw new Error("initializeWasm() must be awaited first!");
20451 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_free(this_obj);
20452 // debug statements here
20454 // uint64_t ClosingSignedFeeRange_get_min_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
20456 export function ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr: number): bigint {
20457 if(!isWasmInitialized) {
20458 throw new Error("initializeWasm() must be awaited first!");
20460 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr);
20461 return nativeResponseValue;
20463 // void ClosingSignedFeeRange_set_min_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
20465 export function ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr: number, val: bigint): void {
20466 if(!isWasmInitialized) {
20467 throw new Error("initializeWasm() must be awaited first!");
20469 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr, val);
20470 // debug statements here
20472 // uint64_t ClosingSignedFeeRange_get_max_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
20474 export function ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr: number): bigint {
20475 if(!isWasmInitialized) {
20476 throw new Error("initializeWasm() must be awaited first!");
20478 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr);
20479 return nativeResponseValue;
20481 // void ClosingSignedFeeRange_set_max_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
20483 export function ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr: number, val: bigint): void {
20484 if(!isWasmInitialized) {
20485 throw new Error("initializeWasm() must be awaited first!");
20487 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr, val);
20488 // debug statements here
20490 // MUST_USE_RES struct LDKClosingSignedFeeRange ClosingSignedFeeRange_new(uint64_t min_fee_satoshis_arg, uint64_t max_fee_satoshis_arg);
20492 export function ClosingSignedFeeRange_new(min_fee_satoshis_arg: bigint, max_fee_satoshis_arg: bigint): number {
20493 if(!isWasmInitialized) {
20494 throw new Error("initializeWasm() must be awaited first!");
20496 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
20497 return nativeResponseValue;
20499 // uintptr_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg);
20501 export function ClosingSignedFeeRange_clone_ptr(arg: number): number {
20502 if(!isWasmInitialized) {
20503 throw new Error("initializeWasm() must be awaited first!");
20505 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone_ptr(arg);
20506 return nativeResponseValue;
20508 // struct LDKClosingSignedFeeRange ClosingSignedFeeRange_clone(const struct LDKClosingSignedFeeRange *NONNULL_PTR orig);
20510 export function ClosingSignedFeeRange_clone(orig: number): number {
20511 if(!isWasmInitialized) {
20512 throw new Error("initializeWasm() must be awaited first!");
20514 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone(orig);
20515 return nativeResponseValue;
20517 // void ClosingSigned_free(struct LDKClosingSigned this_obj);
20519 export function ClosingSigned_free(this_obj: number): void {
20520 if(!isWasmInitialized) {
20521 throw new Error("initializeWasm() must be awaited first!");
20523 const nativeResponseValue = wasm.TS_ClosingSigned_free(this_obj);
20524 // debug statements here
20526 // const uint8_t (*ClosingSigned_get_channel_id(const struct LDKClosingSigned *NONNULL_PTR this_ptr))[32];
20528 export function ClosingSigned_get_channel_id(this_ptr: number): number {
20529 if(!isWasmInitialized) {
20530 throw new Error("initializeWasm() must be awaited first!");
20532 const nativeResponseValue = wasm.TS_ClosingSigned_get_channel_id(this_ptr);
20533 return nativeResponseValue;
20535 // void ClosingSigned_set_channel_id(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20537 export function ClosingSigned_set_channel_id(this_ptr: number, val: number): void {
20538 if(!isWasmInitialized) {
20539 throw new Error("initializeWasm() must be awaited first!");
20541 const nativeResponseValue = wasm.TS_ClosingSigned_set_channel_id(this_ptr, val);
20542 // debug statements here
20544 // uint64_t ClosingSigned_get_fee_satoshis(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
20546 export function ClosingSigned_get_fee_satoshis(this_ptr: number): bigint {
20547 if(!isWasmInitialized) {
20548 throw new Error("initializeWasm() must be awaited first!");
20550 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_satoshis(this_ptr);
20551 return nativeResponseValue;
20553 // void ClosingSigned_set_fee_satoshis(struct LDKClosingSigned *NONNULL_PTR this_ptr, uint64_t val);
20555 export function ClosingSigned_set_fee_satoshis(this_ptr: number, val: bigint): void {
20556 if(!isWasmInitialized) {
20557 throw new Error("initializeWasm() must be awaited first!");
20559 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_satoshis(this_ptr, val);
20560 // debug statements here
20562 // struct LDKSignature ClosingSigned_get_signature(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
20564 export function ClosingSigned_get_signature(this_ptr: number): number {
20565 if(!isWasmInitialized) {
20566 throw new Error("initializeWasm() must be awaited first!");
20568 const nativeResponseValue = wasm.TS_ClosingSigned_get_signature(this_ptr);
20569 return nativeResponseValue;
20571 // void ClosingSigned_set_signature(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
20573 export function ClosingSigned_set_signature(this_ptr: number, val: number): void {
20574 if(!isWasmInitialized) {
20575 throw new Error("initializeWasm() must be awaited first!");
20577 const nativeResponseValue = wasm.TS_ClosingSigned_set_signature(this_ptr, val);
20578 // debug statements here
20580 // struct LDKClosingSignedFeeRange ClosingSigned_get_fee_range(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
20582 export function ClosingSigned_get_fee_range(this_ptr: number): number {
20583 if(!isWasmInitialized) {
20584 throw new Error("initializeWasm() must be awaited first!");
20586 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_range(this_ptr);
20587 return nativeResponseValue;
20589 // void ClosingSigned_set_fee_range(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKClosingSignedFeeRange val);
20591 export function ClosingSigned_set_fee_range(this_ptr: number, val: number): void {
20592 if(!isWasmInitialized) {
20593 throw new Error("initializeWasm() must be awaited first!");
20595 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_range(this_ptr, val);
20596 // debug statements here
20598 // 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);
20600 export function ClosingSigned_new(channel_id_arg: number, fee_satoshis_arg: bigint, signature_arg: number, fee_range_arg: number): number {
20601 if(!isWasmInitialized) {
20602 throw new Error("initializeWasm() must be awaited first!");
20604 const nativeResponseValue = wasm.TS_ClosingSigned_new(channel_id_arg, fee_satoshis_arg, signature_arg, fee_range_arg);
20605 return nativeResponseValue;
20607 // uintptr_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg);
20609 export function ClosingSigned_clone_ptr(arg: number): number {
20610 if(!isWasmInitialized) {
20611 throw new Error("initializeWasm() must be awaited first!");
20613 const nativeResponseValue = wasm.TS_ClosingSigned_clone_ptr(arg);
20614 return nativeResponseValue;
20616 // struct LDKClosingSigned ClosingSigned_clone(const struct LDKClosingSigned *NONNULL_PTR orig);
20618 export function ClosingSigned_clone(orig: number): number {
20619 if(!isWasmInitialized) {
20620 throw new Error("initializeWasm() must be awaited first!");
20622 const nativeResponseValue = wasm.TS_ClosingSigned_clone(orig);
20623 return nativeResponseValue;
20625 // void UpdateAddHTLC_free(struct LDKUpdateAddHTLC this_obj);
20627 export function UpdateAddHTLC_free(this_obj: number): void {
20628 if(!isWasmInitialized) {
20629 throw new Error("initializeWasm() must be awaited first!");
20631 const nativeResponseValue = wasm.TS_UpdateAddHTLC_free(this_obj);
20632 // debug statements here
20634 // const uint8_t (*UpdateAddHTLC_get_channel_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
20636 export function UpdateAddHTLC_get_channel_id(this_ptr: number): number {
20637 if(!isWasmInitialized) {
20638 throw new Error("initializeWasm() must be awaited first!");
20640 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_channel_id(this_ptr);
20641 return nativeResponseValue;
20643 // void UpdateAddHTLC_set_channel_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20645 export function UpdateAddHTLC_set_channel_id(this_ptr: number, val: number): void {
20646 if(!isWasmInitialized) {
20647 throw new Error("initializeWasm() must be awaited first!");
20649 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_channel_id(this_ptr, val);
20650 // debug statements here
20652 // uint64_t UpdateAddHTLC_get_htlc_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
20654 export function UpdateAddHTLC_get_htlc_id(this_ptr: number): bigint {
20655 if(!isWasmInitialized) {
20656 throw new Error("initializeWasm() must be awaited first!");
20658 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_htlc_id(this_ptr);
20659 return nativeResponseValue;
20661 // void UpdateAddHTLC_set_htlc_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
20663 export function UpdateAddHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
20664 if(!isWasmInitialized) {
20665 throw new Error("initializeWasm() must be awaited first!");
20667 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_htlc_id(this_ptr, val);
20668 // debug statements here
20670 // uint64_t UpdateAddHTLC_get_amount_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
20672 export function UpdateAddHTLC_get_amount_msat(this_ptr: number): bigint {
20673 if(!isWasmInitialized) {
20674 throw new Error("initializeWasm() must be awaited first!");
20676 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_amount_msat(this_ptr);
20677 return nativeResponseValue;
20679 // void UpdateAddHTLC_set_amount_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
20681 export function UpdateAddHTLC_set_amount_msat(this_ptr: number, val: bigint): void {
20682 if(!isWasmInitialized) {
20683 throw new Error("initializeWasm() must be awaited first!");
20685 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_amount_msat(this_ptr, val);
20686 // debug statements here
20688 // const uint8_t (*UpdateAddHTLC_get_payment_hash(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
20690 export function UpdateAddHTLC_get_payment_hash(this_ptr: number): number {
20691 if(!isWasmInitialized) {
20692 throw new Error("initializeWasm() must be awaited first!");
20694 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_payment_hash(this_ptr);
20695 return nativeResponseValue;
20697 // void UpdateAddHTLC_set_payment_hash(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20699 export function UpdateAddHTLC_set_payment_hash(this_ptr: number, val: number): void {
20700 if(!isWasmInitialized) {
20701 throw new Error("initializeWasm() must be awaited first!");
20703 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_payment_hash(this_ptr, val);
20704 // debug statements here
20706 // uint32_t UpdateAddHTLC_get_cltv_expiry(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
20708 export function UpdateAddHTLC_get_cltv_expiry(this_ptr: number): number {
20709 if(!isWasmInitialized) {
20710 throw new Error("initializeWasm() must be awaited first!");
20712 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_cltv_expiry(this_ptr);
20713 return nativeResponseValue;
20715 // void UpdateAddHTLC_set_cltv_expiry(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint32_t val);
20717 export function UpdateAddHTLC_set_cltv_expiry(this_ptr: number, val: number): void {
20718 if(!isWasmInitialized) {
20719 throw new Error("initializeWasm() must be awaited first!");
20721 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_cltv_expiry(this_ptr, val);
20722 // debug statements here
20724 // uintptr_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg);
20726 export function UpdateAddHTLC_clone_ptr(arg: number): number {
20727 if(!isWasmInitialized) {
20728 throw new Error("initializeWasm() must be awaited first!");
20730 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone_ptr(arg);
20731 return nativeResponseValue;
20733 // struct LDKUpdateAddHTLC UpdateAddHTLC_clone(const struct LDKUpdateAddHTLC *NONNULL_PTR orig);
20735 export function UpdateAddHTLC_clone(orig: number): number {
20736 if(!isWasmInitialized) {
20737 throw new Error("initializeWasm() must be awaited first!");
20739 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone(orig);
20740 return nativeResponseValue;
20742 // void UpdateFulfillHTLC_free(struct LDKUpdateFulfillHTLC this_obj);
20744 export function UpdateFulfillHTLC_free(this_obj: number): void {
20745 if(!isWasmInitialized) {
20746 throw new Error("initializeWasm() must be awaited first!");
20748 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_free(this_obj);
20749 // debug statements here
20751 // const uint8_t (*UpdateFulfillHTLC_get_channel_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
20753 export function UpdateFulfillHTLC_get_channel_id(this_ptr: number): number {
20754 if(!isWasmInitialized) {
20755 throw new Error("initializeWasm() must be awaited first!");
20757 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_channel_id(this_ptr);
20758 return nativeResponseValue;
20760 // void UpdateFulfillHTLC_set_channel_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20762 export function UpdateFulfillHTLC_set_channel_id(this_ptr: number, val: number): void {
20763 if(!isWasmInitialized) {
20764 throw new Error("initializeWasm() must be awaited first!");
20766 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_channel_id(this_ptr, val);
20767 // debug statements here
20769 // uint64_t UpdateFulfillHTLC_get_htlc_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr);
20771 export function UpdateFulfillHTLC_get_htlc_id(this_ptr: number): bigint {
20772 if(!isWasmInitialized) {
20773 throw new Error("initializeWasm() must be awaited first!");
20775 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_htlc_id(this_ptr);
20776 return nativeResponseValue;
20778 // void UpdateFulfillHTLC_set_htlc_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, uint64_t val);
20780 export function UpdateFulfillHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
20781 if(!isWasmInitialized) {
20782 throw new Error("initializeWasm() must be awaited first!");
20784 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_htlc_id(this_ptr, val);
20785 // debug statements here
20787 // const uint8_t (*UpdateFulfillHTLC_get_payment_preimage(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
20789 export function UpdateFulfillHTLC_get_payment_preimage(this_ptr: number): number {
20790 if(!isWasmInitialized) {
20791 throw new Error("initializeWasm() must be awaited first!");
20793 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_payment_preimage(this_ptr);
20794 return nativeResponseValue;
20796 // void UpdateFulfillHTLC_set_payment_preimage(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20798 export function UpdateFulfillHTLC_set_payment_preimage(this_ptr: number, val: number): void {
20799 if(!isWasmInitialized) {
20800 throw new Error("initializeWasm() must be awaited first!");
20802 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_payment_preimage(this_ptr, val);
20803 // debug statements here
20805 // MUST_USE_RES struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t htlc_id_arg, struct LDKThirtyTwoBytes payment_preimage_arg);
20807 export function UpdateFulfillHTLC_new(channel_id_arg: number, htlc_id_arg: bigint, payment_preimage_arg: number): number {
20808 if(!isWasmInitialized) {
20809 throw new Error("initializeWasm() must be awaited first!");
20811 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_new(channel_id_arg, htlc_id_arg, payment_preimage_arg);
20812 return nativeResponseValue;
20814 // uintptr_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg);
20816 export function UpdateFulfillHTLC_clone_ptr(arg: number): number {
20817 if(!isWasmInitialized) {
20818 throw new Error("initializeWasm() must be awaited first!");
20820 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone_ptr(arg);
20821 return nativeResponseValue;
20823 // struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_clone(const struct LDKUpdateFulfillHTLC *NONNULL_PTR orig);
20825 export function UpdateFulfillHTLC_clone(orig: number): number {
20826 if(!isWasmInitialized) {
20827 throw new Error("initializeWasm() must be awaited first!");
20829 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone(orig);
20830 return nativeResponseValue;
20832 // void UpdateFailHTLC_free(struct LDKUpdateFailHTLC this_obj);
20834 export function UpdateFailHTLC_free(this_obj: number): void {
20835 if(!isWasmInitialized) {
20836 throw new Error("initializeWasm() must be awaited first!");
20838 const nativeResponseValue = wasm.TS_UpdateFailHTLC_free(this_obj);
20839 // debug statements here
20841 // const uint8_t (*UpdateFailHTLC_get_channel_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr))[32];
20843 export function UpdateFailHTLC_get_channel_id(this_ptr: number): number {
20844 if(!isWasmInitialized) {
20845 throw new Error("initializeWasm() must be awaited first!");
20847 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_channel_id(this_ptr);
20848 return nativeResponseValue;
20850 // void UpdateFailHTLC_set_channel_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20852 export function UpdateFailHTLC_set_channel_id(this_ptr: number, val: number): void {
20853 if(!isWasmInitialized) {
20854 throw new Error("initializeWasm() must be awaited first!");
20856 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_channel_id(this_ptr, val);
20857 // debug statements here
20859 // uint64_t UpdateFailHTLC_get_htlc_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr);
20861 export function UpdateFailHTLC_get_htlc_id(this_ptr: number): bigint {
20862 if(!isWasmInitialized) {
20863 throw new Error("initializeWasm() must be awaited first!");
20865 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_htlc_id(this_ptr);
20866 return nativeResponseValue;
20868 // void UpdateFailHTLC_set_htlc_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, uint64_t val);
20870 export function UpdateFailHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
20871 if(!isWasmInitialized) {
20872 throw new Error("initializeWasm() must be awaited first!");
20874 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_htlc_id(this_ptr, val);
20875 // debug statements here
20877 // uintptr_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg);
20879 export function UpdateFailHTLC_clone_ptr(arg: number): number {
20880 if(!isWasmInitialized) {
20881 throw new Error("initializeWasm() must be awaited first!");
20883 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone_ptr(arg);
20884 return nativeResponseValue;
20886 // struct LDKUpdateFailHTLC UpdateFailHTLC_clone(const struct LDKUpdateFailHTLC *NONNULL_PTR orig);
20888 export function UpdateFailHTLC_clone(orig: number): number {
20889 if(!isWasmInitialized) {
20890 throw new Error("initializeWasm() must be awaited first!");
20892 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone(orig);
20893 return nativeResponseValue;
20895 // void UpdateFailMalformedHTLC_free(struct LDKUpdateFailMalformedHTLC this_obj);
20897 export function UpdateFailMalformedHTLC_free(this_obj: number): void {
20898 if(!isWasmInitialized) {
20899 throw new Error("initializeWasm() must be awaited first!");
20901 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_free(this_obj);
20902 // debug statements here
20904 // const uint8_t (*UpdateFailMalformedHTLC_get_channel_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr))[32];
20906 export function UpdateFailMalformedHTLC_get_channel_id(this_ptr: number): number {
20907 if(!isWasmInitialized) {
20908 throw new Error("initializeWasm() must be awaited first!");
20910 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_channel_id(this_ptr);
20911 return nativeResponseValue;
20913 // void UpdateFailMalformedHTLC_set_channel_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20915 export function UpdateFailMalformedHTLC_set_channel_id(this_ptr: number, val: number): void {
20916 if(!isWasmInitialized) {
20917 throw new Error("initializeWasm() must be awaited first!");
20919 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_channel_id(this_ptr, val);
20920 // debug statements here
20922 // uint64_t UpdateFailMalformedHTLC_get_htlc_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
20924 export function UpdateFailMalformedHTLC_get_htlc_id(this_ptr: number): bigint {
20925 if(!isWasmInitialized) {
20926 throw new Error("initializeWasm() must be awaited first!");
20928 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_htlc_id(this_ptr);
20929 return nativeResponseValue;
20931 // void UpdateFailMalformedHTLC_set_htlc_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint64_t val);
20933 export function UpdateFailMalformedHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
20934 if(!isWasmInitialized) {
20935 throw new Error("initializeWasm() must be awaited first!");
20937 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_htlc_id(this_ptr, val);
20938 // debug statements here
20940 // uint16_t UpdateFailMalformedHTLC_get_failure_code(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
20942 export function UpdateFailMalformedHTLC_get_failure_code(this_ptr: number): number {
20943 if(!isWasmInitialized) {
20944 throw new Error("initializeWasm() must be awaited first!");
20946 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_failure_code(this_ptr);
20947 return nativeResponseValue;
20949 // void UpdateFailMalformedHTLC_set_failure_code(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint16_t val);
20951 export function UpdateFailMalformedHTLC_set_failure_code(this_ptr: number, val: number): void {
20952 if(!isWasmInitialized) {
20953 throw new Error("initializeWasm() must be awaited first!");
20955 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_failure_code(this_ptr, val);
20956 // debug statements here
20958 // uintptr_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg);
20960 export function UpdateFailMalformedHTLC_clone_ptr(arg: number): number {
20961 if(!isWasmInitialized) {
20962 throw new Error("initializeWasm() must be awaited first!");
20964 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone_ptr(arg);
20965 return nativeResponseValue;
20967 // struct LDKUpdateFailMalformedHTLC UpdateFailMalformedHTLC_clone(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR orig);
20969 export function UpdateFailMalformedHTLC_clone(orig: number): number {
20970 if(!isWasmInitialized) {
20971 throw new Error("initializeWasm() must be awaited first!");
20973 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone(orig);
20974 return nativeResponseValue;
20976 // void CommitmentSigned_free(struct LDKCommitmentSigned this_obj);
20978 export function CommitmentSigned_free(this_obj: number): void {
20979 if(!isWasmInitialized) {
20980 throw new Error("initializeWasm() must be awaited first!");
20982 const nativeResponseValue = wasm.TS_CommitmentSigned_free(this_obj);
20983 // debug statements here
20985 // const uint8_t (*CommitmentSigned_get_channel_id(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr))[32];
20987 export function CommitmentSigned_get_channel_id(this_ptr: number): number {
20988 if(!isWasmInitialized) {
20989 throw new Error("initializeWasm() must be awaited first!");
20991 const nativeResponseValue = wasm.TS_CommitmentSigned_get_channel_id(this_ptr);
20992 return nativeResponseValue;
20994 // void CommitmentSigned_set_channel_id(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20996 export function CommitmentSigned_set_channel_id(this_ptr: number, val: number): void {
20997 if(!isWasmInitialized) {
20998 throw new Error("initializeWasm() must be awaited first!");
21000 const nativeResponseValue = wasm.TS_CommitmentSigned_set_channel_id(this_ptr, val);
21001 // debug statements here
21003 // struct LDKSignature CommitmentSigned_get_signature(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
21005 export function CommitmentSigned_get_signature(this_ptr: number): number {
21006 if(!isWasmInitialized) {
21007 throw new Error("initializeWasm() must be awaited first!");
21009 const nativeResponseValue = wasm.TS_CommitmentSigned_get_signature(this_ptr);
21010 return nativeResponseValue;
21012 // void CommitmentSigned_set_signature(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
21014 export function CommitmentSigned_set_signature(this_ptr: number, val: number): void {
21015 if(!isWasmInitialized) {
21016 throw new Error("initializeWasm() must be awaited first!");
21018 const nativeResponseValue = wasm.TS_CommitmentSigned_set_signature(this_ptr, val);
21019 // debug statements here
21021 // void CommitmentSigned_set_htlc_signatures(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
21023 export function CommitmentSigned_set_htlc_signatures(this_ptr: number, val: number): void {
21024 if(!isWasmInitialized) {
21025 throw new Error("initializeWasm() must be awaited first!");
21027 const nativeResponseValue = wasm.TS_CommitmentSigned_set_htlc_signatures(this_ptr, val);
21028 // debug statements here
21030 // MUST_USE_RES struct LDKCommitmentSigned CommitmentSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg, struct LDKCVec_SignatureZ htlc_signatures_arg);
21032 export function CommitmentSigned_new(channel_id_arg: number, signature_arg: number, htlc_signatures_arg: number): number {
21033 if(!isWasmInitialized) {
21034 throw new Error("initializeWasm() must be awaited first!");
21036 const nativeResponseValue = wasm.TS_CommitmentSigned_new(channel_id_arg, signature_arg, htlc_signatures_arg);
21037 return nativeResponseValue;
21039 // uintptr_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg);
21041 export function CommitmentSigned_clone_ptr(arg: number): number {
21042 if(!isWasmInitialized) {
21043 throw new Error("initializeWasm() must be awaited first!");
21045 const nativeResponseValue = wasm.TS_CommitmentSigned_clone_ptr(arg);
21046 return nativeResponseValue;
21048 // struct LDKCommitmentSigned CommitmentSigned_clone(const struct LDKCommitmentSigned *NONNULL_PTR orig);
21050 export function CommitmentSigned_clone(orig: number): number {
21051 if(!isWasmInitialized) {
21052 throw new Error("initializeWasm() must be awaited first!");
21054 const nativeResponseValue = wasm.TS_CommitmentSigned_clone(orig);
21055 return nativeResponseValue;
21057 // void RevokeAndACK_free(struct LDKRevokeAndACK this_obj);
21059 export function RevokeAndACK_free(this_obj: number): void {
21060 if(!isWasmInitialized) {
21061 throw new Error("initializeWasm() must be awaited first!");
21063 const nativeResponseValue = wasm.TS_RevokeAndACK_free(this_obj);
21064 // debug statements here
21066 // const uint8_t (*RevokeAndACK_get_channel_id(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
21068 export function RevokeAndACK_get_channel_id(this_ptr: number): number {
21069 if(!isWasmInitialized) {
21070 throw new Error("initializeWasm() must be awaited first!");
21072 const nativeResponseValue = wasm.TS_RevokeAndACK_get_channel_id(this_ptr);
21073 return nativeResponseValue;
21075 // void RevokeAndACK_set_channel_id(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21077 export function RevokeAndACK_set_channel_id(this_ptr: number, val: number): void {
21078 if(!isWasmInitialized) {
21079 throw new Error("initializeWasm() must be awaited first!");
21081 const nativeResponseValue = wasm.TS_RevokeAndACK_set_channel_id(this_ptr, val);
21082 // debug statements here
21084 // const uint8_t (*RevokeAndACK_get_per_commitment_secret(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
21086 export function RevokeAndACK_get_per_commitment_secret(this_ptr: number): number {
21087 if(!isWasmInitialized) {
21088 throw new Error("initializeWasm() must be awaited first!");
21090 const nativeResponseValue = wasm.TS_RevokeAndACK_get_per_commitment_secret(this_ptr);
21091 return nativeResponseValue;
21093 // void RevokeAndACK_set_per_commitment_secret(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21095 export function RevokeAndACK_set_per_commitment_secret(this_ptr: number, val: number): void {
21096 if(!isWasmInitialized) {
21097 throw new Error("initializeWasm() must be awaited first!");
21099 const nativeResponseValue = wasm.TS_RevokeAndACK_set_per_commitment_secret(this_ptr, val);
21100 // debug statements here
21102 // struct LDKPublicKey RevokeAndACK_get_next_per_commitment_point(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr);
21104 export function RevokeAndACK_get_next_per_commitment_point(this_ptr: number): number {
21105 if(!isWasmInitialized) {
21106 throw new Error("initializeWasm() must be awaited first!");
21108 const nativeResponseValue = wasm.TS_RevokeAndACK_get_next_per_commitment_point(this_ptr);
21109 return nativeResponseValue;
21111 // void RevokeAndACK_set_next_per_commitment_point(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21113 export function RevokeAndACK_set_next_per_commitment_point(this_ptr: number, val: number): void {
21114 if(!isWasmInitialized) {
21115 throw new Error("initializeWasm() must be awaited first!");
21117 const nativeResponseValue = wasm.TS_RevokeAndACK_set_next_per_commitment_point(this_ptr, val);
21118 // debug statements here
21120 // 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);
21122 export function RevokeAndACK_new(channel_id_arg: number, per_commitment_secret_arg: number, next_per_commitment_point_arg: number): number {
21123 if(!isWasmInitialized) {
21124 throw new Error("initializeWasm() must be awaited first!");
21126 const nativeResponseValue = wasm.TS_RevokeAndACK_new(channel_id_arg, per_commitment_secret_arg, next_per_commitment_point_arg);
21127 return nativeResponseValue;
21129 // uintptr_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg);
21131 export function RevokeAndACK_clone_ptr(arg: number): number {
21132 if(!isWasmInitialized) {
21133 throw new Error("initializeWasm() must be awaited first!");
21135 const nativeResponseValue = wasm.TS_RevokeAndACK_clone_ptr(arg);
21136 return nativeResponseValue;
21138 // struct LDKRevokeAndACK RevokeAndACK_clone(const struct LDKRevokeAndACK *NONNULL_PTR orig);
21140 export function RevokeAndACK_clone(orig: number): number {
21141 if(!isWasmInitialized) {
21142 throw new Error("initializeWasm() must be awaited first!");
21144 const nativeResponseValue = wasm.TS_RevokeAndACK_clone(orig);
21145 return nativeResponseValue;
21147 // void UpdateFee_free(struct LDKUpdateFee this_obj);
21149 export function UpdateFee_free(this_obj: number): void {
21150 if(!isWasmInitialized) {
21151 throw new Error("initializeWasm() must be awaited first!");
21153 const nativeResponseValue = wasm.TS_UpdateFee_free(this_obj);
21154 // debug statements here
21156 // const uint8_t (*UpdateFee_get_channel_id(const struct LDKUpdateFee *NONNULL_PTR this_ptr))[32];
21158 export function UpdateFee_get_channel_id(this_ptr: number): number {
21159 if(!isWasmInitialized) {
21160 throw new Error("initializeWasm() must be awaited first!");
21162 const nativeResponseValue = wasm.TS_UpdateFee_get_channel_id(this_ptr);
21163 return nativeResponseValue;
21165 // void UpdateFee_set_channel_id(struct LDKUpdateFee *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21167 export function UpdateFee_set_channel_id(this_ptr: number, val: number): void {
21168 if(!isWasmInitialized) {
21169 throw new Error("initializeWasm() must be awaited first!");
21171 const nativeResponseValue = wasm.TS_UpdateFee_set_channel_id(this_ptr, val);
21172 // debug statements here
21174 // uint32_t UpdateFee_get_feerate_per_kw(const struct LDKUpdateFee *NONNULL_PTR this_ptr);
21176 export function UpdateFee_get_feerate_per_kw(this_ptr: number): number {
21177 if(!isWasmInitialized) {
21178 throw new Error("initializeWasm() must be awaited first!");
21180 const nativeResponseValue = wasm.TS_UpdateFee_get_feerate_per_kw(this_ptr);
21181 return nativeResponseValue;
21183 // void UpdateFee_set_feerate_per_kw(struct LDKUpdateFee *NONNULL_PTR this_ptr, uint32_t val);
21185 export function UpdateFee_set_feerate_per_kw(this_ptr: number, val: number): void {
21186 if(!isWasmInitialized) {
21187 throw new Error("initializeWasm() must be awaited first!");
21189 const nativeResponseValue = wasm.TS_UpdateFee_set_feerate_per_kw(this_ptr, val);
21190 // debug statements here
21192 // MUST_USE_RES struct LDKUpdateFee UpdateFee_new(struct LDKThirtyTwoBytes channel_id_arg, uint32_t feerate_per_kw_arg);
21194 export function UpdateFee_new(channel_id_arg: number, feerate_per_kw_arg: number): number {
21195 if(!isWasmInitialized) {
21196 throw new Error("initializeWasm() must be awaited first!");
21198 const nativeResponseValue = wasm.TS_UpdateFee_new(channel_id_arg, feerate_per_kw_arg);
21199 return nativeResponseValue;
21201 // uintptr_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg);
21203 export function UpdateFee_clone_ptr(arg: number): number {
21204 if(!isWasmInitialized) {
21205 throw new Error("initializeWasm() must be awaited first!");
21207 const nativeResponseValue = wasm.TS_UpdateFee_clone_ptr(arg);
21208 return nativeResponseValue;
21210 // struct LDKUpdateFee UpdateFee_clone(const struct LDKUpdateFee *NONNULL_PTR orig);
21212 export function UpdateFee_clone(orig: number): number {
21213 if(!isWasmInitialized) {
21214 throw new Error("initializeWasm() must be awaited first!");
21216 const nativeResponseValue = wasm.TS_UpdateFee_clone(orig);
21217 return nativeResponseValue;
21219 // void DataLossProtect_free(struct LDKDataLossProtect this_obj);
21221 export function DataLossProtect_free(this_obj: number): void {
21222 if(!isWasmInitialized) {
21223 throw new Error("initializeWasm() must be awaited first!");
21225 const nativeResponseValue = wasm.TS_DataLossProtect_free(this_obj);
21226 // debug statements here
21228 // const uint8_t (*DataLossProtect_get_your_last_per_commitment_secret(const struct LDKDataLossProtect *NONNULL_PTR this_ptr))[32];
21230 export function DataLossProtect_get_your_last_per_commitment_secret(this_ptr: number): number {
21231 if(!isWasmInitialized) {
21232 throw new Error("initializeWasm() must be awaited first!");
21234 const nativeResponseValue = wasm.TS_DataLossProtect_get_your_last_per_commitment_secret(this_ptr);
21235 return nativeResponseValue;
21237 // void DataLossProtect_set_your_last_per_commitment_secret(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21239 export function DataLossProtect_set_your_last_per_commitment_secret(this_ptr: number, val: number): void {
21240 if(!isWasmInitialized) {
21241 throw new Error("initializeWasm() must be awaited first!");
21243 const nativeResponseValue = wasm.TS_DataLossProtect_set_your_last_per_commitment_secret(this_ptr, val);
21244 // debug statements here
21246 // struct LDKPublicKey DataLossProtect_get_my_current_per_commitment_point(const struct LDKDataLossProtect *NONNULL_PTR this_ptr);
21248 export function DataLossProtect_get_my_current_per_commitment_point(this_ptr: number): number {
21249 if(!isWasmInitialized) {
21250 throw new Error("initializeWasm() must be awaited first!");
21252 const nativeResponseValue = wasm.TS_DataLossProtect_get_my_current_per_commitment_point(this_ptr);
21253 return nativeResponseValue;
21255 // void DataLossProtect_set_my_current_per_commitment_point(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21257 export function DataLossProtect_set_my_current_per_commitment_point(this_ptr: number, val: number): void {
21258 if(!isWasmInitialized) {
21259 throw new Error("initializeWasm() must be awaited first!");
21261 const nativeResponseValue = wasm.TS_DataLossProtect_set_my_current_per_commitment_point(this_ptr, val);
21262 // debug statements here
21264 // MUST_USE_RES struct LDKDataLossProtect DataLossProtect_new(struct LDKThirtyTwoBytes your_last_per_commitment_secret_arg, struct LDKPublicKey my_current_per_commitment_point_arg);
21266 export function DataLossProtect_new(your_last_per_commitment_secret_arg: number, my_current_per_commitment_point_arg: number): number {
21267 if(!isWasmInitialized) {
21268 throw new Error("initializeWasm() must be awaited first!");
21270 const nativeResponseValue = wasm.TS_DataLossProtect_new(your_last_per_commitment_secret_arg, my_current_per_commitment_point_arg);
21271 return nativeResponseValue;
21273 // uintptr_t DataLossProtect_clone_ptr(LDKDataLossProtect *NONNULL_PTR arg);
21275 export function DataLossProtect_clone_ptr(arg: number): number {
21276 if(!isWasmInitialized) {
21277 throw new Error("initializeWasm() must be awaited first!");
21279 const nativeResponseValue = wasm.TS_DataLossProtect_clone_ptr(arg);
21280 return nativeResponseValue;
21282 // struct LDKDataLossProtect DataLossProtect_clone(const struct LDKDataLossProtect *NONNULL_PTR orig);
21284 export function DataLossProtect_clone(orig: number): number {
21285 if(!isWasmInitialized) {
21286 throw new Error("initializeWasm() must be awaited first!");
21288 const nativeResponseValue = wasm.TS_DataLossProtect_clone(orig);
21289 return nativeResponseValue;
21291 // void ChannelReestablish_free(struct LDKChannelReestablish this_obj);
21293 export function ChannelReestablish_free(this_obj: number): void {
21294 if(!isWasmInitialized) {
21295 throw new Error("initializeWasm() must be awaited first!");
21297 const nativeResponseValue = wasm.TS_ChannelReestablish_free(this_obj);
21298 // debug statements here
21300 // const uint8_t (*ChannelReestablish_get_channel_id(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
21302 export function ChannelReestablish_get_channel_id(this_ptr: number): number {
21303 if(!isWasmInitialized) {
21304 throw new Error("initializeWasm() must be awaited first!");
21306 const nativeResponseValue = wasm.TS_ChannelReestablish_get_channel_id(this_ptr);
21307 return nativeResponseValue;
21309 // void ChannelReestablish_set_channel_id(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21311 export function ChannelReestablish_set_channel_id(this_ptr: number, val: number): void {
21312 if(!isWasmInitialized) {
21313 throw new Error("initializeWasm() must be awaited first!");
21315 const nativeResponseValue = wasm.TS_ChannelReestablish_set_channel_id(this_ptr, val);
21316 // debug statements here
21318 // uint64_t ChannelReestablish_get_next_local_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
21320 export function ChannelReestablish_get_next_local_commitment_number(this_ptr: number): bigint {
21321 if(!isWasmInitialized) {
21322 throw new Error("initializeWasm() must be awaited first!");
21324 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_local_commitment_number(this_ptr);
21325 return nativeResponseValue;
21327 // void ChannelReestablish_set_next_local_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
21329 export function ChannelReestablish_set_next_local_commitment_number(this_ptr: number, val: bigint): void {
21330 if(!isWasmInitialized) {
21331 throw new Error("initializeWasm() must be awaited first!");
21333 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_local_commitment_number(this_ptr, val);
21334 // debug statements here
21336 // uint64_t ChannelReestablish_get_next_remote_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
21338 export function ChannelReestablish_get_next_remote_commitment_number(this_ptr: number): bigint {
21339 if(!isWasmInitialized) {
21340 throw new Error("initializeWasm() must be awaited first!");
21342 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_remote_commitment_number(this_ptr);
21343 return nativeResponseValue;
21345 // void ChannelReestablish_set_next_remote_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
21347 export function ChannelReestablish_set_next_remote_commitment_number(this_ptr: number, val: bigint): void {
21348 if(!isWasmInitialized) {
21349 throw new Error("initializeWasm() must be awaited first!");
21351 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_remote_commitment_number(this_ptr, val);
21352 // debug statements here
21354 // uintptr_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg);
21356 export function ChannelReestablish_clone_ptr(arg: number): number {
21357 if(!isWasmInitialized) {
21358 throw new Error("initializeWasm() must be awaited first!");
21360 const nativeResponseValue = wasm.TS_ChannelReestablish_clone_ptr(arg);
21361 return nativeResponseValue;
21363 // struct LDKChannelReestablish ChannelReestablish_clone(const struct LDKChannelReestablish *NONNULL_PTR orig);
21365 export function ChannelReestablish_clone(orig: number): number {
21366 if(!isWasmInitialized) {
21367 throw new Error("initializeWasm() must be awaited first!");
21369 const nativeResponseValue = wasm.TS_ChannelReestablish_clone(orig);
21370 return nativeResponseValue;
21372 // void AnnouncementSignatures_free(struct LDKAnnouncementSignatures this_obj);
21374 export function AnnouncementSignatures_free(this_obj: number): void {
21375 if(!isWasmInitialized) {
21376 throw new Error("initializeWasm() must be awaited first!");
21378 const nativeResponseValue = wasm.TS_AnnouncementSignatures_free(this_obj);
21379 // debug statements here
21381 // const uint8_t (*AnnouncementSignatures_get_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr))[32];
21383 export function AnnouncementSignatures_get_channel_id(this_ptr: number): number {
21384 if(!isWasmInitialized) {
21385 throw new Error("initializeWasm() must be awaited first!");
21387 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_channel_id(this_ptr);
21388 return nativeResponseValue;
21390 // void AnnouncementSignatures_set_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21392 export function AnnouncementSignatures_set_channel_id(this_ptr: number, val: number): void {
21393 if(!isWasmInitialized) {
21394 throw new Error("initializeWasm() must be awaited first!");
21396 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_channel_id(this_ptr, val);
21397 // debug statements here
21399 // uint64_t AnnouncementSignatures_get_short_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
21401 export function AnnouncementSignatures_get_short_channel_id(this_ptr: number): bigint {
21402 if(!isWasmInitialized) {
21403 throw new Error("initializeWasm() must be awaited first!");
21405 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_short_channel_id(this_ptr);
21406 return nativeResponseValue;
21408 // void AnnouncementSignatures_set_short_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, uint64_t val);
21410 export function AnnouncementSignatures_set_short_channel_id(this_ptr: number, val: bigint): void {
21411 if(!isWasmInitialized) {
21412 throw new Error("initializeWasm() must be awaited first!");
21414 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_short_channel_id(this_ptr, val);
21415 // debug statements here
21417 // struct LDKSignature AnnouncementSignatures_get_node_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
21419 export function AnnouncementSignatures_get_node_signature(this_ptr: number): number {
21420 if(!isWasmInitialized) {
21421 throw new Error("initializeWasm() must be awaited first!");
21423 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_node_signature(this_ptr);
21424 return nativeResponseValue;
21426 // void AnnouncementSignatures_set_node_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
21428 export function AnnouncementSignatures_set_node_signature(this_ptr: number, val: number): void {
21429 if(!isWasmInitialized) {
21430 throw new Error("initializeWasm() must be awaited first!");
21432 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_node_signature(this_ptr, val);
21433 // debug statements here
21435 // struct LDKSignature AnnouncementSignatures_get_bitcoin_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
21437 export function AnnouncementSignatures_get_bitcoin_signature(this_ptr: number): number {
21438 if(!isWasmInitialized) {
21439 throw new Error("initializeWasm() must be awaited first!");
21441 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_bitcoin_signature(this_ptr);
21442 return nativeResponseValue;
21444 // void AnnouncementSignatures_set_bitcoin_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
21446 export function AnnouncementSignatures_set_bitcoin_signature(this_ptr: number, val: number): void {
21447 if(!isWasmInitialized) {
21448 throw new Error("initializeWasm() must be awaited first!");
21450 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_bitcoin_signature(this_ptr, val);
21451 // debug statements here
21453 // 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);
21455 export function AnnouncementSignatures_new(channel_id_arg: number, short_channel_id_arg: bigint, node_signature_arg: number, bitcoin_signature_arg: number): number {
21456 if(!isWasmInitialized) {
21457 throw new Error("initializeWasm() must be awaited first!");
21459 const nativeResponseValue = wasm.TS_AnnouncementSignatures_new(channel_id_arg, short_channel_id_arg, node_signature_arg, bitcoin_signature_arg);
21460 return nativeResponseValue;
21462 // uintptr_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg);
21464 export function AnnouncementSignatures_clone_ptr(arg: number): number {
21465 if(!isWasmInitialized) {
21466 throw new Error("initializeWasm() must be awaited first!");
21468 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone_ptr(arg);
21469 return nativeResponseValue;
21471 // struct LDKAnnouncementSignatures AnnouncementSignatures_clone(const struct LDKAnnouncementSignatures *NONNULL_PTR orig);
21473 export function AnnouncementSignatures_clone(orig: number): number {
21474 if(!isWasmInitialized) {
21475 throw new Error("initializeWasm() must be awaited first!");
21477 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone(orig);
21478 return nativeResponseValue;
21480 // void NetAddress_free(struct LDKNetAddress this_ptr);
21482 export function NetAddress_free(this_ptr: number): void {
21483 if(!isWasmInitialized) {
21484 throw new Error("initializeWasm() must be awaited first!");
21486 const nativeResponseValue = wasm.TS_NetAddress_free(this_ptr);
21487 // debug statements here
21489 // uintptr_t NetAddress_clone_ptr(LDKNetAddress *NONNULL_PTR arg);
21491 export function NetAddress_clone_ptr(arg: number): number {
21492 if(!isWasmInitialized) {
21493 throw new Error("initializeWasm() must be awaited first!");
21495 const nativeResponseValue = wasm.TS_NetAddress_clone_ptr(arg);
21496 return nativeResponseValue;
21498 // struct LDKNetAddress NetAddress_clone(const struct LDKNetAddress *NONNULL_PTR orig);
21500 export function NetAddress_clone(orig: number): number {
21501 if(!isWasmInitialized) {
21502 throw new Error("initializeWasm() must be awaited first!");
21504 const nativeResponseValue = wasm.TS_NetAddress_clone(orig);
21505 return nativeResponseValue;
21507 // struct LDKNetAddress NetAddress_ipv4(struct LDKFourBytes addr, uint16_t port);
21509 export function NetAddress_ipv4(addr: number, port: number): number {
21510 if(!isWasmInitialized) {
21511 throw new Error("initializeWasm() must be awaited first!");
21513 const nativeResponseValue = wasm.TS_NetAddress_ipv4(addr, port);
21514 return nativeResponseValue;
21516 // struct LDKNetAddress NetAddress_ipv6(struct LDKSixteenBytes addr, uint16_t port);
21518 export function NetAddress_ipv6(addr: number, port: number): number {
21519 if(!isWasmInitialized) {
21520 throw new Error("initializeWasm() must be awaited first!");
21522 const nativeResponseValue = wasm.TS_NetAddress_ipv6(addr, port);
21523 return nativeResponseValue;
21525 // struct LDKNetAddress NetAddress_onion_v2(struct LDKTwelveBytes a);
21527 export function NetAddress_onion_v2(a: number): number {
21528 if(!isWasmInitialized) {
21529 throw new Error("initializeWasm() must be awaited first!");
21531 const nativeResponseValue = wasm.TS_NetAddress_onion_v2(a);
21532 return nativeResponseValue;
21534 // struct LDKNetAddress NetAddress_onion_v3(struct LDKThirtyTwoBytes ed25519_pubkey, uint16_t checksum, uint8_t version, uint16_t port);
21536 export function NetAddress_onion_v3(ed25519_pubkey: number, checksum: number, version: number, port: number): number {
21537 if(!isWasmInitialized) {
21538 throw new Error("initializeWasm() must be awaited first!");
21540 const nativeResponseValue = wasm.TS_NetAddress_onion_v3(ed25519_pubkey, checksum, version, port);
21541 return nativeResponseValue;
21543 // struct LDKCVec_u8Z NetAddress_write(const struct LDKNetAddress *NONNULL_PTR obj);
21545 export function NetAddress_write(obj: number): number {
21546 if(!isWasmInitialized) {
21547 throw new Error("initializeWasm() must be awaited first!");
21549 const nativeResponseValue = wasm.TS_NetAddress_write(obj);
21550 return nativeResponseValue;
21552 // struct LDKCResult_NetAddressDecodeErrorZ NetAddress_read(struct LDKu8slice ser);
21554 export function NetAddress_read(ser: number): number {
21555 if(!isWasmInitialized) {
21556 throw new Error("initializeWasm() must be awaited first!");
21558 const nativeResponseValue = wasm.TS_NetAddress_read(ser);
21559 return nativeResponseValue;
21561 // void UnsignedNodeAnnouncement_free(struct LDKUnsignedNodeAnnouncement this_obj);
21563 export function UnsignedNodeAnnouncement_free(this_obj: number): void {
21564 if(!isWasmInitialized) {
21565 throw new Error("initializeWasm() must be awaited first!");
21567 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_free(this_obj);
21568 // debug statements here
21570 // struct LDKNodeFeatures UnsignedNodeAnnouncement_get_features(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
21572 export function UnsignedNodeAnnouncement_get_features(this_ptr: number): number {
21573 if(!isWasmInitialized) {
21574 throw new Error("initializeWasm() must be awaited first!");
21576 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_features(this_ptr);
21577 return nativeResponseValue;
21579 // void UnsignedNodeAnnouncement_set_features(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
21581 export function UnsignedNodeAnnouncement_set_features(this_ptr: number, val: number): void {
21582 if(!isWasmInitialized) {
21583 throw new Error("initializeWasm() must be awaited first!");
21585 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_features(this_ptr, val);
21586 // debug statements here
21588 // uint32_t UnsignedNodeAnnouncement_get_timestamp(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
21590 export function UnsignedNodeAnnouncement_get_timestamp(this_ptr: number): number {
21591 if(!isWasmInitialized) {
21592 throw new Error("initializeWasm() must be awaited first!");
21594 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_timestamp(this_ptr);
21595 return nativeResponseValue;
21597 // void UnsignedNodeAnnouncement_set_timestamp(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, uint32_t val);
21599 export function UnsignedNodeAnnouncement_set_timestamp(this_ptr: number, val: number): void {
21600 if(!isWasmInitialized) {
21601 throw new Error("initializeWasm() must be awaited first!");
21603 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_timestamp(this_ptr, val);
21604 // debug statements here
21606 // struct LDKPublicKey UnsignedNodeAnnouncement_get_node_id(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
21608 export function UnsignedNodeAnnouncement_get_node_id(this_ptr: number): number {
21609 if(!isWasmInitialized) {
21610 throw new Error("initializeWasm() must be awaited first!");
21612 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_node_id(this_ptr);
21613 return nativeResponseValue;
21615 // void UnsignedNodeAnnouncement_set_node_id(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21617 export function UnsignedNodeAnnouncement_set_node_id(this_ptr: number, val: number): void {
21618 if(!isWasmInitialized) {
21619 throw new Error("initializeWasm() must be awaited first!");
21621 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_node_id(this_ptr, val);
21622 // debug statements here
21624 // const uint8_t (*UnsignedNodeAnnouncement_get_rgb(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[3];
21626 export function UnsignedNodeAnnouncement_get_rgb(this_ptr: number): number {
21627 if(!isWasmInitialized) {
21628 throw new Error("initializeWasm() must be awaited first!");
21630 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_rgb(this_ptr);
21631 return nativeResponseValue;
21633 // void UnsignedNodeAnnouncement_set_rgb(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
21635 export function UnsignedNodeAnnouncement_set_rgb(this_ptr: number, val: number): void {
21636 if(!isWasmInitialized) {
21637 throw new Error("initializeWasm() must be awaited first!");
21639 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_rgb(this_ptr, val);
21640 // debug statements here
21642 // const uint8_t (*UnsignedNodeAnnouncement_get_alias(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[32];
21644 export function UnsignedNodeAnnouncement_get_alias(this_ptr: number): number {
21645 if(!isWasmInitialized) {
21646 throw new Error("initializeWasm() must be awaited first!");
21648 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_alias(this_ptr);
21649 return nativeResponseValue;
21651 // void UnsignedNodeAnnouncement_set_alias(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21653 export function UnsignedNodeAnnouncement_set_alias(this_ptr: number, val: number): void {
21654 if(!isWasmInitialized) {
21655 throw new Error("initializeWasm() must be awaited first!");
21657 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_alias(this_ptr, val);
21658 // debug statements here
21660 // void UnsignedNodeAnnouncement_set_addresses(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
21662 export function UnsignedNodeAnnouncement_set_addresses(this_ptr: number, val: number): void {
21663 if(!isWasmInitialized) {
21664 throw new Error("initializeWasm() must be awaited first!");
21666 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_addresses(this_ptr, val);
21667 // debug statements here
21669 // uintptr_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg);
21671 export function UnsignedNodeAnnouncement_clone_ptr(arg: number): number {
21672 if(!isWasmInitialized) {
21673 throw new Error("initializeWasm() must be awaited first!");
21675 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone_ptr(arg);
21676 return nativeResponseValue;
21678 // struct LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_clone(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR orig);
21680 export function UnsignedNodeAnnouncement_clone(orig: number): number {
21681 if(!isWasmInitialized) {
21682 throw new Error("initializeWasm() must be awaited first!");
21684 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone(orig);
21685 return nativeResponseValue;
21687 // void NodeAnnouncement_free(struct LDKNodeAnnouncement this_obj);
21689 export function NodeAnnouncement_free(this_obj: number): void {
21690 if(!isWasmInitialized) {
21691 throw new Error("initializeWasm() must be awaited first!");
21693 const nativeResponseValue = wasm.TS_NodeAnnouncement_free(this_obj);
21694 // debug statements here
21696 // struct LDKSignature NodeAnnouncement_get_signature(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
21698 export function NodeAnnouncement_get_signature(this_ptr: number): number {
21699 if(!isWasmInitialized) {
21700 throw new Error("initializeWasm() must be awaited first!");
21702 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_signature(this_ptr);
21703 return nativeResponseValue;
21705 // void NodeAnnouncement_set_signature(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
21707 export function NodeAnnouncement_set_signature(this_ptr: number, val: number): void {
21708 if(!isWasmInitialized) {
21709 throw new Error("initializeWasm() must be awaited first!");
21711 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_signature(this_ptr, val);
21712 // debug statements here
21714 // struct LDKUnsignedNodeAnnouncement NodeAnnouncement_get_contents(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
21716 export function NodeAnnouncement_get_contents(this_ptr: number): number {
21717 if(!isWasmInitialized) {
21718 throw new Error("initializeWasm() must be awaited first!");
21720 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_contents(this_ptr);
21721 return nativeResponseValue;
21723 // void NodeAnnouncement_set_contents(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedNodeAnnouncement val);
21725 export function NodeAnnouncement_set_contents(this_ptr: number, val: number): void {
21726 if(!isWasmInitialized) {
21727 throw new Error("initializeWasm() must be awaited first!");
21729 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_contents(this_ptr, val);
21730 // debug statements here
21732 // MUST_USE_RES struct LDKNodeAnnouncement NodeAnnouncement_new(struct LDKSignature signature_arg, struct LDKUnsignedNodeAnnouncement contents_arg);
21734 export function NodeAnnouncement_new(signature_arg: number, contents_arg: number): number {
21735 if(!isWasmInitialized) {
21736 throw new Error("initializeWasm() must be awaited first!");
21738 const nativeResponseValue = wasm.TS_NodeAnnouncement_new(signature_arg, contents_arg);
21739 return nativeResponseValue;
21741 // uintptr_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg);
21743 export function NodeAnnouncement_clone_ptr(arg: number): number {
21744 if(!isWasmInitialized) {
21745 throw new Error("initializeWasm() must be awaited first!");
21747 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone_ptr(arg);
21748 return nativeResponseValue;
21750 // struct LDKNodeAnnouncement NodeAnnouncement_clone(const struct LDKNodeAnnouncement *NONNULL_PTR orig);
21752 export function NodeAnnouncement_clone(orig: number): number {
21753 if(!isWasmInitialized) {
21754 throw new Error("initializeWasm() must be awaited first!");
21756 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone(orig);
21757 return nativeResponseValue;
21759 // void UnsignedChannelAnnouncement_free(struct LDKUnsignedChannelAnnouncement this_obj);
21761 export function UnsignedChannelAnnouncement_free(this_obj: number): void {
21762 if(!isWasmInitialized) {
21763 throw new Error("initializeWasm() must be awaited first!");
21765 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_free(this_obj);
21766 // debug statements here
21768 // struct LDKChannelFeatures UnsignedChannelAnnouncement_get_features(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
21770 export function UnsignedChannelAnnouncement_get_features(this_ptr: number): number {
21771 if(!isWasmInitialized) {
21772 throw new Error("initializeWasm() must be awaited first!");
21774 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_features(this_ptr);
21775 return nativeResponseValue;
21777 // void UnsignedChannelAnnouncement_set_features(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
21779 export function UnsignedChannelAnnouncement_set_features(this_ptr: number, val: number): void {
21780 if(!isWasmInitialized) {
21781 throw new Error("initializeWasm() must be awaited first!");
21783 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_features(this_ptr, val);
21784 // debug statements here
21786 // const uint8_t (*UnsignedChannelAnnouncement_get_chain_hash(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr))[32];
21788 export function UnsignedChannelAnnouncement_get_chain_hash(this_ptr: number): number {
21789 if(!isWasmInitialized) {
21790 throw new Error("initializeWasm() must be awaited first!");
21792 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_chain_hash(this_ptr);
21793 return nativeResponseValue;
21795 // void UnsignedChannelAnnouncement_set_chain_hash(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21797 export function UnsignedChannelAnnouncement_set_chain_hash(this_ptr: number, val: number): void {
21798 if(!isWasmInitialized) {
21799 throw new Error("initializeWasm() must be awaited first!");
21801 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_chain_hash(this_ptr, val);
21802 // debug statements here
21804 // uint64_t UnsignedChannelAnnouncement_get_short_channel_id(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
21806 export function UnsignedChannelAnnouncement_get_short_channel_id(this_ptr: number): bigint {
21807 if(!isWasmInitialized) {
21808 throw new Error("initializeWasm() must be awaited first!");
21810 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_short_channel_id(this_ptr);
21811 return nativeResponseValue;
21813 // void UnsignedChannelAnnouncement_set_short_channel_id(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, uint64_t val);
21815 export function UnsignedChannelAnnouncement_set_short_channel_id(this_ptr: number, val: bigint): void {
21816 if(!isWasmInitialized) {
21817 throw new Error("initializeWasm() must be awaited first!");
21819 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_short_channel_id(this_ptr, val);
21820 // debug statements here
21822 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
21824 export function UnsignedChannelAnnouncement_get_node_id_1(this_ptr: number): number {
21825 if(!isWasmInitialized) {
21826 throw new Error("initializeWasm() must be awaited first!");
21828 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_1(this_ptr);
21829 return nativeResponseValue;
21831 // void UnsignedChannelAnnouncement_set_node_id_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21833 export function UnsignedChannelAnnouncement_set_node_id_1(this_ptr: number, val: number): void {
21834 if(!isWasmInitialized) {
21835 throw new Error("initializeWasm() must be awaited first!");
21837 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_1(this_ptr, val);
21838 // debug statements here
21840 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
21842 export function UnsignedChannelAnnouncement_get_node_id_2(this_ptr: number): number {
21843 if(!isWasmInitialized) {
21844 throw new Error("initializeWasm() must be awaited first!");
21846 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_2(this_ptr);
21847 return nativeResponseValue;
21849 // void UnsignedChannelAnnouncement_set_node_id_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21851 export function UnsignedChannelAnnouncement_set_node_id_2(this_ptr: number, val: number): void {
21852 if(!isWasmInitialized) {
21853 throw new Error("initializeWasm() must be awaited first!");
21855 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_2(this_ptr, val);
21856 // debug statements here
21858 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
21860 export function UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr: number): number {
21861 if(!isWasmInitialized) {
21862 throw new Error("initializeWasm() must be awaited first!");
21864 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr);
21865 return nativeResponseValue;
21867 // void UnsignedChannelAnnouncement_set_bitcoin_key_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21869 export function UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr: number, val: number): void {
21870 if(!isWasmInitialized) {
21871 throw new Error("initializeWasm() must be awaited first!");
21873 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr, val);
21874 // debug statements here
21876 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
21878 export function UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr: number): number {
21879 if(!isWasmInitialized) {
21880 throw new Error("initializeWasm() must be awaited first!");
21882 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr);
21883 return nativeResponseValue;
21885 // void UnsignedChannelAnnouncement_set_bitcoin_key_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21887 export function UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr: number, val: number): void {
21888 if(!isWasmInitialized) {
21889 throw new Error("initializeWasm() must be awaited first!");
21891 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr, val);
21892 // debug statements here
21894 // uintptr_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg);
21896 export function UnsignedChannelAnnouncement_clone_ptr(arg: number): number {
21897 if(!isWasmInitialized) {
21898 throw new Error("initializeWasm() must be awaited first!");
21900 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone_ptr(arg);
21901 return nativeResponseValue;
21903 // struct LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_clone(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR orig);
21905 export function UnsignedChannelAnnouncement_clone(orig: number): number {
21906 if(!isWasmInitialized) {
21907 throw new Error("initializeWasm() must be awaited first!");
21909 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone(orig);
21910 return nativeResponseValue;
21912 // void ChannelAnnouncement_free(struct LDKChannelAnnouncement this_obj);
21914 export function ChannelAnnouncement_free(this_obj: number): void {
21915 if(!isWasmInitialized) {
21916 throw new Error("initializeWasm() must be awaited first!");
21918 const nativeResponseValue = wasm.TS_ChannelAnnouncement_free(this_obj);
21919 // debug statements here
21921 // struct LDKSignature ChannelAnnouncement_get_node_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
21923 export function ChannelAnnouncement_get_node_signature_1(this_ptr: number): number {
21924 if(!isWasmInitialized) {
21925 throw new Error("initializeWasm() must be awaited first!");
21927 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_1(this_ptr);
21928 return nativeResponseValue;
21930 // void ChannelAnnouncement_set_node_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
21932 export function ChannelAnnouncement_set_node_signature_1(this_ptr: number, val: number): void {
21933 if(!isWasmInitialized) {
21934 throw new Error("initializeWasm() must be awaited first!");
21936 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_1(this_ptr, val);
21937 // debug statements here
21939 // struct LDKSignature ChannelAnnouncement_get_node_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
21941 export function ChannelAnnouncement_get_node_signature_2(this_ptr: number): number {
21942 if(!isWasmInitialized) {
21943 throw new Error("initializeWasm() must be awaited first!");
21945 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_2(this_ptr);
21946 return nativeResponseValue;
21948 // void ChannelAnnouncement_set_node_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
21950 export function ChannelAnnouncement_set_node_signature_2(this_ptr: number, val: number): void {
21951 if(!isWasmInitialized) {
21952 throw new Error("initializeWasm() must be awaited first!");
21954 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_2(this_ptr, val);
21955 // debug statements here
21957 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
21959 export function ChannelAnnouncement_get_bitcoin_signature_1(this_ptr: number): number {
21960 if(!isWasmInitialized) {
21961 throw new Error("initializeWasm() must be awaited first!");
21963 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_1(this_ptr);
21964 return nativeResponseValue;
21966 // void ChannelAnnouncement_set_bitcoin_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
21968 export function ChannelAnnouncement_set_bitcoin_signature_1(this_ptr: number, val: number): void {
21969 if(!isWasmInitialized) {
21970 throw new Error("initializeWasm() must be awaited first!");
21972 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_1(this_ptr, val);
21973 // debug statements here
21975 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
21977 export function ChannelAnnouncement_get_bitcoin_signature_2(this_ptr: number): number {
21978 if(!isWasmInitialized) {
21979 throw new Error("initializeWasm() must be awaited first!");
21981 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_2(this_ptr);
21982 return nativeResponseValue;
21984 // void ChannelAnnouncement_set_bitcoin_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
21986 export function ChannelAnnouncement_set_bitcoin_signature_2(this_ptr: number, val: number): void {
21987 if(!isWasmInitialized) {
21988 throw new Error("initializeWasm() must be awaited first!");
21990 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_2(this_ptr, val);
21991 // debug statements here
21993 // struct LDKUnsignedChannelAnnouncement ChannelAnnouncement_get_contents(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
21995 export function ChannelAnnouncement_get_contents(this_ptr: number): number {
21996 if(!isWasmInitialized) {
21997 throw new Error("initializeWasm() must be awaited first!");
21999 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_contents(this_ptr);
22000 return nativeResponseValue;
22002 // void ChannelAnnouncement_set_contents(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedChannelAnnouncement val);
22004 export function ChannelAnnouncement_set_contents(this_ptr: number, val: number): void {
22005 if(!isWasmInitialized) {
22006 throw new Error("initializeWasm() must be awaited first!");
22008 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_contents(this_ptr, val);
22009 // debug statements here
22011 // 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);
22013 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 {
22014 if(!isWasmInitialized) {
22015 throw new Error("initializeWasm() must be awaited first!");
22017 const nativeResponseValue = wasm.TS_ChannelAnnouncement_new(node_signature_1_arg, node_signature_2_arg, bitcoin_signature_1_arg, bitcoin_signature_2_arg, contents_arg);
22018 return nativeResponseValue;
22020 // uintptr_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg);
22022 export function ChannelAnnouncement_clone_ptr(arg: number): number {
22023 if(!isWasmInitialized) {
22024 throw new Error("initializeWasm() must be awaited first!");
22026 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone_ptr(arg);
22027 return nativeResponseValue;
22029 // struct LDKChannelAnnouncement ChannelAnnouncement_clone(const struct LDKChannelAnnouncement *NONNULL_PTR orig);
22031 export function ChannelAnnouncement_clone(orig: number): number {
22032 if(!isWasmInitialized) {
22033 throw new Error("initializeWasm() must be awaited first!");
22035 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone(orig);
22036 return nativeResponseValue;
22038 // void UnsignedChannelUpdate_free(struct LDKUnsignedChannelUpdate this_obj);
22040 export function UnsignedChannelUpdate_free(this_obj: number): void {
22041 if(!isWasmInitialized) {
22042 throw new Error("initializeWasm() must be awaited first!");
22044 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_free(this_obj);
22045 // debug statements here
22047 // const uint8_t (*UnsignedChannelUpdate_get_chain_hash(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr))[32];
22049 export function UnsignedChannelUpdate_get_chain_hash(this_ptr: number): number {
22050 if(!isWasmInitialized) {
22051 throw new Error("initializeWasm() must be awaited first!");
22053 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_chain_hash(this_ptr);
22054 return nativeResponseValue;
22056 // void UnsignedChannelUpdate_set_chain_hash(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22058 export function UnsignedChannelUpdate_set_chain_hash(this_ptr: number, val: number): void {
22059 if(!isWasmInitialized) {
22060 throw new Error("initializeWasm() must be awaited first!");
22062 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_chain_hash(this_ptr, val);
22063 // debug statements here
22065 // uint64_t UnsignedChannelUpdate_get_short_channel_id(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
22067 export function UnsignedChannelUpdate_get_short_channel_id(this_ptr: number): bigint {
22068 if(!isWasmInitialized) {
22069 throw new Error("initializeWasm() must be awaited first!");
22071 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_short_channel_id(this_ptr);
22072 return nativeResponseValue;
22074 // void UnsignedChannelUpdate_set_short_channel_id(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
22076 export function UnsignedChannelUpdate_set_short_channel_id(this_ptr: number, val: bigint): void {
22077 if(!isWasmInitialized) {
22078 throw new Error("initializeWasm() must be awaited first!");
22080 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_short_channel_id(this_ptr, val);
22081 // debug statements here
22083 // uint32_t UnsignedChannelUpdate_get_timestamp(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
22085 export function UnsignedChannelUpdate_get_timestamp(this_ptr: number): number {
22086 if(!isWasmInitialized) {
22087 throw new Error("initializeWasm() must be awaited first!");
22089 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_timestamp(this_ptr);
22090 return nativeResponseValue;
22092 // void UnsignedChannelUpdate_set_timestamp(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
22094 export function UnsignedChannelUpdate_set_timestamp(this_ptr: number, val: number): void {
22095 if(!isWasmInitialized) {
22096 throw new Error("initializeWasm() must be awaited first!");
22098 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_timestamp(this_ptr, val);
22099 // debug statements here
22101 // uint8_t UnsignedChannelUpdate_get_flags(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
22103 export function UnsignedChannelUpdate_get_flags(this_ptr: number): number {
22104 if(!isWasmInitialized) {
22105 throw new Error("initializeWasm() must be awaited first!");
22107 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_flags(this_ptr);
22108 return nativeResponseValue;
22110 // void UnsignedChannelUpdate_set_flags(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint8_t val);
22112 export function UnsignedChannelUpdate_set_flags(this_ptr: number, val: number): void {
22113 if(!isWasmInitialized) {
22114 throw new Error("initializeWasm() must be awaited first!");
22116 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_flags(this_ptr, val);
22117 // debug statements here
22119 // uint16_t UnsignedChannelUpdate_get_cltv_expiry_delta(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
22121 export function UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr: number): number {
22122 if(!isWasmInitialized) {
22123 throw new Error("initializeWasm() must be awaited first!");
22125 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr);
22126 return nativeResponseValue;
22128 // void UnsignedChannelUpdate_set_cltv_expiry_delta(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint16_t val);
22130 export function UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr: number, val: number): void {
22131 if(!isWasmInitialized) {
22132 throw new Error("initializeWasm() must be awaited first!");
22134 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr, val);
22135 // debug statements here
22137 // uint64_t UnsignedChannelUpdate_get_htlc_minimum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
22139 export function UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr: number): bigint {
22140 if(!isWasmInitialized) {
22141 throw new Error("initializeWasm() must be awaited first!");
22143 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr);
22144 return nativeResponseValue;
22146 // void UnsignedChannelUpdate_set_htlc_minimum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
22148 export function UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
22149 if(!isWasmInitialized) {
22150 throw new Error("initializeWasm() must be awaited first!");
22152 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr, val);
22153 // debug statements here
22155 // uint32_t UnsignedChannelUpdate_get_fee_base_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
22157 export function UnsignedChannelUpdate_get_fee_base_msat(this_ptr: number): number {
22158 if(!isWasmInitialized) {
22159 throw new Error("initializeWasm() must be awaited first!");
22161 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_base_msat(this_ptr);
22162 return nativeResponseValue;
22164 // void UnsignedChannelUpdate_set_fee_base_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
22166 export function UnsignedChannelUpdate_set_fee_base_msat(this_ptr: number, val: number): void {
22167 if(!isWasmInitialized) {
22168 throw new Error("initializeWasm() must be awaited first!");
22170 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_base_msat(this_ptr, val);
22171 // debug statements here
22173 // uint32_t UnsignedChannelUpdate_get_fee_proportional_millionths(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
22175 export function UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr: number): number {
22176 if(!isWasmInitialized) {
22177 throw new Error("initializeWasm() must be awaited first!");
22179 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr);
22180 return nativeResponseValue;
22182 // void UnsignedChannelUpdate_set_fee_proportional_millionths(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
22184 export function UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr: number, val: number): void {
22185 if(!isWasmInitialized) {
22186 throw new Error("initializeWasm() must be awaited first!");
22188 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr, val);
22189 // debug statements here
22191 // uintptr_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg);
22193 export function UnsignedChannelUpdate_clone_ptr(arg: number): number {
22194 if(!isWasmInitialized) {
22195 throw new Error("initializeWasm() must be awaited first!");
22197 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone_ptr(arg);
22198 return nativeResponseValue;
22200 // struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_clone(const struct LDKUnsignedChannelUpdate *NONNULL_PTR orig);
22202 export function UnsignedChannelUpdate_clone(orig: number): number {
22203 if(!isWasmInitialized) {
22204 throw new Error("initializeWasm() must be awaited first!");
22206 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone(orig);
22207 return nativeResponseValue;
22209 // void ChannelUpdate_free(struct LDKChannelUpdate this_obj);
22211 export function ChannelUpdate_free(this_obj: number): void {
22212 if(!isWasmInitialized) {
22213 throw new Error("initializeWasm() must be awaited first!");
22215 const nativeResponseValue = wasm.TS_ChannelUpdate_free(this_obj);
22216 // debug statements here
22218 // struct LDKSignature ChannelUpdate_get_signature(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
22220 export function ChannelUpdate_get_signature(this_ptr: number): number {
22221 if(!isWasmInitialized) {
22222 throw new Error("initializeWasm() must be awaited first!");
22224 const nativeResponseValue = wasm.TS_ChannelUpdate_get_signature(this_ptr);
22225 return nativeResponseValue;
22227 // void ChannelUpdate_set_signature(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKSignature val);
22229 export function ChannelUpdate_set_signature(this_ptr: number, val: number): void {
22230 if(!isWasmInitialized) {
22231 throw new Error("initializeWasm() must be awaited first!");
22233 const nativeResponseValue = wasm.TS_ChannelUpdate_set_signature(this_ptr, val);
22234 // debug statements here
22236 // struct LDKUnsignedChannelUpdate ChannelUpdate_get_contents(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
22238 export function ChannelUpdate_get_contents(this_ptr: number): number {
22239 if(!isWasmInitialized) {
22240 throw new Error("initializeWasm() must be awaited first!");
22242 const nativeResponseValue = wasm.TS_ChannelUpdate_get_contents(this_ptr);
22243 return nativeResponseValue;
22245 // void ChannelUpdate_set_contents(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKUnsignedChannelUpdate val);
22247 export function ChannelUpdate_set_contents(this_ptr: number, val: number): void {
22248 if(!isWasmInitialized) {
22249 throw new Error("initializeWasm() must be awaited first!");
22251 const nativeResponseValue = wasm.TS_ChannelUpdate_set_contents(this_ptr, val);
22252 // debug statements here
22254 // MUST_USE_RES struct LDKChannelUpdate ChannelUpdate_new(struct LDKSignature signature_arg, struct LDKUnsignedChannelUpdate contents_arg);
22256 export function ChannelUpdate_new(signature_arg: number, contents_arg: number): number {
22257 if(!isWasmInitialized) {
22258 throw new Error("initializeWasm() must be awaited first!");
22260 const nativeResponseValue = wasm.TS_ChannelUpdate_new(signature_arg, contents_arg);
22261 return nativeResponseValue;
22263 // uintptr_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg);
22265 export function ChannelUpdate_clone_ptr(arg: number): number {
22266 if(!isWasmInitialized) {
22267 throw new Error("initializeWasm() must be awaited first!");
22269 const nativeResponseValue = wasm.TS_ChannelUpdate_clone_ptr(arg);
22270 return nativeResponseValue;
22272 // struct LDKChannelUpdate ChannelUpdate_clone(const struct LDKChannelUpdate *NONNULL_PTR orig);
22274 export function ChannelUpdate_clone(orig: number): number {
22275 if(!isWasmInitialized) {
22276 throw new Error("initializeWasm() must be awaited first!");
22278 const nativeResponseValue = wasm.TS_ChannelUpdate_clone(orig);
22279 return nativeResponseValue;
22281 // void QueryChannelRange_free(struct LDKQueryChannelRange this_obj);
22283 export function QueryChannelRange_free(this_obj: number): void {
22284 if(!isWasmInitialized) {
22285 throw new Error("initializeWasm() must be awaited first!");
22287 const nativeResponseValue = wasm.TS_QueryChannelRange_free(this_obj);
22288 // debug statements here
22290 // const uint8_t (*QueryChannelRange_get_chain_hash(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr))[32];
22292 export function QueryChannelRange_get_chain_hash(this_ptr: number): number {
22293 if(!isWasmInitialized) {
22294 throw new Error("initializeWasm() must be awaited first!");
22296 const nativeResponseValue = wasm.TS_QueryChannelRange_get_chain_hash(this_ptr);
22297 return nativeResponseValue;
22299 // void QueryChannelRange_set_chain_hash(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22301 export function QueryChannelRange_set_chain_hash(this_ptr: number, val: number): void {
22302 if(!isWasmInitialized) {
22303 throw new Error("initializeWasm() must be awaited first!");
22305 const nativeResponseValue = wasm.TS_QueryChannelRange_set_chain_hash(this_ptr, val);
22306 // debug statements here
22308 // uint32_t QueryChannelRange_get_first_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
22310 export function QueryChannelRange_get_first_blocknum(this_ptr: number): number {
22311 if(!isWasmInitialized) {
22312 throw new Error("initializeWasm() must be awaited first!");
22314 const nativeResponseValue = wasm.TS_QueryChannelRange_get_first_blocknum(this_ptr);
22315 return nativeResponseValue;
22317 // void QueryChannelRange_set_first_blocknum(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
22319 export function QueryChannelRange_set_first_blocknum(this_ptr: number, val: number): void {
22320 if(!isWasmInitialized) {
22321 throw new Error("initializeWasm() must be awaited first!");
22323 const nativeResponseValue = wasm.TS_QueryChannelRange_set_first_blocknum(this_ptr, val);
22324 // debug statements here
22326 // uint32_t QueryChannelRange_get_number_of_blocks(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
22328 export function QueryChannelRange_get_number_of_blocks(this_ptr: number): number {
22329 if(!isWasmInitialized) {
22330 throw new Error("initializeWasm() must be awaited first!");
22332 const nativeResponseValue = wasm.TS_QueryChannelRange_get_number_of_blocks(this_ptr);
22333 return nativeResponseValue;
22335 // void QueryChannelRange_set_number_of_blocks(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
22337 export function QueryChannelRange_set_number_of_blocks(this_ptr: number, val: number): void {
22338 if(!isWasmInitialized) {
22339 throw new Error("initializeWasm() must be awaited first!");
22341 const nativeResponseValue = wasm.TS_QueryChannelRange_set_number_of_blocks(this_ptr, val);
22342 // debug statements here
22344 // MUST_USE_RES struct LDKQueryChannelRange QueryChannelRange_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_blocknum_arg, uint32_t number_of_blocks_arg);
22346 export function QueryChannelRange_new(chain_hash_arg: number, first_blocknum_arg: number, number_of_blocks_arg: number): number {
22347 if(!isWasmInitialized) {
22348 throw new Error("initializeWasm() must be awaited first!");
22350 const nativeResponseValue = wasm.TS_QueryChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg);
22351 return nativeResponseValue;
22353 // uintptr_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg);
22355 export function QueryChannelRange_clone_ptr(arg: number): number {
22356 if(!isWasmInitialized) {
22357 throw new Error("initializeWasm() must be awaited first!");
22359 const nativeResponseValue = wasm.TS_QueryChannelRange_clone_ptr(arg);
22360 return nativeResponseValue;
22362 // struct LDKQueryChannelRange QueryChannelRange_clone(const struct LDKQueryChannelRange *NONNULL_PTR orig);
22364 export function QueryChannelRange_clone(orig: number): number {
22365 if(!isWasmInitialized) {
22366 throw new Error("initializeWasm() must be awaited first!");
22368 const nativeResponseValue = wasm.TS_QueryChannelRange_clone(orig);
22369 return nativeResponseValue;
22371 // void ReplyChannelRange_free(struct LDKReplyChannelRange this_obj);
22373 export function ReplyChannelRange_free(this_obj: number): void {
22374 if(!isWasmInitialized) {
22375 throw new Error("initializeWasm() must be awaited first!");
22377 const nativeResponseValue = wasm.TS_ReplyChannelRange_free(this_obj);
22378 // debug statements here
22380 // const uint8_t (*ReplyChannelRange_get_chain_hash(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr))[32];
22382 export function ReplyChannelRange_get_chain_hash(this_ptr: number): number {
22383 if(!isWasmInitialized) {
22384 throw new Error("initializeWasm() must be awaited first!");
22386 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_chain_hash(this_ptr);
22387 return nativeResponseValue;
22389 // void ReplyChannelRange_set_chain_hash(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22391 export function ReplyChannelRange_set_chain_hash(this_ptr: number, val: number): void {
22392 if(!isWasmInitialized) {
22393 throw new Error("initializeWasm() must be awaited first!");
22395 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_chain_hash(this_ptr, val);
22396 // debug statements here
22398 // uint32_t ReplyChannelRange_get_first_blocknum(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
22400 export function ReplyChannelRange_get_first_blocknum(this_ptr: number): number {
22401 if(!isWasmInitialized) {
22402 throw new Error("initializeWasm() must be awaited first!");
22404 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_first_blocknum(this_ptr);
22405 return nativeResponseValue;
22407 // void ReplyChannelRange_set_first_blocknum(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
22409 export function ReplyChannelRange_set_first_blocknum(this_ptr: number, val: number): void {
22410 if(!isWasmInitialized) {
22411 throw new Error("initializeWasm() must be awaited first!");
22413 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_first_blocknum(this_ptr, val);
22414 // debug statements here
22416 // uint32_t ReplyChannelRange_get_number_of_blocks(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
22418 export function ReplyChannelRange_get_number_of_blocks(this_ptr: number): number {
22419 if(!isWasmInitialized) {
22420 throw new Error("initializeWasm() must be awaited first!");
22422 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_number_of_blocks(this_ptr);
22423 return nativeResponseValue;
22425 // void ReplyChannelRange_set_number_of_blocks(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
22427 export function ReplyChannelRange_set_number_of_blocks(this_ptr: number, val: number): void {
22428 if(!isWasmInitialized) {
22429 throw new Error("initializeWasm() must be awaited first!");
22431 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_number_of_blocks(this_ptr, val);
22432 // debug statements here
22434 // bool ReplyChannelRange_get_sync_complete(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
22436 export function ReplyChannelRange_get_sync_complete(this_ptr: number): boolean {
22437 if(!isWasmInitialized) {
22438 throw new Error("initializeWasm() must be awaited first!");
22440 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_sync_complete(this_ptr);
22441 return nativeResponseValue;
22443 // void ReplyChannelRange_set_sync_complete(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, bool val);
22445 export function ReplyChannelRange_set_sync_complete(this_ptr: number, val: boolean): void {
22446 if(!isWasmInitialized) {
22447 throw new Error("initializeWasm() must be awaited first!");
22449 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_sync_complete(this_ptr, val);
22450 // debug statements here
22452 // void ReplyChannelRange_set_short_channel_ids(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
22454 export function ReplyChannelRange_set_short_channel_ids(this_ptr: number, val: number): void {
22455 if(!isWasmInitialized) {
22456 throw new Error("initializeWasm() must be awaited first!");
22458 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_short_channel_ids(this_ptr, val);
22459 // debug statements here
22461 // 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);
22463 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 {
22464 if(!isWasmInitialized) {
22465 throw new Error("initializeWasm() must be awaited first!");
22467 const nativeResponseValue = wasm.TS_ReplyChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg);
22468 return nativeResponseValue;
22470 // uintptr_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg);
22472 export function ReplyChannelRange_clone_ptr(arg: number): number {
22473 if(!isWasmInitialized) {
22474 throw new Error("initializeWasm() must be awaited first!");
22476 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone_ptr(arg);
22477 return nativeResponseValue;
22479 // struct LDKReplyChannelRange ReplyChannelRange_clone(const struct LDKReplyChannelRange *NONNULL_PTR orig);
22481 export function ReplyChannelRange_clone(orig: number): number {
22482 if(!isWasmInitialized) {
22483 throw new Error("initializeWasm() must be awaited first!");
22485 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone(orig);
22486 return nativeResponseValue;
22488 // void QueryShortChannelIds_free(struct LDKQueryShortChannelIds this_obj);
22490 export function QueryShortChannelIds_free(this_obj: number): void {
22491 if(!isWasmInitialized) {
22492 throw new Error("initializeWasm() must be awaited first!");
22494 const nativeResponseValue = wasm.TS_QueryShortChannelIds_free(this_obj);
22495 // debug statements here
22497 // const uint8_t (*QueryShortChannelIds_get_chain_hash(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr))[32];
22499 export function QueryShortChannelIds_get_chain_hash(this_ptr: number): number {
22500 if(!isWasmInitialized) {
22501 throw new Error("initializeWasm() must be awaited first!");
22503 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_chain_hash(this_ptr);
22504 return nativeResponseValue;
22506 // void QueryShortChannelIds_set_chain_hash(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22508 export function QueryShortChannelIds_set_chain_hash(this_ptr: number, val: number): void {
22509 if(!isWasmInitialized) {
22510 throw new Error("initializeWasm() must be awaited first!");
22512 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_chain_hash(this_ptr, val);
22513 // debug statements here
22515 // void QueryShortChannelIds_set_short_channel_ids(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
22517 export function QueryShortChannelIds_set_short_channel_ids(this_ptr: number, val: number): void {
22518 if(!isWasmInitialized) {
22519 throw new Error("initializeWasm() must be awaited first!");
22521 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_short_channel_ids(this_ptr, val);
22522 // debug statements here
22524 // MUST_USE_RES struct LDKQueryShortChannelIds QueryShortChannelIds_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKCVec_u64Z short_channel_ids_arg);
22526 export function QueryShortChannelIds_new(chain_hash_arg: number, short_channel_ids_arg: number): number {
22527 if(!isWasmInitialized) {
22528 throw new Error("initializeWasm() must be awaited first!");
22530 const nativeResponseValue = wasm.TS_QueryShortChannelIds_new(chain_hash_arg, short_channel_ids_arg);
22531 return nativeResponseValue;
22533 // uintptr_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg);
22535 export function QueryShortChannelIds_clone_ptr(arg: number): number {
22536 if(!isWasmInitialized) {
22537 throw new Error("initializeWasm() must be awaited first!");
22539 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone_ptr(arg);
22540 return nativeResponseValue;
22542 // struct LDKQueryShortChannelIds QueryShortChannelIds_clone(const struct LDKQueryShortChannelIds *NONNULL_PTR orig);
22544 export function QueryShortChannelIds_clone(orig: number): number {
22545 if(!isWasmInitialized) {
22546 throw new Error("initializeWasm() must be awaited first!");
22548 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone(orig);
22549 return nativeResponseValue;
22551 // void ReplyShortChannelIdsEnd_free(struct LDKReplyShortChannelIdsEnd this_obj);
22553 export function ReplyShortChannelIdsEnd_free(this_obj: number): void {
22554 if(!isWasmInitialized) {
22555 throw new Error("initializeWasm() must be awaited first!");
22557 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_free(this_obj);
22558 // debug statements here
22560 // const uint8_t (*ReplyShortChannelIdsEnd_get_chain_hash(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr))[32];
22562 export function ReplyShortChannelIdsEnd_get_chain_hash(this_ptr: number): number {
22563 if(!isWasmInitialized) {
22564 throw new Error("initializeWasm() must be awaited first!");
22566 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_chain_hash(this_ptr);
22567 return nativeResponseValue;
22569 // void ReplyShortChannelIdsEnd_set_chain_hash(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22571 export function ReplyShortChannelIdsEnd_set_chain_hash(this_ptr: number, val: number): void {
22572 if(!isWasmInitialized) {
22573 throw new Error("initializeWasm() must be awaited first!");
22575 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_chain_hash(this_ptr, val);
22576 // debug statements here
22578 // bool ReplyShortChannelIdsEnd_get_full_information(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr);
22580 export function ReplyShortChannelIdsEnd_get_full_information(this_ptr: number): boolean {
22581 if(!isWasmInitialized) {
22582 throw new Error("initializeWasm() must be awaited first!");
22584 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_full_information(this_ptr);
22585 return nativeResponseValue;
22587 // void ReplyShortChannelIdsEnd_set_full_information(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, bool val);
22589 export function ReplyShortChannelIdsEnd_set_full_information(this_ptr: number, val: boolean): void {
22590 if(!isWasmInitialized) {
22591 throw new Error("initializeWasm() must be awaited first!");
22593 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_full_information(this_ptr, val);
22594 // debug statements here
22596 // MUST_USE_RES struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_new(struct LDKThirtyTwoBytes chain_hash_arg, bool full_information_arg);
22598 export function ReplyShortChannelIdsEnd_new(chain_hash_arg: number, full_information_arg: boolean): number {
22599 if(!isWasmInitialized) {
22600 throw new Error("initializeWasm() must be awaited first!");
22602 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_new(chain_hash_arg, full_information_arg);
22603 return nativeResponseValue;
22605 // uintptr_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg);
22607 export function ReplyShortChannelIdsEnd_clone_ptr(arg: number): number {
22608 if(!isWasmInitialized) {
22609 throw new Error("initializeWasm() must be awaited first!");
22611 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone_ptr(arg);
22612 return nativeResponseValue;
22614 // struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_clone(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR orig);
22616 export function ReplyShortChannelIdsEnd_clone(orig: number): number {
22617 if(!isWasmInitialized) {
22618 throw new Error("initializeWasm() must be awaited first!");
22620 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone(orig);
22621 return nativeResponseValue;
22623 // void GossipTimestampFilter_free(struct LDKGossipTimestampFilter this_obj);
22625 export function GossipTimestampFilter_free(this_obj: number): void {
22626 if(!isWasmInitialized) {
22627 throw new Error("initializeWasm() must be awaited first!");
22629 const nativeResponseValue = wasm.TS_GossipTimestampFilter_free(this_obj);
22630 // debug statements here
22632 // const uint8_t (*GossipTimestampFilter_get_chain_hash(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr))[32];
22634 export function GossipTimestampFilter_get_chain_hash(this_ptr: number): number {
22635 if(!isWasmInitialized) {
22636 throw new Error("initializeWasm() must be awaited first!");
22638 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_chain_hash(this_ptr);
22639 return nativeResponseValue;
22641 // void GossipTimestampFilter_set_chain_hash(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22643 export function GossipTimestampFilter_set_chain_hash(this_ptr: number, val: number): void {
22644 if(!isWasmInitialized) {
22645 throw new Error("initializeWasm() must be awaited first!");
22647 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_chain_hash(this_ptr, val);
22648 // debug statements here
22650 // uint32_t GossipTimestampFilter_get_first_timestamp(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
22652 export function GossipTimestampFilter_get_first_timestamp(this_ptr: number): number {
22653 if(!isWasmInitialized) {
22654 throw new Error("initializeWasm() must be awaited first!");
22656 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_first_timestamp(this_ptr);
22657 return nativeResponseValue;
22659 // void GossipTimestampFilter_set_first_timestamp(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
22661 export function GossipTimestampFilter_set_first_timestamp(this_ptr: number, val: number): void {
22662 if(!isWasmInitialized) {
22663 throw new Error("initializeWasm() must be awaited first!");
22665 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_first_timestamp(this_ptr, val);
22666 // debug statements here
22668 // uint32_t GossipTimestampFilter_get_timestamp_range(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
22670 export function GossipTimestampFilter_get_timestamp_range(this_ptr: number): number {
22671 if(!isWasmInitialized) {
22672 throw new Error("initializeWasm() must be awaited first!");
22674 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_timestamp_range(this_ptr);
22675 return nativeResponseValue;
22677 // void GossipTimestampFilter_set_timestamp_range(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
22679 export function GossipTimestampFilter_set_timestamp_range(this_ptr: number, val: number): void {
22680 if(!isWasmInitialized) {
22681 throw new Error("initializeWasm() must be awaited first!");
22683 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_timestamp_range(this_ptr, val);
22684 // debug statements here
22686 // MUST_USE_RES struct LDKGossipTimestampFilter GossipTimestampFilter_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_timestamp_arg, uint32_t timestamp_range_arg);
22688 export function GossipTimestampFilter_new(chain_hash_arg: number, first_timestamp_arg: number, timestamp_range_arg: number): number {
22689 if(!isWasmInitialized) {
22690 throw new Error("initializeWasm() must be awaited first!");
22692 const nativeResponseValue = wasm.TS_GossipTimestampFilter_new(chain_hash_arg, first_timestamp_arg, timestamp_range_arg);
22693 return nativeResponseValue;
22695 // uintptr_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg);
22697 export function GossipTimestampFilter_clone_ptr(arg: number): number {
22698 if(!isWasmInitialized) {
22699 throw new Error("initializeWasm() must be awaited first!");
22701 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone_ptr(arg);
22702 return nativeResponseValue;
22704 // struct LDKGossipTimestampFilter GossipTimestampFilter_clone(const struct LDKGossipTimestampFilter *NONNULL_PTR orig);
22706 export function GossipTimestampFilter_clone(orig: number): number {
22707 if(!isWasmInitialized) {
22708 throw new Error("initializeWasm() must be awaited first!");
22710 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone(orig);
22711 return nativeResponseValue;
22713 // void ErrorAction_free(struct LDKErrorAction this_ptr);
22715 export function ErrorAction_free(this_ptr: number): void {
22716 if(!isWasmInitialized) {
22717 throw new Error("initializeWasm() must be awaited first!");
22719 const nativeResponseValue = wasm.TS_ErrorAction_free(this_ptr);
22720 // debug statements here
22722 // uintptr_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg);
22724 export function ErrorAction_clone_ptr(arg: number): number {
22725 if(!isWasmInitialized) {
22726 throw new Error("initializeWasm() must be awaited first!");
22728 const nativeResponseValue = wasm.TS_ErrorAction_clone_ptr(arg);
22729 return nativeResponseValue;
22731 // struct LDKErrorAction ErrorAction_clone(const struct LDKErrorAction *NONNULL_PTR orig);
22733 export function ErrorAction_clone(orig: number): number {
22734 if(!isWasmInitialized) {
22735 throw new Error("initializeWasm() must be awaited first!");
22737 const nativeResponseValue = wasm.TS_ErrorAction_clone(orig);
22738 return nativeResponseValue;
22740 // struct LDKErrorAction ErrorAction_disconnect_peer(struct LDKErrorMessage msg);
22742 export function ErrorAction_disconnect_peer(msg: number): number {
22743 if(!isWasmInitialized) {
22744 throw new Error("initializeWasm() must be awaited first!");
22746 const nativeResponseValue = wasm.TS_ErrorAction_disconnect_peer(msg);
22747 return nativeResponseValue;
22749 // struct LDKErrorAction ErrorAction_ignore_error(void);
22751 export function ErrorAction_ignore_error(): number {
22752 if(!isWasmInitialized) {
22753 throw new Error("initializeWasm() must be awaited first!");
22755 const nativeResponseValue = wasm.TS_ErrorAction_ignore_error();
22756 return nativeResponseValue;
22758 // struct LDKErrorAction ErrorAction_ignore_and_log(enum LDKLevel a);
22760 export function ErrorAction_ignore_and_log(a: Level): number {
22761 if(!isWasmInitialized) {
22762 throw new Error("initializeWasm() must be awaited first!");
22764 const nativeResponseValue = wasm.TS_ErrorAction_ignore_and_log(a);
22765 return nativeResponseValue;
22767 // struct LDKErrorAction ErrorAction_ignore_duplicate_gossip(void);
22769 export function ErrorAction_ignore_duplicate_gossip(): number {
22770 if(!isWasmInitialized) {
22771 throw new Error("initializeWasm() must be awaited first!");
22773 const nativeResponseValue = wasm.TS_ErrorAction_ignore_duplicate_gossip();
22774 return nativeResponseValue;
22776 // struct LDKErrorAction ErrorAction_send_error_message(struct LDKErrorMessage msg);
22778 export function ErrorAction_send_error_message(msg: number): number {
22779 if(!isWasmInitialized) {
22780 throw new Error("initializeWasm() must be awaited first!");
22782 const nativeResponseValue = wasm.TS_ErrorAction_send_error_message(msg);
22783 return nativeResponseValue;
22785 // struct LDKErrorAction ErrorAction_send_warning_message(struct LDKWarningMessage msg, enum LDKLevel log_level);
22787 export function ErrorAction_send_warning_message(msg: number, log_level: Level): number {
22788 if(!isWasmInitialized) {
22789 throw new Error("initializeWasm() must be awaited first!");
22791 const nativeResponseValue = wasm.TS_ErrorAction_send_warning_message(msg, log_level);
22792 return nativeResponseValue;
22794 // void LightningError_free(struct LDKLightningError this_obj);
22796 export function LightningError_free(this_obj: number): void {
22797 if(!isWasmInitialized) {
22798 throw new Error("initializeWasm() must be awaited first!");
22800 const nativeResponseValue = wasm.TS_LightningError_free(this_obj);
22801 // debug statements here
22803 // struct LDKStr LightningError_get_err(const struct LDKLightningError *NONNULL_PTR this_ptr);
22805 export function LightningError_get_err(this_ptr: number): number {
22806 if(!isWasmInitialized) {
22807 throw new Error("initializeWasm() must be awaited first!");
22809 const nativeResponseValue = wasm.TS_LightningError_get_err(this_ptr);
22810 return nativeResponseValue;
22812 // void LightningError_set_err(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKStr val);
22814 export function LightningError_set_err(this_ptr: number, val: number): void {
22815 if(!isWasmInitialized) {
22816 throw new Error("initializeWasm() must be awaited first!");
22818 const nativeResponseValue = wasm.TS_LightningError_set_err(this_ptr, val);
22819 // debug statements here
22821 // struct LDKErrorAction LightningError_get_action(const struct LDKLightningError *NONNULL_PTR this_ptr);
22823 export function LightningError_get_action(this_ptr: number): number {
22824 if(!isWasmInitialized) {
22825 throw new Error("initializeWasm() must be awaited first!");
22827 const nativeResponseValue = wasm.TS_LightningError_get_action(this_ptr);
22828 return nativeResponseValue;
22830 // void LightningError_set_action(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKErrorAction val);
22832 export function LightningError_set_action(this_ptr: number, val: number): void {
22833 if(!isWasmInitialized) {
22834 throw new Error("initializeWasm() must be awaited first!");
22836 const nativeResponseValue = wasm.TS_LightningError_set_action(this_ptr, val);
22837 // debug statements here
22839 // MUST_USE_RES struct LDKLightningError LightningError_new(struct LDKStr err_arg, struct LDKErrorAction action_arg);
22841 export function LightningError_new(err_arg: number, action_arg: number): number {
22842 if(!isWasmInitialized) {
22843 throw new Error("initializeWasm() must be awaited first!");
22845 const nativeResponseValue = wasm.TS_LightningError_new(err_arg, action_arg);
22846 return nativeResponseValue;
22848 // uintptr_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg);
22850 export function LightningError_clone_ptr(arg: number): number {
22851 if(!isWasmInitialized) {
22852 throw new Error("initializeWasm() must be awaited first!");
22854 const nativeResponseValue = wasm.TS_LightningError_clone_ptr(arg);
22855 return nativeResponseValue;
22857 // struct LDKLightningError LightningError_clone(const struct LDKLightningError *NONNULL_PTR orig);
22859 export function LightningError_clone(orig: number): number {
22860 if(!isWasmInitialized) {
22861 throw new Error("initializeWasm() must be awaited first!");
22863 const nativeResponseValue = wasm.TS_LightningError_clone(orig);
22864 return nativeResponseValue;
22866 // void CommitmentUpdate_free(struct LDKCommitmentUpdate this_obj);
22868 export function CommitmentUpdate_free(this_obj: number): void {
22869 if(!isWasmInitialized) {
22870 throw new Error("initializeWasm() must be awaited first!");
22872 const nativeResponseValue = wasm.TS_CommitmentUpdate_free(this_obj);
22873 // debug statements here
22875 // struct LDKCVec_UpdateAddHTLCZ CommitmentUpdate_get_update_add_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
22877 export function CommitmentUpdate_get_update_add_htlcs(this_ptr: number): number {
22878 if(!isWasmInitialized) {
22879 throw new Error("initializeWasm() must be awaited first!");
22881 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_add_htlcs(this_ptr);
22882 return nativeResponseValue;
22884 // void CommitmentUpdate_set_update_add_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateAddHTLCZ val);
22886 export function CommitmentUpdate_set_update_add_htlcs(this_ptr: number, val: number): void {
22887 if(!isWasmInitialized) {
22888 throw new Error("initializeWasm() must be awaited first!");
22890 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_add_htlcs(this_ptr, val);
22891 // debug statements here
22893 // struct LDKCVec_UpdateFulfillHTLCZ CommitmentUpdate_get_update_fulfill_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
22895 export function CommitmentUpdate_get_update_fulfill_htlcs(this_ptr: number): number {
22896 if(!isWasmInitialized) {
22897 throw new Error("initializeWasm() must be awaited first!");
22899 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fulfill_htlcs(this_ptr);
22900 return nativeResponseValue;
22902 // void CommitmentUpdate_set_update_fulfill_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFulfillHTLCZ val);
22904 export function CommitmentUpdate_set_update_fulfill_htlcs(this_ptr: number, val: number): void {
22905 if(!isWasmInitialized) {
22906 throw new Error("initializeWasm() must be awaited first!");
22908 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fulfill_htlcs(this_ptr, val);
22909 // debug statements here
22911 // struct LDKCVec_UpdateFailHTLCZ CommitmentUpdate_get_update_fail_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
22913 export function CommitmentUpdate_get_update_fail_htlcs(this_ptr: number): number {
22914 if(!isWasmInitialized) {
22915 throw new Error("initializeWasm() must be awaited first!");
22917 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_htlcs(this_ptr);
22918 return nativeResponseValue;
22920 // void CommitmentUpdate_set_update_fail_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailHTLCZ val);
22922 export function CommitmentUpdate_set_update_fail_htlcs(this_ptr: number, val: number): void {
22923 if(!isWasmInitialized) {
22924 throw new Error("initializeWasm() must be awaited first!");
22926 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_htlcs(this_ptr, val);
22927 // debug statements here
22929 // struct LDKCVec_UpdateFailMalformedHTLCZ CommitmentUpdate_get_update_fail_malformed_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
22931 export function CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr: number): number {
22932 if(!isWasmInitialized) {
22933 throw new Error("initializeWasm() must be awaited first!");
22935 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr);
22936 return nativeResponseValue;
22938 // void CommitmentUpdate_set_update_fail_malformed_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailMalformedHTLCZ val);
22940 export function CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr: number, val: number): void {
22941 if(!isWasmInitialized) {
22942 throw new Error("initializeWasm() must be awaited first!");
22944 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr, val);
22945 // debug statements here
22947 // struct LDKUpdateFee CommitmentUpdate_get_update_fee(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
22949 export function CommitmentUpdate_get_update_fee(this_ptr: number): number {
22950 if(!isWasmInitialized) {
22951 throw new Error("initializeWasm() must be awaited first!");
22953 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fee(this_ptr);
22954 return nativeResponseValue;
22956 // void CommitmentUpdate_set_update_fee(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKUpdateFee val);
22958 export function CommitmentUpdate_set_update_fee(this_ptr: number, val: number): void {
22959 if(!isWasmInitialized) {
22960 throw new Error("initializeWasm() must be awaited first!");
22962 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fee(this_ptr, val);
22963 // debug statements here
22965 // struct LDKCommitmentSigned CommitmentUpdate_get_commitment_signed(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
22967 export function CommitmentUpdate_get_commitment_signed(this_ptr: number): number {
22968 if(!isWasmInitialized) {
22969 throw new Error("initializeWasm() must be awaited first!");
22971 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_commitment_signed(this_ptr);
22972 return nativeResponseValue;
22974 // void CommitmentUpdate_set_commitment_signed(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCommitmentSigned val);
22976 export function CommitmentUpdate_set_commitment_signed(this_ptr: number, val: number): void {
22977 if(!isWasmInitialized) {
22978 throw new Error("initializeWasm() must be awaited first!");
22980 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_commitment_signed(this_ptr, val);
22981 // debug statements here
22983 // 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);
22985 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 {
22986 if(!isWasmInitialized) {
22987 throw new Error("initializeWasm() must be awaited first!");
22989 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);
22990 return nativeResponseValue;
22992 // uintptr_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg);
22994 export function CommitmentUpdate_clone_ptr(arg: number): number {
22995 if(!isWasmInitialized) {
22996 throw new Error("initializeWasm() must be awaited first!");
22998 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone_ptr(arg);
22999 return nativeResponseValue;
23001 // struct LDKCommitmentUpdate CommitmentUpdate_clone(const struct LDKCommitmentUpdate *NONNULL_PTR orig);
23003 export function CommitmentUpdate_clone(orig: number): number {
23004 if(!isWasmInitialized) {
23005 throw new Error("initializeWasm() must be awaited first!");
23007 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone(orig);
23008 return nativeResponseValue;
23010 // void ChannelMessageHandler_free(struct LDKChannelMessageHandler this_ptr);
23012 export function ChannelMessageHandler_free(this_ptr: number): void {
23013 if(!isWasmInitialized) {
23014 throw new Error("initializeWasm() must be awaited first!");
23016 const nativeResponseValue = wasm.TS_ChannelMessageHandler_free(this_ptr);
23017 // debug statements here
23019 // void RoutingMessageHandler_free(struct LDKRoutingMessageHandler this_ptr);
23021 export function RoutingMessageHandler_free(this_ptr: number): void {
23022 if(!isWasmInitialized) {
23023 throw new Error("initializeWasm() must be awaited first!");
23025 const nativeResponseValue = wasm.TS_RoutingMessageHandler_free(this_ptr);
23026 // debug statements here
23028 // struct LDKCVec_u8Z AcceptChannel_write(const struct LDKAcceptChannel *NONNULL_PTR obj);
23030 export function AcceptChannel_write(obj: number): number {
23031 if(!isWasmInitialized) {
23032 throw new Error("initializeWasm() must be awaited first!");
23034 const nativeResponseValue = wasm.TS_AcceptChannel_write(obj);
23035 return nativeResponseValue;
23037 // struct LDKCResult_AcceptChannelDecodeErrorZ AcceptChannel_read(struct LDKu8slice ser);
23039 export function AcceptChannel_read(ser: number): number {
23040 if(!isWasmInitialized) {
23041 throw new Error("initializeWasm() must be awaited first!");
23043 const nativeResponseValue = wasm.TS_AcceptChannel_read(ser);
23044 return nativeResponseValue;
23046 // struct LDKCVec_u8Z AnnouncementSignatures_write(const struct LDKAnnouncementSignatures *NONNULL_PTR obj);
23048 export function AnnouncementSignatures_write(obj: number): number {
23049 if(!isWasmInitialized) {
23050 throw new Error("initializeWasm() must be awaited first!");
23052 const nativeResponseValue = wasm.TS_AnnouncementSignatures_write(obj);
23053 return nativeResponseValue;
23055 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ AnnouncementSignatures_read(struct LDKu8slice ser);
23057 export function AnnouncementSignatures_read(ser: number): number {
23058 if(!isWasmInitialized) {
23059 throw new Error("initializeWasm() must be awaited first!");
23061 const nativeResponseValue = wasm.TS_AnnouncementSignatures_read(ser);
23062 return nativeResponseValue;
23064 // struct LDKCVec_u8Z ChannelReestablish_write(const struct LDKChannelReestablish *NONNULL_PTR obj);
23066 export function ChannelReestablish_write(obj: number): number {
23067 if(!isWasmInitialized) {
23068 throw new Error("initializeWasm() must be awaited first!");
23070 const nativeResponseValue = wasm.TS_ChannelReestablish_write(obj);
23071 return nativeResponseValue;
23073 // struct LDKCResult_ChannelReestablishDecodeErrorZ ChannelReestablish_read(struct LDKu8slice ser);
23075 export function ChannelReestablish_read(ser: number): number {
23076 if(!isWasmInitialized) {
23077 throw new Error("initializeWasm() must be awaited first!");
23079 const nativeResponseValue = wasm.TS_ChannelReestablish_read(ser);
23080 return nativeResponseValue;
23082 // struct LDKCVec_u8Z ClosingSigned_write(const struct LDKClosingSigned *NONNULL_PTR obj);
23084 export function ClosingSigned_write(obj: number): number {
23085 if(!isWasmInitialized) {
23086 throw new Error("initializeWasm() must be awaited first!");
23088 const nativeResponseValue = wasm.TS_ClosingSigned_write(obj);
23089 return nativeResponseValue;
23091 // struct LDKCResult_ClosingSignedDecodeErrorZ ClosingSigned_read(struct LDKu8slice ser);
23093 export function ClosingSigned_read(ser: number): number {
23094 if(!isWasmInitialized) {
23095 throw new Error("initializeWasm() must be awaited first!");
23097 const nativeResponseValue = wasm.TS_ClosingSigned_read(ser);
23098 return nativeResponseValue;
23100 // struct LDKCVec_u8Z ClosingSignedFeeRange_write(const struct LDKClosingSignedFeeRange *NONNULL_PTR obj);
23102 export function ClosingSignedFeeRange_write(obj: number): number {
23103 if(!isWasmInitialized) {
23104 throw new Error("initializeWasm() must be awaited first!");
23106 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_write(obj);
23107 return nativeResponseValue;
23109 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ ClosingSignedFeeRange_read(struct LDKu8slice ser);
23111 export function ClosingSignedFeeRange_read(ser: number): number {
23112 if(!isWasmInitialized) {
23113 throw new Error("initializeWasm() must be awaited first!");
23115 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_read(ser);
23116 return nativeResponseValue;
23118 // struct LDKCVec_u8Z CommitmentSigned_write(const struct LDKCommitmentSigned *NONNULL_PTR obj);
23120 export function CommitmentSigned_write(obj: number): number {
23121 if(!isWasmInitialized) {
23122 throw new Error("initializeWasm() must be awaited first!");
23124 const nativeResponseValue = wasm.TS_CommitmentSigned_write(obj);
23125 return nativeResponseValue;
23127 // struct LDKCResult_CommitmentSignedDecodeErrorZ CommitmentSigned_read(struct LDKu8slice ser);
23129 export function CommitmentSigned_read(ser: number): number {
23130 if(!isWasmInitialized) {
23131 throw new Error("initializeWasm() must be awaited first!");
23133 const nativeResponseValue = wasm.TS_CommitmentSigned_read(ser);
23134 return nativeResponseValue;
23136 // struct LDKCVec_u8Z FundingCreated_write(const struct LDKFundingCreated *NONNULL_PTR obj);
23138 export function FundingCreated_write(obj: number): number {
23139 if(!isWasmInitialized) {
23140 throw new Error("initializeWasm() must be awaited first!");
23142 const nativeResponseValue = wasm.TS_FundingCreated_write(obj);
23143 return nativeResponseValue;
23145 // struct LDKCResult_FundingCreatedDecodeErrorZ FundingCreated_read(struct LDKu8slice ser);
23147 export function FundingCreated_read(ser: number): number {
23148 if(!isWasmInitialized) {
23149 throw new Error("initializeWasm() must be awaited first!");
23151 const nativeResponseValue = wasm.TS_FundingCreated_read(ser);
23152 return nativeResponseValue;
23154 // struct LDKCVec_u8Z FundingSigned_write(const struct LDKFundingSigned *NONNULL_PTR obj);
23156 export function FundingSigned_write(obj: number): number {
23157 if(!isWasmInitialized) {
23158 throw new Error("initializeWasm() must be awaited first!");
23160 const nativeResponseValue = wasm.TS_FundingSigned_write(obj);
23161 return nativeResponseValue;
23163 // struct LDKCResult_FundingSignedDecodeErrorZ FundingSigned_read(struct LDKu8slice ser);
23165 export function FundingSigned_read(ser: number): number {
23166 if(!isWasmInitialized) {
23167 throw new Error("initializeWasm() must be awaited first!");
23169 const nativeResponseValue = wasm.TS_FundingSigned_read(ser);
23170 return nativeResponseValue;
23172 // struct LDKCVec_u8Z FundingLocked_write(const struct LDKFundingLocked *NONNULL_PTR obj);
23174 export function FundingLocked_write(obj: number): number {
23175 if(!isWasmInitialized) {
23176 throw new Error("initializeWasm() must be awaited first!");
23178 const nativeResponseValue = wasm.TS_FundingLocked_write(obj);
23179 return nativeResponseValue;
23181 // struct LDKCResult_FundingLockedDecodeErrorZ FundingLocked_read(struct LDKu8slice ser);
23183 export function FundingLocked_read(ser: number): number {
23184 if(!isWasmInitialized) {
23185 throw new Error("initializeWasm() must be awaited first!");
23187 const nativeResponseValue = wasm.TS_FundingLocked_read(ser);
23188 return nativeResponseValue;
23190 // struct LDKCVec_u8Z Init_write(const struct LDKInit *NONNULL_PTR obj);
23192 export function Init_write(obj: number): number {
23193 if(!isWasmInitialized) {
23194 throw new Error("initializeWasm() must be awaited first!");
23196 const nativeResponseValue = wasm.TS_Init_write(obj);
23197 return nativeResponseValue;
23199 // struct LDKCResult_InitDecodeErrorZ Init_read(struct LDKu8slice ser);
23201 export function Init_read(ser: number): number {
23202 if(!isWasmInitialized) {
23203 throw new Error("initializeWasm() must be awaited first!");
23205 const nativeResponseValue = wasm.TS_Init_read(ser);
23206 return nativeResponseValue;
23208 // struct LDKCVec_u8Z OpenChannel_write(const struct LDKOpenChannel *NONNULL_PTR obj);
23210 export function OpenChannel_write(obj: number): number {
23211 if(!isWasmInitialized) {
23212 throw new Error("initializeWasm() must be awaited first!");
23214 const nativeResponseValue = wasm.TS_OpenChannel_write(obj);
23215 return nativeResponseValue;
23217 // struct LDKCResult_OpenChannelDecodeErrorZ OpenChannel_read(struct LDKu8slice ser);
23219 export function OpenChannel_read(ser: number): number {
23220 if(!isWasmInitialized) {
23221 throw new Error("initializeWasm() must be awaited first!");
23223 const nativeResponseValue = wasm.TS_OpenChannel_read(ser);
23224 return nativeResponseValue;
23226 // struct LDKCVec_u8Z RevokeAndACK_write(const struct LDKRevokeAndACK *NONNULL_PTR obj);
23228 export function RevokeAndACK_write(obj: number): number {
23229 if(!isWasmInitialized) {
23230 throw new Error("initializeWasm() must be awaited first!");
23232 const nativeResponseValue = wasm.TS_RevokeAndACK_write(obj);
23233 return nativeResponseValue;
23235 // struct LDKCResult_RevokeAndACKDecodeErrorZ RevokeAndACK_read(struct LDKu8slice ser);
23237 export function RevokeAndACK_read(ser: number): number {
23238 if(!isWasmInitialized) {
23239 throw new Error("initializeWasm() must be awaited first!");
23241 const nativeResponseValue = wasm.TS_RevokeAndACK_read(ser);
23242 return nativeResponseValue;
23244 // struct LDKCVec_u8Z Shutdown_write(const struct LDKShutdown *NONNULL_PTR obj);
23246 export function Shutdown_write(obj: number): number {
23247 if(!isWasmInitialized) {
23248 throw new Error("initializeWasm() must be awaited first!");
23250 const nativeResponseValue = wasm.TS_Shutdown_write(obj);
23251 return nativeResponseValue;
23253 // struct LDKCResult_ShutdownDecodeErrorZ Shutdown_read(struct LDKu8slice ser);
23255 export function Shutdown_read(ser: number): number {
23256 if(!isWasmInitialized) {
23257 throw new Error("initializeWasm() must be awaited first!");
23259 const nativeResponseValue = wasm.TS_Shutdown_read(ser);
23260 return nativeResponseValue;
23262 // struct LDKCVec_u8Z UpdateFailHTLC_write(const struct LDKUpdateFailHTLC *NONNULL_PTR obj);
23264 export function UpdateFailHTLC_write(obj: number): number {
23265 if(!isWasmInitialized) {
23266 throw new Error("initializeWasm() must be awaited first!");
23268 const nativeResponseValue = wasm.TS_UpdateFailHTLC_write(obj);
23269 return nativeResponseValue;
23271 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ UpdateFailHTLC_read(struct LDKu8slice ser);
23273 export function UpdateFailHTLC_read(ser: number): number {
23274 if(!isWasmInitialized) {
23275 throw new Error("initializeWasm() must be awaited first!");
23277 const nativeResponseValue = wasm.TS_UpdateFailHTLC_read(ser);
23278 return nativeResponseValue;
23280 // struct LDKCVec_u8Z UpdateFailMalformedHTLC_write(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR obj);
23282 export function UpdateFailMalformedHTLC_write(obj: number): number {
23283 if(!isWasmInitialized) {
23284 throw new Error("initializeWasm() must be awaited first!");
23286 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_write(obj);
23287 return nativeResponseValue;
23289 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ UpdateFailMalformedHTLC_read(struct LDKu8slice ser);
23291 export function UpdateFailMalformedHTLC_read(ser: number): number {
23292 if(!isWasmInitialized) {
23293 throw new Error("initializeWasm() must be awaited first!");
23295 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_read(ser);
23296 return nativeResponseValue;
23298 // struct LDKCVec_u8Z UpdateFee_write(const struct LDKUpdateFee *NONNULL_PTR obj);
23300 export function UpdateFee_write(obj: number): number {
23301 if(!isWasmInitialized) {
23302 throw new Error("initializeWasm() must be awaited first!");
23304 const nativeResponseValue = wasm.TS_UpdateFee_write(obj);
23305 return nativeResponseValue;
23307 // struct LDKCResult_UpdateFeeDecodeErrorZ UpdateFee_read(struct LDKu8slice ser);
23309 export function UpdateFee_read(ser: number): number {
23310 if(!isWasmInitialized) {
23311 throw new Error("initializeWasm() must be awaited first!");
23313 const nativeResponseValue = wasm.TS_UpdateFee_read(ser);
23314 return nativeResponseValue;
23316 // struct LDKCVec_u8Z UpdateFulfillHTLC_write(const struct LDKUpdateFulfillHTLC *NONNULL_PTR obj);
23318 export function UpdateFulfillHTLC_write(obj: number): number {
23319 if(!isWasmInitialized) {
23320 throw new Error("initializeWasm() must be awaited first!");
23322 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_write(obj);
23323 return nativeResponseValue;
23325 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ UpdateFulfillHTLC_read(struct LDKu8slice ser);
23327 export function UpdateFulfillHTLC_read(ser: number): number {
23328 if(!isWasmInitialized) {
23329 throw new Error("initializeWasm() must be awaited first!");
23331 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_read(ser);
23332 return nativeResponseValue;
23334 // struct LDKCVec_u8Z UpdateAddHTLC_write(const struct LDKUpdateAddHTLC *NONNULL_PTR obj);
23336 export function UpdateAddHTLC_write(obj: number): number {
23337 if(!isWasmInitialized) {
23338 throw new Error("initializeWasm() must be awaited first!");
23340 const nativeResponseValue = wasm.TS_UpdateAddHTLC_write(obj);
23341 return nativeResponseValue;
23343 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ UpdateAddHTLC_read(struct LDKu8slice ser);
23345 export function UpdateAddHTLC_read(ser: number): number {
23346 if(!isWasmInitialized) {
23347 throw new Error("initializeWasm() must be awaited first!");
23349 const nativeResponseValue = wasm.TS_UpdateAddHTLC_read(ser);
23350 return nativeResponseValue;
23352 // struct LDKCVec_u8Z Ping_write(const struct LDKPing *NONNULL_PTR obj);
23354 export function Ping_write(obj: number): number {
23355 if(!isWasmInitialized) {
23356 throw new Error("initializeWasm() must be awaited first!");
23358 const nativeResponseValue = wasm.TS_Ping_write(obj);
23359 return nativeResponseValue;
23361 // struct LDKCResult_PingDecodeErrorZ Ping_read(struct LDKu8slice ser);
23363 export function Ping_read(ser: number): number {
23364 if(!isWasmInitialized) {
23365 throw new Error("initializeWasm() must be awaited first!");
23367 const nativeResponseValue = wasm.TS_Ping_read(ser);
23368 return nativeResponseValue;
23370 // struct LDKCVec_u8Z Pong_write(const struct LDKPong *NONNULL_PTR obj);
23372 export function Pong_write(obj: number): number {
23373 if(!isWasmInitialized) {
23374 throw new Error("initializeWasm() must be awaited first!");
23376 const nativeResponseValue = wasm.TS_Pong_write(obj);
23377 return nativeResponseValue;
23379 // struct LDKCResult_PongDecodeErrorZ Pong_read(struct LDKu8slice ser);
23381 export function Pong_read(ser: number): number {
23382 if(!isWasmInitialized) {
23383 throw new Error("initializeWasm() must be awaited first!");
23385 const nativeResponseValue = wasm.TS_Pong_read(ser);
23386 return nativeResponseValue;
23388 // struct LDKCVec_u8Z UnsignedChannelAnnouncement_write(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR obj);
23390 export function UnsignedChannelAnnouncement_write(obj: number): number {
23391 if(!isWasmInitialized) {
23392 throw new Error("initializeWasm() must be awaited first!");
23394 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_write(obj);
23395 return nativeResponseValue;
23397 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ UnsignedChannelAnnouncement_read(struct LDKu8slice ser);
23399 export function UnsignedChannelAnnouncement_read(ser: number): number {
23400 if(!isWasmInitialized) {
23401 throw new Error("initializeWasm() must be awaited first!");
23403 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_read(ser);
23404 return nativeResponseValue;
23406 // struct LDKCVec_u8Z ChannelAnnouncement_write(const struct LDKChannelAnnouncement *NONNULL_PTR obj);
23408 export function ChannelAnnouncement_write(obj: number): number {
23409 if(!isWasmInitialized) {
23410 throw new Error("initializeWasm() must be awaited first!");
23412 const nativeResponseValue = wasm.TS_ChannelAnnouncement_write(obj);
23413 return nativeResponseValue;
23415 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ ChannelAnnouncement_read(struct LDKu8slice ser);
23417 export function ChannelAnnouncement_read(ser: number): number {
23418 if(!isWasmInitialized) {
23419 throw new Error("initializeWasm() must be awaited first!");
23421 const nativeResponseValue = wasm.TS_ChannelAnnouncement_read(ser);
23422 return nativeResponseValue;
23424 // struct LDKCVec_u8Z UnsignedChannelUpdate_write(const struct LDKUnsignedChannelUpdate *NONNULL_PTR obj);
23426 export function UnsignedChannelUpdate_write(obj: number): number {
23427 if(!isWasmInitialized) {
23428 throw new Error("initializeWasm() must be awaited first!");
23430 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_write(obj);
23431 return nativeResponseValue;
23433 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ UnsignedChannelUpdate_read(struct LDKu8slice ser);
23435 export function UnsignedChannelUpdate_read(ser: number): number {
23436 if(!isWasmInitialized) {
23437 throw new Error("initializeWasm() must be awaited first!");
23439 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_read(ser);
23440 return nativeResponseValue;
23442 // struct LDKCVec_u8Z ChannelUpdate_write(const struct LDKChannelUpdate *NONNULL_PTR obj);
23444 export function ChannelUpdate_write(obj: number): number {
23445 if(!isWasmInitialized) {
23446 throw new Error("initializeWasm() must be awaited first!");
23448 const nativeResponseValue = wasm.TS_ChannelUpdate_write(obj);
23449 return nativeResponseValue;
23451 // struct LDKCResult_ChannelUpdateDecodeErrorZ ChannelUpdate_read(struct LDKu8slice ser);
23453 export function ChannelUpdate_read(ser: number): number {
23454 if(!isWasmInitialized) {
23455 throw new Error("initializeWasm() must be awaited first!");
23457 const nativeResponseValue = wasm.TS_ChannelUpdate_read(ser);
23458 return nativeResponseValue;
23460 // struct LDKCVec_u8Z ErrorMessage_write(const struct LDKErrorMessage *NONNULL_PTR obj);
23462 export function ErrorMessage_write(obj: number): number {
23463 if(!isWasmInitialized) {
23464 throw new Error("initializeWasm() must be awaited first!");
23466 const nativeResponseValue = wasm.TS_ErrorMessage_write(obj);
23467 return nativeResponseValue;
23469 // struct LDKCResult_ErrorMessageDecodeErrorZ ErrorMessage_read(struct LDKu8slice ser);
23471 export function ErrorMessage_read(ser: number): number {
23472 if(!isWasmInitialized) {
23473 throw new Error("initializeWasm() must be awaited first!");
23475 const nativeResponseValue = wasm.TS_ErrorMessage_read(ser);
23476 return nativeResponseValue;
23478 // struct LDKCVec_u8Z WarningMessage_write(const struct LDKWarningMessage *NONNULL_PTR obj);
23480 export function WarningMessage_write(obj: number): number {
23481 if(!isWasmInitialized) {
23482 throw new Error("initializeWasm() must be awaited first!");
23484 const nativeResponseValue = wasm.TS_WarningMessage_write(obj);
23485 return nativeResponseValue;
23487 // struct LDKCResult_WarningMessageDecodeErrorZ WarningMessage_read(struct LDKu8slice ser);
23489 export function WarningMessage_read(ser: number): number {
23490 if(!isWasmInitialized) {
23491 throw new Error("initializeWasm() must be awaited first!");
23493 const nativeResponseValue = wasm.TS_WarningMessage_read(ser);
23494 return nativeResponseValue;
23496 // struct LDKCVec_u8Z UnsignedNodeAnnouncement_write(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR obj);
23498 export function UnsignedNodeAnnouncement_write(obj: number): number {
23499 if(!isWasmInitialized) {
23500 throw new Error("initializeWasm() must be awaited first!");
23502 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_write(obj);
23503 return nativeResponseValue;
23505 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ UnsignedNodeAnnouncement_read(struct LDKu8slice ser);
23507 export function UnsignedNodeAnnouncement_read(ser: number): number {
23508 if(!isWasmInitialized) {
23509 throw new Error("initializeWasm() must be awaited first!");
23511 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_read(ser);
23512 return nativeResponseValue;
23514 // struct LDKCVec_u8Z NodeAnnouncement_write(const struct LDKNodeAnnouncement *NONNULL_PTR obj);
23516 export function NodeAnnouncement_write(obj: number): number {
23517 if(!isWasmInitialized) {
23518 throw new Error("initializeWasm() must be awaited first!");
23520 const nativeResponseValue = wasm.TS_NodeAnnouncement_write(obj);
23521 return nativeResponseValue;
23523 // struct LDKCResult_NodeAnnouncementDecodeErrorZ NodeAnnouncement_read(struct LDKu8slice ser);
23525 export function NodeAnnouncement_read(ser: number): number {
23526 if(!isWasmInitialized) {
23527 throw new Error("initializeWasm() must be awaited first!");
23529 const nativeResponseValue = wasm.TS_NodeAnnouncement_read(ser);
23530 return nativeResponseValue;
23532 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ QueryShortChannelIds_read(struct LDKu8slice ser);
23534 export function QueryShortChannelIds_read(ser: number): number {
23535 if(!isWasmInitialized) {
23536 throw new Error("initializeWasm() must be awaited first!");
23538 const nativeResponseValue = wasm.TS_QueryShortChannelIds_read(ser);
23539 return nativeResponseValue;
23541 // struct LDKCVec_u8Z QueryShortChannelIds_write(const struct LDKQueryShortChannelIds *NONNULL_PTR obj);
23543 export function QueryShortChannelIds_write(obj: number): number {
23544 if(!isWasmInitialized) {
23545 throw new Error("initializeWasm() must be awaited first!");
23547 const nativeResponseValue = wasm.TS_QueryShortChannelIds_write(obj);
23548 return nativeResponseValue;
23550 // struct LDKCVec_u8Z ReplyShortChannelIdsEnd_write(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR obj);
23552 export function ReplyShortChannelIdsEnd_write(obj: number): number {
23553 if(!isWasmInitialized) {
23554 throw new Error("initializeWasm() must be awaited first!");
23556 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_write(obj);
23557 return nativeResponseValue;
23559 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ ReplyShortChannelIdsEnd_read(struct LDKu8slice ser);
23561 export function ReplyShortChannelIdsEnd_read(ser: number): number {
23562 if(!isWasmInitialized) {
23563 throw new Error("initializeWasm() must be awaited first!");
23565 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_read(ser);
23566 return nativeResponseValue;
23568 // MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
23570 export function QueryChannelRange_end_blocknum(this_arg: number): number {
23571 if(!isWasmInitialized) {
23572 throw new Error("initializeWasm() must be awaited first!");
23574 const nativeResponseValue = wasm.TS_QueryChannelRange_end_blocknum(this_arg);
23575 return nativeResponseValue;
23577 // struct LDKCVec_u8Z QueryChannelRange_write(const struct LDKQueryChannelRange *NONNULL_PTR obj);
23579 export function QueryChannelRange_write(obj: number): number {
23580 if(!isWasmInitialized) {
23581 throw new Error("initializeWasm() must be awaited first!");
23583 const nativeResponseValue = wasm.TS_QueryChannelRange_write(obj);
23584 return nativeResponseValue;
23586 // struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
23588 export function QueryChannelRange_read(ser: number): number {
23589 if(!isWasmInitialized) {
23590 throw new Error("initializeWasm() must be awaited first!");
23592 const nativeResponseValue = wasm.TS_QueryChannelRange_read(ser);
23593 return nativeResponseValue;
23595 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ ReplyChannelRange_read(struct LDKu8slice ser);
23597 export function ReplyChannelRange_read(ser: number): number {
23598 if(!isWasmInitialized) {
23599 throw new Error("initializeWasm() must be awaited first!");
23601 const nativeResponseValue = wasm.TS_ReplyChannelRange_read(ser);
23602 return nativeResponseValue;
23604 // struct LDKCVec_u8Z ReplyChannelRange_write(const struct LDKReplyChannelRange *NONNULL_PTR obj);
23606 export function ReplyChannelRange_write(obj: number): number {
23607 if(!isWasmInitialized) {
23608 throw new Error("initializeWasm() must be awaited first!");
23610 const nativeResponseValue = wasm.TS_ReplyChannelRange_write(obj);
23611 return nativeResponseValue;
23613 // struct LDKCVec_u8Z GossipTimestampFilter_write(const struct LDKGossipTimestampFilter *NONNULL_PTR obj);
23615 export function GossipTimestampFilter_write(obj: number): number {
23616 if(!isWasmInitialized) {
23617 throw new Error("initializeWasm() must be awaited first!");
23619 const nativeResponseValue = wasm.TS_GossipTimestampFilter_write(obj);
23620 return nativeResponseValue;
23622 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ GossipTimestampFilter_read(struct LDKu8slice ser);
23624 export function GossipTimestampFilter_read(ser: number): number {
23625 if(!isWasmInitialized) {
23626 throw new Error("initializeWasm() must be awaited first!");
23628 const nativeResponseValue = wasm.TS_GossipTimestampFilter_read(ser);
23629 return nativeResponseValue;
23631 // void CustomMessageHandler_free(struct LDKCustomMessageHandler this_ptr);
23633 export function CustomMessageHandler_free(this_ptr: number): void {
23634 if(!isWasmInitialized) {
23635 throw new Error("initializeWasm() must be awaited first!");
23637 const nativeResponseValue = wasm.TS_CustomMessageHandler_free(this_ptr);
23638 // debug statements here
23640 // void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_obj);
23642 export function IgnoringMessageHandler_free(this_obj: number): void {
23643 if(!isWasmInitialized) {
23644 throw new Error("initializeWasm() must be awaited first!");
23646 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_free(this_obj);
23647 // debug statements here
23649 // MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void);
23651 export function IgnoringMessageHandler_new(): number {
23652 if(!isWasmInitialized) {
23653 throw new Error("initializeWasm() must be awaited first!");
23655 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_new();
23656 return nativeResponseValue;
23658 // struct LDKMessageSendEventsProvider IgnoringMessageHandler_as_MessageSendEventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
23660 export function IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number {
23661 if(!isWasmInitialized) {
23662 throw new Error("initializeWasm() must be awaited first!");
23664 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg);
23665 return nativeResponseValue;
23667 // struct LDKRoutingMessageHandler IgnoringMessageHandler_as_RoutingMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
23669 export function IgnoringMessageHandler_as_RoutingMessageHandler(this_arg: number): number {
23670 if(!isWasmInitialized) {
23671 throw new Error("initializeWasm() must be awaited first!");
23673 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_RoutingMessageHandler(this_arg);
23674 return nativeResponseValue;
23676 // struct LDKCustomMessageReader IgnoringMessageHandler_as_CustomMessageReader(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
23678 export function IgnoringMessageHandler_as_CustomMessageReader(this_arg: number): number {
23679 if(!isWasmInitialized) {
23680 throw new Error("initializeWasm() must be awaited first!");
23682 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageReader(this_arg);
23683 return nativeResponseValue;
23685 // struct LDKCustomMessageHandler IgnoringMessageHandler_as_CustomMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
23687 export function IgnoringMessageHandler_as_CustomMessageHandler(this_arg: number): number {
23688 if(!isWasmInitialized) {
23689 throw new Error("initializeWasm() must be awaited first!");
23691 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageHandler(this_arg);
23692 return nativeResponseValue;
23694 // void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_obj);
23696 export function ErroringMessageHandler_free(this_obj: number): void {
23697 if(!isWasmInitialized) {
23698 throw new Error("initializeWasm() must be awaited first!");
23700 const nativeResponseValue = wasm.TS_ErroringMessageHandler_free(this_obj);
23701 // debug statements here
23703 // MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void);
23705 export function ErroringMessageHandler_new(): number {
23706 if(!isWasmInitialized) {
23707 throw new Error("initializeWasm() must be awaited first!");
23709 const nativeResponseValue = wasm.TS_ErroringMessageHandler_new();
23710 return nativeResponseValue;
23712 // struct LDKMessageSendEventsProvider ErroringMessageHandler_as_MessageSendEventsProvider(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
23714 export function ErroringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number {
23715 if(!isWasmInitialized) {
23716 throw new Error("initializeWasm() must be awaited first!");
23718 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_MessageSendEventsProvider(this_arg);
23719 return nativeResponseValue;
23721 // struct LDKChannelMessageHandler ErroringMessageHandler_as_ChannelMessageHandler(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
23723 export function ErroringMessageHandler_as_ChannelMessageHandler(this_arg: number): number {
23724 if(!isWasmInitialized) {
23725 throw new Error("initializeWasm() must be awaited first!");
23727 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_ChannelMessageHandler(this_arg);
23728 return nativeResponseValue;
23730 // void MessageHandler_free(struct LDKMessageHandler this_obj);
23732 export function MessageHandler_free(this_obj: number): void {
23733 if(!isWasmInitialized) {
23734 throw new Error("initializeWasm() must be awaited first!");
23736 const nativeResponseValue = wasm.TS_MessageHandler_free(this_obj);
23737 // debug statements here
23739 // const struct LDKChannelMessageHandler *MessageHandler_get_chan_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
23741 export function MessageHandler_get_chan_handler(this_ptr: number): number {
23742 if(!isWasmInitialized) {
23743 throw new Error("initializeWasm() must be awaited first!");
23745 const nativeResponseValue = wasm.TS_MessageHandler_get_chan_handler(this_ptr);
23746 return nativeResponseValue;
23748 // void MessageHandler_set_chan_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKChannelMessageHandler val);
23750 export function MessageHandler_set_chan_handler(this_ptr: number, val: number): void {
23751 if(!isWasmInitialized) {
23752 throw new Error("initializeWasm() must be awaited first!");
23754 const nativeResponseValue = wasm.TS_MessageHandler_set_chan_handler(this_ptr, val);
23755 // debug statements here
23757 // const struct LDKRoutingMessageHandler *MessageHandler_get_route_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
23759 export function MessageHandler_get_route_handler(this_ptr: number): number {
23760 if(!isWasmInitialized) {
23761 throw new Error("initializeWasm() must be awaited first!");
23763 const nativeResponseValue = wasm.TS_MessageHandler_get_route_handler(this_ptr);
23764 return nativeResponseValue;
23766 // void MessageHandler_set_route_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKRoutingMessageHandler val);
23768 export function MessageHandler_set_route_handler(this_ptr: number, val: number): void {
23769 if(!isWasmInitialized) {
23770 throw new Error("initializeWasm() must be awaited first!");
23772 const nativeResponseValue = wasm.TS_MessageHandler_set_route_handler(this_ptr, val);
23773 // debug statements here
23775 // MUST_USE_RES struct LDKMessageHandler MessageHandler_new(struct LDKChannelMessageHandler chan_handler_arg, struct LDKRoutingMessageHandler route_handler_arg);
23777 export function MessageHandler_new(chan_handler_arg: number, route_handler_arg: number): number {
23778 if(!isWasmInitialized) {
23779 throw new Error("initializeWasm() must be awaited first!");
23781 const nativeResponseValue = wasm.TS_MessageHandler_new(chan_handler_arg, route_handler_arg);
23782 return nativeResponseValue;
23784 // uintptr_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg);
23786 export function SocketDescriptor_clone_ptr(arg: number): number {
23787 if(!isWasmInitialized) {
23788 throw new Error("initializeWasm() must be awaited first!");
23790 const nativeResponseValue = wasm.TS_SocketDescriptor_clone_ptr(arg);
23791 return nativeResponseValue;
23793 // struct LDKSocketDescriptor SocketDescriptor_clone(const struct LDKSocketDescriptor *NONNULL_PTR orig);
23795 export function SocketDescriptor_clone(orig: number): number {
23796 if(!isWasmInitialized) {
23797 throw new Error("initializeWasm() must be awaited first!");
23799 const nativeResponseValue = wasm.TS_SocketDescriptor_clone(orig);
23800 return nativeResponseValue;
23802 // void SocketDescriptor_free(struct LDKSocketDescriptor this_ptr);
23804 export function SocketDescriptor_free(this_ptr: number): void {
23805 if(!isWasmInitialized) {
23806 throw new Error("initializeWasm() must be awaited first!");
23808 const nativeResponseValue = wasm.TS_SocketDescriptor_free(this_ptr);
23809 // debug statements here
23811 // void PeerHandleError_free(struct LDKPeerHandleError this_obj);
23813 export function PeerHandleError_free(this_obj: number): void {
23814 if(!isWasmInitialized) {
23815 throw new Error("initializeWasm() must be awaited first!");
23817 const nativeResponseValue = wasm.TS_PeerHandleError_free(this_obj);
23818 // debug statements here
23820 // bool PeerHandleError_get_no_connection_possible(const struct LDKPeerHandleError *NONNULL_PTR this_ptr);
23822 export function PeerHandleError_get_no_connection_possible(this_ptr: number): boolean {
23823 if(!isWasmInitialized) {
23824 throw new Error("initializeWasm() must be awaited first!");
23826 const nativeResponseValue = wasm.TS_PeerHandleError_get_no_connection_possible(this_ptr);
23827 return nativeResponseValue;
23829 // void PeerHandleError_set_no_connection_possible(struct LDKPeerHandleError *NONNULL_PTR this_ptr, bool val);
23831 export function PeerHandleError_set_no_connection_possible(this_ptr: number, val: boolean): void {
23832 if(!isWasmInitialized) {
23833 throw new Error("initializeWasm() must be awaited first!");
23835 const nativeResponseValue = wasm.TS_PeerHandleError_set_no_connection_possible(this_ptr, val);
23836 // debug statements here
23838 // MUST_USE_RES struct LDKPeerHandleError PeerHandleError_new(bool no_connection_possible_arg);
23840 export function PeerHandleError_new(no_connection_possible_arg: boolean): number {
23841 if(!isWasmInitialized) {
23842 throw new Error("initializeWasm() must be awaited first!");
23844 const nativeResponseValue = wasm.TS_PeerHandleError_new(no_connection_possible_arg);
23845 return nativeResponseValue;
23847 // uintptr_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg);
23849 export function PeerHandleError_clone_ptr(arg: number): number {
23850 if(!isWasmInitialized) {
23851 throw new Error("initializeWasm() must be awaited first!");
23853 const nativeResponseValue = wasm.TS_PeerHandleError_clone_ptr(arg);
23854 return nativeResponseValue;
23856 // struct LDKPeerHandleError PeerHandleError_clone(const struct LDKPeerHandleError *NONNULL_PTR orig);
23858 export function PeerHandleError_clone(orig: number): number {
23859 if(!isWasmInitialized) {
23860 throw new Error("initializeWasm() must be awaited first!");
23862 const nativeResponseValue = wasm.TS_PeerHandleError_clone(orig);
23863 return nativeResponseValue;
23865 // void PeerManager_free(struct LDKPeerManager this_obj);
23867 export function PeerManager_free(this_obj: number): void {
23868 if(!isWasmInitialized) {
23869 throw new Error("initializeWasm() must be awaited first!");
23871 const nativeResponseValue = wasm.TS_PeerManager_free(this_obj);
23872 // debug statements here
23874 // 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);
23876 export function PeerManager_new(message_handler: number, our_node_secret: number, ephemeral_random_data: number, logger: number, custom_message_handler: number): number {
23877 if(!isWasmInitialized) {
23878 throw new Error("initializeWasm() must be awaited first!");
23880 const nativeResponseValue = wasm.TS_PeerManager_new(message_handler, our_node_secret, ephemeral_random_data, logger, custom_message_handler);
23881 return nativeResponseValue;
23883 // MUST_USE_RES struct LDKCVec_PublicKeyZ PeerManager_get_peer_node_ids(const struct LDKPeerManager *NONNULL_PTR this_arg);
23885 export function PeerManager_get_peer_node_ids(this_arg: number): number {
23886 if(!isWasmInitialized) {
23887 throw new Error("initializeWasm() must be awaited first!");
23889 const nativeResponseValue = wasm.TS_PeerManager_get_peer_node_ids(this_arg);
23890 return nativeResponseValue;
23892 // 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);
23894 export function PeerManager_new_outbound_connection(this_arg: number, their_node_id: number, descriptor: number): number {
23895 if(!isWasmInitialized) {
23896 throw new Error("initializeWasm() must be awaited first!");
23898 const nativeResponseValue = wasm.TS_PeerManager_new_outbound_connection(this_arg, their_node_id, descriptor);
23899 return nativeResponseValue;
23901 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_new_inbound_connection(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor descriptor);
23903 export function PeerManager_new_inbound_connection(this_arg: number, descriptor: number): number {
23904 if(!isWasmInitialized) {
23905 throw new Error("initializeWasm() must be awaited first!");
23907 const nativeResponseValue = wasm.TS_PeerManager_new_inbound_connection(this_arg, descriptor);
23908 return nativeResponseValue;
23910 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_write_buffer_space_avail(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor *NONNULL_PTR descriptor);
23912 export function PeerManager_write_buffer_space_avail(this_arg: number, descriptor: number): number {
23913 if(!isWasmInitialized) {
23914 throw new Error("initializeWasm() must be awaited first!");
23916 const nativeResponseValue = wasm.TS_PeerManager_write_buffer_space_avail(this_arg, descriptor);
23917 return nativeResponseValue;
23919 // 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);
23921 export function PeerManager_read_event(this_arg: number, peer_descriptor: number, data: number): number {
23922 if(!isWasmInitialized) {
23923 throw new Error("initializeWasm() must be awaited first!");
23925 const nativeResponseValue = wasm.TS_PeerManager_read_event(this_arg, peer_descriptor, data);
23926 return nativeResponseValue;
23928 // void PeerManager_process_events(const struct LDKPeerManager *NONNULL_PTR this_arg);
23930 export function PeerManager_process_events(this_arg: number): void {
23931 if(!isWasmInitialized) {
23932 throw new Error("initializeWasm() must be awaited first!");
23934 const nativeResponseValue = wasm.TS_PeerManager_process_events(this_arg);
23935 // debug statements here
23937 // void PeerManager_socket_disconnected(const struct LDKPeerManager *NONNULL_PTR this_arg, const struct LDKSocketDescriptor *NONNULL_PTR descriptor);
23939 export function PeerManager_socket_disconnected(this_arg: number, descriptor: number): void {
23940 if(!isWasmInitialized) {
23941 throw new Error("initializeWasm() must be awaited first!");
23943 const nativeResponseValue = wasm.TS_PeerManager_socket_disconnected(this_arg, descriptor);
23944 // debug statements here
23946 // void PeerManager_disconnect_by_node_id(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id, bool no_connection_possible);
23948 export function PeerManager_disconnect_by_node_id(this_arg: number, node_id: number, no_connection_possible: boolean): void {
23949 if(!isWasmInitialized) {
23950 throw new Error("initializeWasm() must be awaited first!");
23952 const nativeResponseValue = wasm.TS_PeerManager_disconnect_by_node_id(this_arg, node_id, no_connection_possible);
23953 // debug statements here
23955 // void PeerManager_disconnect_all_peers(const struct LDKPeerManager *NONNULL_PTR this_arg);
23957 export function PeerManager_disconnect_all_peers(this_arg: number): void {
23958 if(!isWasmInitialized) {
23959 throw new Error("initializeWasm() must be awaited first!");
23961 const nativeResponseValue = wasm.TS_PeerManager_disconnect_all_peers(this_arg);
23962 // debug statements here
23964 // void PeerManager_timer_tick_occurred(const struct LDKPeerManager *NONNULL_PTR this_arg);
23966 export function PeerManager_timer_tick_occurred(this_arg: number): void {
23967 if(!isWasmInitialized) {
23968 throw new Error("initializeWasm() must be awaited first!");
23970 const nativeResponseValue = wasm.TS_PeerManager_timer_tick_occurred(this_arg);
23971 // debug statements here
23973 // uint64_t htlc_success_tx_weight(bool opt_anchors);
23975 export function htlc_success_tx_weight(opt_anchors: boolean): bigint {
23976 if(!isWasmInitialized) {
23977 throw new Error("initializeWasm() must be awaited first!");
23979 const nativeResponseValue = wasm.TS_htlc_success_tx_weight(opt_anchors);
23980 return nativeResponseValue;
23982 // uint64_t htlc_timeout_tx_weight(bool opt_anchors);
23984 export function htlc_timeout_tx_weight(opt_anchors: boolean): bigint {
23985 if(!isWasmInitialized) {
23986 throw new Error("initializeWasm() must be awaited first!");
23988 const nativeResponseValue = wasm.TS_htlc_timeout_tx_weight(opt_anchors);
23989 return nativeResponseValue;
23991 // struct LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx);
23993 export function build_commitment_secret(commitment_seed: number, idx: bigint): number {
23994 if(!isWasmInitialized) {
23995 throw new Error("initializeWasm() must be awaited first!");
23997 const nativeResponseValue = wasm.TS_build_commitment_secret(commitment_seed, idx);
23998 return nativeResponseValue;
24000 // 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);
24002 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 {
24003 if(!isWasmInitialized) {
24004 throw new Error("initializeWasm() must be awaited first!");
24006 const nativeResponseValue = wasm.TS_build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
24007 return nativeResponseValue;
24009 // void CounterpartyCommitmentSecrets_free(struct LDKCounterpartyCommitmentSecrets this_obj);
24011 export function CounterpartyCommitmentSecrets_free(this_obj: number): void {
24012 if(!isWasmInitialized) {
24013 throw new Error("initializeWasm() must be awaited first!");
24015 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_free(this_obj);
24016 // debug statements here
24018 // uintptr_t CounterpartyCommitmentSecrets_clone_ptr(LDKCounterpartyCommitmentSecrets *NONNULL_PTR arg);
24020 export function CounterpartyCommitmentSecrets_clone_ptr(arg: number): number {
24021 if(!isWasmInitialized) {
24022 throw new Error("initializeWasm() must be awaited first!");
24024 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone_ptr(arg);
24025 return nativeResponseValue;
24027 // struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_clone(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR orig);
24029 export function CounterpartyCommitmentSecrets_clone(orig: number): number {
24030 if(!isWasmInitialized) {
24031 throw new Error("initializeWasm() must be awaited first!");
24033 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone(orig);
24034 return nativeResponseValue;
24036 // MUST_USE_RES struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_new(void);
24038 export function CounterpartyCommitmentSecrets_new(): number {
24039 if(!isWasmInitialized) {
24040 throw new Error("initializeWasm() must be awaited first!");
24042 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_new();
24043 return nativeResponseValue;
24045 // MUST_USE_RES uint64_t CounterpartyCommitmentSecrets_get_min_seen_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg);
24047 export function CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg: number): bigint {
24048 if(!isWasmInitialized) {
24049 throw new Error("initializeWasm() must be awaited first!");
24051 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg);
24052 return nativeResponseValue;
24054 // MUST_USE_RES struct LDKCResult_NoneNoneZ CounterpartyCommitmentSecrets_provide_secret(struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx, struct LDKThirtyTwoBytes secret);
24056 export function CounterpartyCommitmentSecrets_provide_secret(this_arg: number, idx: bigint, secret: number): number {
24057 if(!isWasmInitialized) {
24058 throw new Error("initializeWasm() must be awaited first!");
24060 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_provide_secret(this_arg, idx, secret);
24061 return nativeResponseValue;
24063 // MUST_USE_RES struct LDKThirtyTwoBytes CounterpartyCommitmentSecrets_get_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx);
24065 export function CounterpartyCommitmentSecrets_get_secret(this_arg: number, idx: bigint): number {
24066 if(!isWasmInitialized) {
24067 throw new Error("initializeWasm() must be awaited first!");
24069 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_secret(this_arg, idx);
24070 return nativeResponseValue;
24072 // struct LDKCVec_u8Z CounterpartyCommitmentSecrets_write(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR obj);
24074 export function CounterpartyCommitmentSecrets_write(obj: number): number {
24075 if(!isWasmInitialized) {
24076 throw new Error("initializeWasm() must be awaited first!");
24078 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_write(obj);
24079 return nativeResponseValue;
24081 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CounterpartyCommitmentSecrets_read(struct LDKu8slice ser);
24083 export function CounterpartyCommitmentSecrets_read(ser: number): number {
24084 if(!isWasmInitialized) {
24085 throw new Error("initializeWasm() must be awaited first!");
24087 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_read(ser);
24088 return nativeResponseValue;
24090 // struct LDKCResult_SecretKeyErrorZ derive_private_key(struct LDKPublicKey per_commitment_point, const uint8_t (*base_secret)[32]);
24092 export function derive_private_key(per_commitment_point: number, base_secret: number): number {
24093 if(!isWasmInitialized) {
24094 throw new Error("initializeWasm() must be awaited first!");
24096 const nativeResponseValue = wasm.TS_derive_private_key(per_commitment_point, base_secret);
24097 return nativeResponseValue;
24099 // struct LDKCResult_PublicKeyErrorZ derive_public_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey base_point);
24101 export function derive_public_key(per_commitment_point: number, base_point: number): number {
24102 if(!isWasmInitialized) {
24103 throw new Error("initializeWasm() must be awaited first!");
24105 const nativeResponseValue = wasm.TS_derive_public_key(per_commitment_point, base_point);
24106 return nativeResponseValue;
24108 // struct LDKCResult_SecretKeyErrorZ derive_private_revocation_key(const uint8_t (*per_commitment_secret)[32], const uint8_t (*countersignatory_revocation_base_secret)[32]);
24110 export function derive_private_revocation_key(per_commitment_secret: number, countersignatory_revocation_base_secret: number): number {
24111 if(!isWasmInitialized) {
24112 throw new Error("initializeWasm() must be awaited first!");
24114 const nativeResponseValue = wasm.TS_derive_private_revocation_key(per_commitment_secret, countersignatory_revocation_base_secret);
24115 return nativeResponseValue;
24117 // struct LDKCResult_PublicKeyErrorZ derive_public_revocation_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey countersignatory_revocation_base_point);
24119 export function derive_public_revocation_key(per_commitment_point: number, countersignatory_revocation_base_point: number): number {
24120 if(!isWasmInitialized) {
24121 throw new Error("initializeWasm() must be awaited first!");
24123 const nativeResponseValue = wasm.TS_derive_public_revocation_key(per_commitment_point, countersignatory_revocation_base_point);
24124 return nativeResponseValue;
24126 // void TxCreationKeys_free(struct LDKTxCreationKeys this_obj);
24128 export function TxCreationKeys_free(this_obj: number): void {
24129 if(!isWasmInitialized) {
24130 throw new Error("initializeWasm() must be awaited first!");
24132 const nativeResponseValue = wasm.TS_TxCreationKeys_free(this_obj);
24133 // debug statements here
24135 // struct LDKPublicKey TxCreationKeys_get_per_commitment_point(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
24137 export function TxCreationKeys_get_per_commitment_point(this_ptr: number): number {
24138 if(!isWasmInitialized) {
24139 throw new Error("initializeWasm() must be awaited first!");
24141 const nativeResponseValue = wasm.TS_TxCreationKeys_get_per_commitment_point(this_ptr);
24142 return nativeResponseValue;
24144 // void TxCreationKeys_set_per_commitment_point(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24146 export function TxCreationKeys_set_per_commitment_point(this_ptr: number, val: number): void {
24147 if(!isWasmInitialized) {
24148 throw new Error("initializeWasm() must be awaited first!");
24150 const nativeResponseValue = wasm.TS_TxCreationKeys_set_per_commitment_point(this_ptr, val);
24151 // debug statements here
24153 // struct LDKPublicKey TxCreationKeys_get_revocation_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
24155 export function TxCreationKeys_get_revocation_key(this_ptr: number): number {
24156 if(!isWasmInitialized) {
24157 throw new Error("initializeWasm() must be awaited first!");
24159 const nativeResponseValue = wasm.TS_TxCreationKeys_get_revocation_key(this_ptr);
24160 return nativeResponseValue;
24162 // void TxCreationKeys_set_revocation_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24164 export function TxCreationKeys_set_revocation_key(this_ptr: number, val: number): void {
24165 if(!isWasmInitialized) {
24166 throw new Error("initializeWasm() must be awaited first!");
24168 const nativeResponseValue = wasm.TS_TxCreationKeys_set_revocation_key(this_ptr, val);
24169 // debug statements here
24171 // struct LDKPublicKey TxCreationKeys_get_broadcaster_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
24173 export function TxCreationKeys_get_broadcaster_htlc_key(this_ptr: number): number {
24174 if(!isWasmInitialized) {
24175 throw new Error("initializeWasm() must be awaited first!");
24177 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_htlc_key(this_ptr);
24178 return nativeResponseValue;
24180 // void TxCreationKeys_set_broadcaster_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24182 export function TxCreationKeys_set_broadcaster_htlc_key(this_ptr: number, val: number): void {
24183 if(!isWasmInitialized) {
24184 throw new Error("initializeWasm() must be awaited first!");
24186 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_htlc_key(this_ptr, val);
24187 // debug statements here
24189 // struct LDKPublicKey TxCreationKeys_get_countersignatory_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
24191 export function TxCreationKeys_get_countersignatory_htlc_key(this_ptr: number): number {
24192 if(!isWasmInitialized) {
24193 throw new Error("initializeWasm() must be awaited first!");
24195 const nativeResponseValue = wasm.TS_TxCreationKeys_get_countersignatory_htlc_key(this_ptr);
24196 return nativeResponseValue;
24198 // void TxCreationKeys_set_countersignatory_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24200 export function TxCreationKeys_set_countersignatory_htlc_key(this_ptr: number, val: number): void {
24201 if(!isWasmInitialized) {
24202 throw new Error("initializeWasm() must be awaited first!");
24204 const nativeResponseValue = wasm.TS_TxCreationKeys_set_countersignatory_htlc_key(this_ptr, val);
24205 // debug statements here
24207 // struct LDKPublicKey TxCreationKeys_get_broadcaster_delayed_payment_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
24209 export function TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr: number): number {
24210 if(!isWasmInitialized) {
24211 throw new Error("initializeWasm() must be awaited first!");
24213 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr);
24214 return nativeResponseValue;
24216 // void TxCreationKeys_set_broadcaster_delayed_payment_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24218 export function TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr: number, val: number): void {
24219 if(!isWasmInitialized) {
24220 throw new Error("initializeWasm() must be awaited first!");
24222 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr, val);
24223 // debug statements here
24225 // 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);
24227 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 {
24228 if(!isWasmInitialized) {
24229 throw new Error("initializeWasm() must be awaited first!");
24231 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);
24232 return nativeResponseValue;
24234 // uintptr_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg);
24236 export function TxCreationKeys_clone_ptr(arg: number): number {
24237 if(!isWasmInitialized) {
24238 throw new Error("initializeWasm() must be awaited first!");
24240 const nativeResponseValue = wasm.TS_TxCreationKeys_clone_ptr(arg);
24241 return nativeResponseValue;
24243 // struct LDKTxCreationKeys TxCreationKeys_clone(const struct LDKTxCreationKeys *NONNULL_PTR orig);
24245 export function TxCreationKeys_clone(orig: number): number {
24246 if(!isWasmInitialized) {
24247 throw new Error("initializeWasm() must be awaited first!");
24249 const nativeResponseValue = wasm.TS_TxCreationKeys_clone(orig);
24250 return nativeResponseValue;
24252 // struct LDKCVec_u8Z TxCreationKeys_write(const struct LDKTxCreationKeys *NONNULL_PTR obj);
24254 export function TxCreationKeys_write(obj: number): number {
24255 if(!isWasmInitialized) {
24256 throw new Error("initializeWasm() must be awaited first!");
24258 const nativeResponseValue = wasm.TS_TxCreationKeys_write(obj);
24259 return nativeResponseValue;
24261 // struct LDKCResult_TxCreationKeysDecodeErrorZ TxCreationKeys_read(struct LDKu8slice ser);
24263 export function TxCreationKeys_read(ser: number): number {
24264 if(!isWasmInitialized) {
24265 throw new Error("initializeWasm() must be awaited first!");
24267 const nativeResponseValue = wasm.TS_TxCreationKeys_read(ser);
24268 return nativeResponseValue;
24270 // void ChannelPublicKeys_free(struct LDKChannelPublicKeys this_obj);
24272 export function ChannelPublicKeys_free(this_obj: number): void {
24273 if(!isWasmInitialized) {
24274 throw new Error("initializeWasm() must be awaited first!");
24276 const nativeResponseValue = wasm.TS_ChannelPublicKeys_free(this_obj);
24277 // debug statements here
24279 // struct LDKPublicKey ChannelPublicKeys_get_funding_pubkey(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
24281 export function ChannelPublicKeys_get_funding_pubkey(this_ptr: number): number {
24282 if(!isWasmInitialized) {
24283 throw new Error("initializeWasm() must be awaited first!");
24285 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_funding_pubkey(this_ptr);
24286 return nativeResponseValue;
24288 // void ChannelPublicKeys_set_funding_pubkey(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24290 export function ChannelPublicKeys_set_funding_pubkey(this_ptr: number, val: number): void {
24291 if(!isWasmInitialized) {
24292 throw new Error("initializeWasm() must be awaited first!");
24294 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_funding_pubkey(this_ptr, val);
24295 // debug statements here
24297 // struct LDKPublicKey ChannelPublicKeys_get_revocation_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
24299 export function ChannelPublicKeys_get_revocation_basepoint(this_ptr: number): number {
24300 if(!isWasmInitialized) {
24301 throw new Error("initializeWasm() must be awaited first!");
24303 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_revocation_basepoint(this_ptr);
24304 return nativeResponseValue;
24306 // void ChannelPublicKeys_set_revocation_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24308 export function ChannelPublicKeys_set_revocation_basepoint(this_ptr: number, val: number): void {
24309 if(!isWasmInitialized) {
24310 throw new Error("initializeWasm() must be awaited first!");
24312 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_revocation_basepoint(this_ptr, val);
24313 // debug statements here
24315 // struct LDKPublicKey ChannelPublicKeys_get_payment_point(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
24317 export function ChannelPublicKeys_get_payment_point(this_ptr: number): number {
24318 if(!isWasmInitialized) {
24319 throw new Error("initializeWasm() must be awaited first!");
24321 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_payment_point(this_ptr);
24322 return nativeResponseValue;
24324 // void ChannelPublicKeys_set_payment_point(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24326 export function ChannelPublicKeys_set_payment_point(this_ptr: number, val: number): void {
24327 if(!isWasmInitialized) {
24328 throw new Error("initializeWasm() must be awaited first!");
24330 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_payment_point(this_ptr, val);
24331 // debug statements here
24333 // struct LDKPublicKey ChannelPublicKeys_get_delayed_payment_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
24335 export function ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr: number): number {
24336 if(!isWasmInitialized) {
24337 throw new Error("initializeWasm() must be awaited first!");
24339 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr);
24340 return nativeResponseValue;
24342 // void ChannelPublicKeys_set_delayed_payment_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24344 export function ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
24345 if(!isWasmInitialized) {
24346 throw new Error("initializeWasm() must be awaited first!");
24348 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr, val);
24349 // debug statements here
24351 // struct LDKPublicKey ChannelPublicKeys_get_htlc_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
24353 export function ChannelPublicKeys_get_htlc_basepoint(this_ptr: number): number {
24354 if(!isWasmInitialized) {
24355 throw new Error("initializeWasm() must be awaited first!");
24357 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_htlc_basepoint(this_ptr);
24358 return nativeResponseValue;
24360 // void ChannelPublicKeys_set_htlc_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24362 export function ChannelPublicKeys_set_htlc_basepoint(this_ptr: number, val: number): void {
24363 if(!isWasmInitialized) {
24364 throw new Error("initializeWasm() must be awaited first!");
24366 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_htlc_basepoint(this_ptr, val);
24367 // debug statements here
24369 // 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);
24371 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 {
24372 if(!isWasmInitialized) {
24373 throw new Error("initializeWasm() must be awaited first!");
24375 const nativeResponseValue = wasm.TS_ChannelPublicKeys_new(funding_pubkey_arg, revocation_basepoint_arg, payment_point_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg);
24376 return nativeResponseValue;
24378 // uintptr_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg);
24380 export function ChannelPublicKeys_clone_ptr(arg: number): number {
24381 if(!isWasmInitialized) {
24382 throw new Error("initializeWasm() must be awaited first!");
24384 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone_ptr(arg);
24385 return nativeResponseValue;
24387 // struct LDKChannelPublicKeys ChannelPublicKeys_clone(const struct LDKChannelPublicKeys *NONNULL_PTR orig);
24389 export function ChannelPublicKeys_clone(orig: number): number {
24390 if(!isWasmInitialized) {
24391 throw new Error("initializeWasm() must be awaited first!");
24393 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone(orig);
24394 return nativeResponseValue;
24396 // struct LDKCVec_u8Z ChannelPublicKeys_write(const struct LDKChannelPublicKeys *NONNULL_PTR obj);
24398 export function ChannelPublicKeys_write(obj: number): number {
24399 if(!isWasmInitialized) {
24400 throw new Error("initializeWasm() must be awaited first!");
24402 const nativeResponseValue = wasm.TS_ChannelPublicKeys_write(obj);
24403 return nativeResponseValue;
24405 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ ChannelPublicKeys_read(struct LDKu8slice ser);
24407 export function ChannelPublicKeys_read(ser: number): number {
24408 if(!isWasmInitialized) {
24409 throw new Error("initializeWasm() must be awaited first!");
24411 const nativeResponseValue = wasm.TS_ChannelPublicKeys_read(ser);
24412 return nativeResponseValue;
24414 // 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);
24416 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 {
24417 if(!isWasmInitialized) {
24418 throw new Error("initializeWasm() must be awaited first!");
24420 const nativeResponseValue = wasm.TS_TxCreationKeys_derive_new(per_commitment_point, broadcaster_delayed_payment_base, broadcaster_htlc_base, countersignatory_revocation_base, countersignatory_htlc_base);
24421 return nativeResponseValue;
24423 // 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);
24425 export function TxCreationKeys_from_channel_static_keys(per_commitment_point: number, broadcaster_keys: number, countersignatory_keys: number): number {
24426 if(!isWasmInitialized) {
24427 throw new Error("initializeWasm() must be awaited first!");
24429 const nativeResponseValue = wasm.TS_TxCreationKeys_from_channel_static_keys(per_commitment_point, broadcaster_keys, countersignatory_keys);
24430 return nativeResponseValue;
24432 // struct LDKCVec_u8Z get_revokeable_redeemscript(struct LDKPublicKey revocation_key, uint16_t contest_delay, struct LDKPublicKey broadcaster_delayed_payment_key);
24434 export function get_revokeable_redeemscript(revocation_key: number, contest_delay: number, broadcaster_delayed_payment_key: number): number {
24435 if(!isWasmInitialized) {
24436 throw new Error("initializeWasm() must be awaited first!");
24438 const nativeResponseValue = wasm.TS_get_revokeable_redeemscript(revocation_key, contest_delay, broadcaster_delayed_payment_key);
24439 return nativeResponseValue;
24441 // void HTLCOutputInCommitment_free(struct LDKHTLCOutputInCommitment this_obj);
24443 export function HTLCOutputInCommitment_free(this_obj: number): void {
24444 if(!isWasmInitialized) {
24445 throw new Error("initializeWasm() must be awaited first!");
24447 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_free(this_obj);
24448 // debug statements here
24450 // bool HTLCOutputInCommitment_get_offered(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
24452 export function HTLCOutputInCommitment_get_offered(this_ptr: number): boolean {
24453 if(!isWasmInitialized) {
24454 throw new Error("initializeWasm() must be awaited first!");
24456 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_offered(this_ptr);
24457 return nativeResponseValue;
24459 // void HTLCOutputInCommitment_set_offered(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, bool val);
24461 export function HTLCOutputInCommitment_set_offered(this_ptr: number, val: boolean): void {
24462 if(!isWasmInitialized) {
24463 throw new Error("initializeWasm() must be awaited first!");
24465 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_offered(this_ptr, val);
24466 // debug statements here
24468 // uint64_t HTLCOutputInCommitment_get_amount_msat(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
24470 export function HTLCOutputInCommitment_get_amount_msat(this_ptr: number): bigint {
24471 if(!isWasmInitialized) {
24472 throw new Error("initializeWasm() must be awaited first!");
24474 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_amount_msat(this_ptr);
24475 return nativeResponseValue;
24477 // void HTLCOutputInCommitment_set_amount_msat(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint64_t val);
24479 export function HTLCOutputInCommitment_set_amount_msat(this_ptr: number, val: bigint): void {
24480 if(!isWasmInitialized) {
24481 throw new Error("initializeWasm() must be awaited first!");
24483 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_amount_msat(this_ptr, val);
24484 // debug statements here
24486 // uint32_t HTLCOutputInCommitment_get_cltv_expiry(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
24488 export function HTLCOutputInCommitment_get_cltv_expiry(this_ptr: number): number {
24489 if(!isWasmInitialized) {
24490 throw new Error("initializeWasm() must be awaited first!");
24492 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_cltv_expiry(this_ptr);
24493 return nativeResponseValue;
24495 // void HTLCOutputInCommitment_set_cltv_expiry(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint32_t val);
24497 export function HTLCOutputInCommitment_set_cltv_expiry(this_ptr: number, val: number): void {
24498 if(!isWasmInitialized) {
24499 throw new Error("initializeWasm() must be awaited first!");
24501 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_cltv_expiry(this_ptr, val);
24502 // debug statements here
24504 // const uint8_t (*HTLCOutputInCommitment_get_payment_hash(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr))[32];
24506 export function HTLCOutputInCommitment_get_payment_hash(this_ptr: number): number {
24507 if(!isWasmInitialized) {
24508 throw new Error("initializeWasm() must be awaited first!");
24510 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_payment_hash(this_ptr);
24511 return nativeResponseValue;
24513 // void HTLCOutputInCommitment_set_payment_hash(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24515 export function HTLCOutputInCommitment_set_payment_hash(this_ptr: number, val: number): void {
24516 if(!isWasmInitialized) {
24517 throw new Error("initializeWasm() must be awaited first!");
24519 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_payment_hash(this_ptr, val);
24520 // debug statements here
24522 // struct LDKCOption_u32Z HTLCOutputInCommitment_get_transaction_output_index(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
24524 export function HTLCOutputInCommitment_get_transaction_output_index(this_ptr: number): number {
24525 if(!isWasmInitialized) {
24526 throw new Error("initializeWasm() must be awaited first!");
24528 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_transaction_output_index(this_ptr);
24529 return nativeResponseValue;
24531 // void HTLCOutputInCommitment_set_transaction_output_index(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
24533 export function HTLCOutputInCommitment_set_transaction_output_index(this_ptr: number, val: number): void {
24534 if(!isWasmInitialized) {
24535 throw new Error("initializeWasm() must be awaited first!");
24537 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_transaction_output_index(this_ptr, val);
24538 // debug statements here
24540 // 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);
24542 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 {
24543 if(!isWasmInitialized) {
24544 throw new Error("initializeWasm() must be awaited first!");
24546 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg, transaction_output_index_arg);
24547 return nativeResponseValue;
24549 // uintptr_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg);
24551 export function HTLCOutputInCommitment_clone_ptr(arg: number): number {
24552 if(!isWasmInitialized) {
24553 throw new Error("initializeWasm() must be awaited first!");
24555 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone_ptr(arg);
24556 return nativeResponseValue;
24558 // struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_clone(const struct LDKHTLCOutputInCommitment *NONNULL_PTR orig);
24560 export function HTLCOutputInCommitment_clone(orig: number): number {
24561 if(!isWasmInitialized) {
24562 throw new Error("initializeWasm() must be awaited first!");
24564 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone(orig);
24565 return nativeResponseValue;
24567 // struct LDKCVec_u8Z HTLCOutputInCommitment_write(const struct LDKHTLCOutputInCommitment *NONNULL_PTR obj);
24569 export function HTLCOutputInCommitment_write(obj: number): number {
24570 if(!isWasmInitialized) {
24571 throw new Error("initializeWasm() must be awaited first!");
24573 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_write(obj);
24574 return nativeResponseValue;
24576 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ HTLCOutputInCommitment_read(struct LDKu8slice ser);
24578 export function HTLCOutputInCommitment_read(ser: number): number {
24579 if(!isWasmInitialized) {
24580 throw new Error("initializeWasm() must be awaited first!");
24582 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_read(ser);
24583 return nativeResponseValue;
24585 // struct LDKCVec_u8Z get_htlc_redeemscript(const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc, bool opt_anchors, const struct LDKTxCreationKeys *NONNULL_PTR keys);
24587 export function get_htlc_redeemscript(htlc: number, opt_anchors: boolean, keys: number): number {
24588 if(!isWasmInitialized) {
24589 throw new Error("initializeWasm() must be awaited first!");
24591 const nativeResponseValue = wasm.TS_get_htlc_redeemscript(htlc, opt_anchors, keys);
24592 return nativeResponseValue;
24594 // struct LDKCVec_u8Z make_funding_redeemscript(struct LDKPublicKey broadcaster, struct LDKPublicKey countersignatory);
24596 export function make_funding_redeemscript(broadcaster: number, countersignatory: number): number {
24597 if(!isWasmInitialized) {
24598 throw new Error("initializeWasm() must be awaited first!");
24600 const nativeResponseValue = wasm.TS_make_funding_redeemscript(broadcaster, countersignatory);
24601 return nativeResponseValue;
24603 // 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);
24605 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 {
24606 if(!isWasmInitialized) {
24607 throw new Error("initializeWasm() must be awaited first!");
24609 const nativeResponseValue = wasm.TS_build_htlc_transaction(commitment_txid, feerate_per_kw, contest_delay, htlc, opt_anchors, broadcaster_delayed_payment_key, revocation_key);
24610 return nativeResponseValue;
24612 // struct LDKCVec_u8Z get_anchor_redeemscript(struct LDKPublicKey funding_pubkey);
24614 export function get_anchor_redeemscript(funding_pubkey: number): number {
24615 if(!isWasmInitialized) {
24616 throw new Error("initializeWasm() must be awaited first!");
24618 const nativeResponseValue = wasm.TS_get_anchor_redeemscript(funding_pubkey);
24619 return nativeResponseValue;
24621 // void ChannelTransactionParameters_free(struct LDKChannelTransactionParameters this_obj);
24623 export function ChannelTransactionParameters_free(this_obj: number): void {
24624 if(!isWasmInitialized) {
24625 throw new Error("initializeWasm() must be awaited first!");
24627 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_free(this_obj);
24628 // debug statements here
24630 // struct LDKChannelPublicKeys ChannelTransactionParameters_get_holder_pubkeys(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
24632 export function ChannelTransactionParameters_get_holder_pubkeys(this_ptr: number): number {
24633 if(!isWasmInitialized) {
24634 throw new Error("initializeWasm() must be awaited first!");
24636 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_pubkeys(this_ptr);
24637 return nativeResponseValue;
24639 // void ChannelTransactionParameters_set_holder_pubkeys(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
24641 export function ChannelTransactionParameters_set_holder_pubkeys(this_ptr: number, val: number): void {
24642 if(!isWasmInitialized) {
24643 throw new Error("initializeWasm() must be awaited first!");
24645 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_pubkeys(this_ptr, val);
24646 // debug statements here
24648 // uint16_t ChannelTransactionParameters_get_holder_selected_contest_delay(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
24650 export function ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr: number): number {
24651 if(!isWasmInitialized) {
24652 throw new Error("initializeWasm() must be awaited first!");
24654 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr);
24655 return nativeResponseValue;
24657 // void ChannelTransactionParameters_set_holder_selected_contest_delay(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
24659 export function ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr: number, val: number): void {
24660 if(!isWasmInitialized) {
24661 throw new Error("initializeWasm() must be awaited first!");
24663 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr, val);
24664 // debug statements here
24666 // bool ChannelTransactionParameters_get_is_outbound_from_holder(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
24668 export function ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr: number): boolean {
24669 if(!isWasmInitialized) {
24670 throw new Error("initializeWasm() must be awaited first!");
24672 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr);
24673 return nativeResponseValue;
24675 // void ChannelTransactionParameters_set_is_outbound_from_holder(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, bool val);
24677 export function ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr: number, val: boolean): void {
24678 if(!isWasmInitialized) {
24679 throw new Error("initializeWasm() must be awaited first!");
24681 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr, val);
24682 // debug statements here
24684 // struct LDKCounterpartyChannelTransactionParameters ChannelTransactionParameters_get_counterparty_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
24686 export function ChannelTransactionParameters_get_counterparty_parameters(this_ptr: number): number {
24687 if(!isWasmInitialized) {
24688 throw new Error("initializeWasm() must be awaited first!");
24690 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_counterparty_parameters(this_ptr);
24691 return nativeResponseValue;
24693 // void ChannelTransactionParameters_set_counterparty_parameters(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKCounterpartyChannelTransactionParameters val);
24695 export function ChannelTransactionParameters_set_counterparty_parameters(this_ptr: number, val: number): void {
24696 if(!isWasmInitialized) {
24697 throw new Error("initializeWasm() must be awaited first!");
24699 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_counterparty_parameters(this_ptr, val);
24700 // debug statements here
24702 // struct LDKOutPoint ChannelTransactionParameters_get_funding_outpoint(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
24704 export function ChannelTransactionParameters_get_funding_outpoint(this_ptr: number): number {
24705 if(!isWasmInitialized) {
24706 throw new Error("initializeWasm() must be awaited first!");
24708 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_funding_outpoint(this_ptr);
24709 return nativeResponseValue;
24711 // void ChannelTransactionParameters_set_funding_outpoint(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKOutPoint val);
24713 export function ChannelTransactionParameters_set_funding_outpoint(this_ptr: number, val: number): void {
24714 if(!isWasmInitialized) {
24715 throw new Error("initializeWasm() must be awaited first!");
24717 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_funding_outpoint(this_ptr, val);
24718 // debug statements here
24720 // enum LDKCOption_NoneZ ChannelTransactionParameters_get_opt_anchors(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
24722 export function ChannelTransactionParameters_get_opt_anchors(this_ptr: number): COption_NoneZ {
24723 if(!isWasmInitialized) {
24724 throw new Error("initializeWasm() must be awaited first!");
24726 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_opt_anchors(this_ptr);
24727 return nativeResponseValue;
24729 // void ChannelTransactionParameters_set_opt_anchors(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
24731 export function ChannelTransactionParameters_set_opt_anchors(this_ptr: number, val: COption_NoneZ): void {
24732 if(!isWasmInitialized) {
24733 throw new Error("initializeWasm() must be awaited first!");
24735 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_opt_anchors(this_ptr, val);
24736 // debug statements here
24738 // 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);
24740 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 {
24741 if(!isWasmInitialized) {
24742 throw new Error("initializeWasm() must be awaited first!");
24744 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);
24745 return nativeResponseValue;
24747 // uintptr_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg);
24749 export function ChannelTransactionParameters_clone_ptr(arg: number): number {
24750 if(!isWasmInitialized) {
24751 throw new Error("initializeWasm() must be awaited first!");
24753 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone_ptr(arg);
24754 return nativeResponseValue;
24756 // struct LDKChannelTransactionParameters ChannelTransactionParameters_clone(const struct LDKChannelTransactionParameters *NONNULL_PTR orig);
24758 export function ChannelTransactionParameters_clone(orig: number): number {
24759 if(!isWasmInitialized) {
24760 throw new Error("initializeWasm() must be awaited first!");
24762 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone(orig);
24763 return nativeResponseValue;
24765 // void CounterpartyChannelTransactionParameters_free(struct LDKCounterpartyChannelTransactionParameters this_obj);
24767 export function CounterpartyChannelTransactionParameters_free(this_obj: number): void {
24768 if(!isWasmInitialized) {
24769 throw new Error("initializeWasm() must be awaited first!");
24771 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_free(this_obj);
24772 // debug statements here
24774 // struct LDKChannelPublicKeys CounterpartyChannelTransactionParameters_get_pubkeys(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
24776 export function CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr: number): number {
24777 if(!isWasmInitialized) {
24778 throw new Error("initializeWasm() must be awaited first!");
24780 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr);
24781 return nativeResponseValue;
24783 // void CounterpartyChannelTransactionParameters_set_pubkeys(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
24785 export function CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr: number, val: number): void {
24786 if(!isWasmInitialized) {
24787 throw new Error("initializeWasm() must be awaited first!");
24789 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr, val);
24790 // debug statements here
24792 // uint16_t CounterpartyChannelTransactionParameters_get_selected_contest_delay(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
24794 export function CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr: number): number {
24795 if(!isWasmInitialized) {
24796 throw new Error("initializeWasm() must be awaited first!");
24798 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr);
24799 return nativeResponseValue;
24801 // void CounterpartyChannelTransactionParameters_set_selected_contest_delay(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
24803 export function CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr: number, val: number): void {
24804 if(!isWasmInitialized) {
24805 throw new Error("initializeWasm() must be awaited first!");
24807 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr, val);
24808 // debug statements here
24810 // MUST_USE_RES struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_new(struct LDKChannelPublicKeys pubkeys_arg, uint16_t selected_contest_delay_arg);
24812 export function CounterpartyChannelTransactionParameters_new(pubkeys_arg: number, selected_contest_delay_arg: number): number {
24813 if(!isWasmInitialized) {
24814 throw new Error("initializeWasm() must be awaited first!");
24816 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_new(pubkeys_arg, selected_contest_delay_arg);
24817 return nativeResponseValue;
24819 // uintptr_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg);
24821 export function CounterpartyChannelTransactionParameters_clone_ptr(arg: number): number {
24822 if(!isWasmInitialized) {
24823 throw new Error("initializeWasm() must be awaited first!");
24825 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone_ptr(arg);
24826 return nativeResponseValue;
24828 // struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_clone(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR orig);
24830 export function CounterpartyChannelTransactionParameters_clone(orig: number): number {
24831 if(!isWasmInitialized) {
24832 throw new Error("initializeWasm() must be awaited first!");
24834 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone(orig);
24835 return nativeResponseValue;
24837 // MUST_USE_RES bool ChannelTransactionParameters_is_populated(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
24839 export function ChannelTransactionParameters_is_populated(this_arg: number): boolean {
24840 if(!isWasmInitialized) {
24841 throw new Error("initializeWasm() must be awaited first!");
24843 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_is_populated(this_arg);
24844 return nativeResponseValue;
24846 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_holder_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
24848 export function ChannelTransactionParameters_as_holder_broadcastable(this_arg: number): number {
24849 if(!isWasmInitialized) {
24850 throw new Error("initializeWasm() must be awaited first!");
24852 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_holder_broadcastable(this_arg);
24853 return nativeResponseValue;
24855 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_counterparty_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
24857 export function ChannelTransactionParameters_as_counterparty_broadcastable(this_arg: number): number {
24858 if(!isWasmInitialized) {
24859 throw new Error("initializeWasm() must be awaited first!");
24861 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_counterparty_broadcastable(this_arg);
24862 return nativeResponseValue;
24864 // struct LDKCVec_u8Z CounterpartyChannelTransactionParameters_write(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR obj);
24866 export function CounterpartyChannelTransactionParameters_write(obj: number): number {
24867 if(!isWasmInitialized) {
24868 throw new Error("initializeWasm() must be awaited first!");
24870 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_write(obj);
24871 return nativeResponseValue;
24873 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CounterpartyChannelTransactionParameters_read(struct LDKu8slice ser);
24875 export function CounterpartyChannelTransactionParameters_read(ser: number): number {
24876 if(!isWasmInitialized) {
24877 throw new Error("initializeWasm() must be awaited first!");
24879 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_read(ser);
24880 return nativeResponseValue;
24882 // struct LDKCVec_u8Z ChannelTransactionParameters_write(const struct LDKChannelTransactionParameters *NONNULL_PTR obj);
24884 export function ChannelTransactionParameters_write(obj: number): number {
24885 if(!isWasmInitialized) {
24886 throw new Error("initializeWasm() must be awaited first!");
24888 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_write(obj);
24889 return nativeResponseValue;
24891 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ ChannelTransactionParameters_read(struct LDKu8slice ser);
24893 export function ChannelTransactionParameters_read(ser: number): number {
24894 if(!isWasmInitialized) {
24895 throw new Error("initializeWasm() must be awaited first!");
24897 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_read(ser);
24898 return nativeResponseValue;
24900 // void DirectedChannelTransactionParameters_free(struct LDKDirectedChannelTransactionParameters this_obj);
24902 export function DirectedChannelTransactionParameters_free(this_obj: number): void {
24903 if(!isWasmInitialized) {
24904 throw new Error("initializeWasm() must be awaited first!");
24906 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_free(this_obj);
24907 // debug statements here
24909 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_broadcaster_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
24911 export function DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg: number): number {
24912 if(!isWasmInitialized) {
24913 throw new Error("initializeWasm() must be awaited first!");
24915 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg);
24916 return nativeResponseValue;
24918 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_countersignatory_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
24920 export function DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg: number): number {
24921 if(!isWasmInitialized) {
24922 throw new Error("initializeWasm() must be awaited first!");
24924 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg);
24925 return nativeResponseValue;
24927 // MUST_USE_RES uint16_t DirectedChannelTransactionParameters_contest_delay(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
24929 export function DirectedChannelTransactionParameters_contest_delay(this_arg: number): number {
24930 if(!isWasmInitialized) {
24931 throw new Error("initializeWasm() must be awaited first!");
24933 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_contest_delay(this_arg);
24934 return nativeResponseValue;
24936 // MUST_USE_RES bool DirectedChannelTransactionParameters_is_outbound(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
24938 export function DirectedChannelTransactionParameters_is_outbound(this_arg: number): boolean {
24939 if(!isWasmInitialized) {
24940 throw new Error("initializeWasm() must be awaited first!");
24942 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_is_outbound(this_arg);
24943 return nativeResponseValue;
24945 // MUST_USE_RES struct LDKOutPoint DirectedChannelTransactionParameters_funding_outpoint(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
24947 export function DirectedChannelTransactionParameters_funding_outpoint(this_arg: number): number {
24948 if(!isWasmInitialized) {
24949 throw new Error("initializeWasm() must be awaited first!");
24951 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_funding_outpoint(this_arg);
24952 return nativeResponseValue;
24954 // MUST_USE_RES bool DirectedChannelTransactionParameters_opt_anchors(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
24956 export function DirectedChannelTransactionParameters_opt_anchors(this_arg: number): boolean {
24957 if(!isWasmInitialized) {
24958 throw new Error("initializeWasm() must be awaited first!");
24960 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_opt_anchors(this_arg);
24961 return nativeResponseValue;
24963 // void HolderCommitmentTransaction_free(struct LDKHolderCommitmentTransaction this_obj);
24965 export function HolderCommitmentTransaction_free(this_obj: number): void {
24966 if(!isWasmInitialized) {
24967 throw new Error("initializeWasm() must be awaited first!");
24969 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_free(this_obj);
24970 // debug statements here
24972 // struct LDKSignature HolderCommitmentTransaction_get_counterparty_sig(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
24974 export function HolderCommitmentTransaction_get_counterparty_sig(this_ptr: number): number {
24975 if(!isWasmInitialized) {
24976 throw new Error("initializeWasm() must be awaited first!");
24978 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_sig(this_ptr);
24979 return nativeResponseValue;
24981 // void HolderCommitmentTransaction_set_counterparty_sig(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKSignature val);
24983 export function HolderCommitmentTransaction_set_counterparty_sig(this_ptr: number, val: number): void {
24984 if(!isWasmInitialized) {
24985 throw new Error("initializeWasm() must be awaited first!");
24987 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_sig(this_ptr, val);
24988 // debug statements here
24990 // void HolderCommitmentTransaction_set_counterparty_htlc_sigs(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
24992 export function HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr: number, val: number): void {
24993 if(!isWasmInitialized) {
24994 throw new Error("initializeWasm() must be awaited first!");
24996 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr, val);
24997 // debug statements here
24999 // uintptr_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg);
25001 export function HolderCommitmentTransaction_clone_ptr(arg: number): number {
25002 if(!isWasmInitialized) {
25003 throw new Error("initializeWasm() must be awaited first!");
25005 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone_ptr(arg);
25006 return nativeResponseValue;
25008 // struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_clone(const struct LDKHolderCommitmentTransaction *NONNULL_PTR orig);
25010 export function HolderCommitmentTransaction_clone(orig: number): number {
25011 if(!isWasmInitialized) {
25012 throw new Error("initializeWasm() must be awaited first!");
25014 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone(orig);
25015 return nativeResponseValue;
25017 // struct LDKCVec_u8Z HolderCommitmentTransaction_write(const struct LDKHolderCommitmentTransaction *NONNULL_PTR obj);
25019 export function HolderCommitmentTransaction_write(obj: number): number {
25020 if(!isWasmInitialized) {
25021 throw new Error("initializeWasm() must be awaited first!");
25023 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_write(obj);
25024 return nativeResponseValue;
25026 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ HolderCommitmentTransaction_read(struct LDKu8slice ser);
25028 export function HolderCommitmentTransaction_read(ser: number): number {
25029 if(!isWasmInitialized) {
25030 throw new Error("initializeWasm() must be awaited first!");
25032 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_read(ser);
25033 return nativeResponseValue;
25035 // 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);
25037 export function HolderCommitmentTransaction_new(commitment_tx: number, counterparty_sig: number, counterparty_htlc_sigs: number, holder_funding_key: number, counterparty_funding_key: number): number {
25038 if(!isWasmInitialized) {
25039 throw new Error("initializeWasm() must be awaited first!");
25041 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_new(commitment_tx, counterparty_sig, counterparty_htlc_sigs, holder_funding_key, counterparty_funding_key);
25042 return nativeResponseValue;
25044 // void BuiltCommitmentTransaction_free(struct LDKBuiltCommitmentTransaction this_obj);
25046 export function BuiltCommitmentTransaction_free(this_obj: number): void {
25047 if(!isWasmInitialized) {
25048 throw new Error("initializeWasm() must be awaited first!");
25050 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_free(this_obj);
25051 // debug statements here
25053 // struct LDKTransaction BuiltCommitmentTransaction_get_transaction(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr);
25055 export function BuiltCommitmentTransaction_get_transaction(this_ptr: number): number {
25056 if(!isWasmInitialized) {
25057 throw new Error("initializeWasm() must be awaited first!");
25059 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_transaction(this_ptr);
25060 return nativeResponseValue;
25062 // void BuiltCommitmentTransaction_set_transaction(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKTransaction val);
25064 export function BuiltCommitmentTransaction_set_transaction(this_ptr: number, val: number): void {
25065 if(!isWasmInitialized) {
25066 throw new Error("initializeWasm() must be awaited first!");
25068 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_transaction(this_ptr, val);
25069 // debug statements here
25071 // const uint8_t (*BuiltCommitmentTransaction_get_txid(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr))[32];
25073 export function BuiltCommitmentTransaction_get_txid(this_ptr: number): number {
25074 if(!isWasmInitialized) {
25075 throw new Error("initializeWasm() must be awaited first!");
25077 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_txid(this_ptr);
25078 return nativeResponseValue;
25080 // void BuiltCommitmentTransaction_set_txid(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25082 export function BuiltCommitmentTransaction_set_txid(this_ptr: number, val: number): void {
25083 if(!isWasmInitialized) {
25084 throw new Error("initializeWasm() must be awaited first!");
25086 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_txid(this_ptr, val);
25087 // debug statements here
25089 // MUST_USE_RES struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_new(struct LDKTransaction transaction_arg, struct LDKThirtyTwoBytes txid_arg);
25091 export function BuiltCommitmentTransaction_new(transaction_arg: number, txid_arg: number): number {
25092 if(!isWasmInitialized) {
25093 throw new Error("initializeWasm() must be awaited first!");
25095 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_new(transaction_arg, txid_arg);
25096 return nativeResponseValue;
25098 // uintptr_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg);
25100 export function BuiltCommitmentTransaction_clone_ptr(arg: number): number {
25101 if(!isWasmInitialized) {
25102 throw new Error("initializeWasm() must be awaited first!");
25104 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone_ptr(arg);
25105 return nativeResponseValue;
25107 // struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_clone(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR orig);
25109 export function BuiltCommitmentTransaction_clone(orig: number): number {
25110 if(!isWasmInitialized) {
25111 throw new Error("initializeWasm() must be awaited first!");
25113 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone(orig);
25114 return nativeResponseValue;
25116 // struct LDKCVec_u8Z BuiltCommitmentTransaction_write(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR obj);
25118 export function BuiltCommitmentTransaction_write(obj: number): number {
25119 if(!isWasmInitialized) {
25120 throw new Error("initializeWasm() must be awaited first!");
25122 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_write(obj);
25123 return nativeResponseValue;
25125 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ BuiltCommitmentTransaction_read(struct LDKu8slice ser);
25127 export function BuiltCommitmentTransaction_read(ser: number): number {
25128 if(!isWasmInitialized) {
25129 throw new Error("initializeWasm() must be awaited first!");
25131 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_read(ser);
25132 return nativeResponseValue;
25134 // 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);
25136 export function BuiltCommitmentTransaction_get_sighash_all(this_arg: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
25137 if(!isWasmInitialized) {
25138 throw new Error("initializeWasm() must be awaited first!");
25140 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
25141 return nativeResponseValue;
25143 // 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);
25145 export function BuiltCommitmentTransaction_sign(this_arg: number, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
25146 if(!isWasmInitialized) {
25147 throw new Error("initializeWasm() must be awaited first!");
25149 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
25150 return nativeResponseValue;
25152 // void ClosingTransaction_free(struct LDKClosingTransaction this_obj);
25154 export function ClosingTransaction_free(this_obj: number): void {
25155 if(!isWasmInitialized) {
25156 throw new Error("initializeWasm() must be awaited first!");
25158 const nativeResponseValue = wasm.TS_ClosingTransaction_free(this_obj);
25159 // debug statements here
25161 // uintptr_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg);
25163 export function ClosingTransaction_clone_ptr(arg: number): number {
25164 if(!isWasmInitialized) {
25165 throw new Error("initializeWasm() must be awaited first!");
25167 const nativeResponseValue = wasm.TS_ClosingTransaction_clone_ptr(arg);
25168 return nativeResponseValue;
25170 // struct LDKClosingTransaction ClosingTransaction_clone(const struct LDKClosingTransaction *NONNULL_PTR orig);
25172 export function ClosingTransaction_clone(orig: number): number {
25173 if(!isWasmInitialized) {
25174 throw new Error("initializeWasm() must be awaited first!");
25176 const nativeResponseValue = wasm.TS_ClosingTransaction_clone(orig);
25177 return nativeResponseValue;
25179 // uint64_t ClosingTransaction_hash(const struct LDKClosingTransaction *NONNULL_PTR o);
25181 export function ClosingTransaction_hash(o: number): bigint {
25182 if(!isWasmInitialized) {
25183 throw new Error("initializeWasm() must be awaited first!");
25185 const nativeResponseValue = wasm.TS_ClosingTransaction_hash(o);
25186 return nativeResponseValue;
25188 // 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);
25190 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 {
25191 if(!isWasmInitialized) {
25192 throw new Error("initializeWasm() must be awaited first!");
25194 const nativeResponseValue = wasm.TS_ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
25195 return nativeResponseValue;
25197 // MUST_USE_RES struct LDKTrustedClosingTransaction ClosingTransaction_trust(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
25199 export function ClosingTransaction_trust(this_arg: number): number {
25200 if(!isWasmInitialized) {
25201 throw new Error("initializeWasm() must be awaited first!");
25203 const nativeResponseValue = wasm.TS_ClosingTransaction_trust(this_arg);
25204 return nativeResponseValue;
25206 // MUST_USE_RES struct LDKCResult_TrustedClosingTransactionNoneZ ClosingTransaction_verify(const struct LDKClosingTransaction *NONNULL_PTR this_arg, struct LDKOutPoint funding_outpoint);
25208 export function ClosingTransaction_verify(this_arg: number, funding_outpoint: number): number {
25209 if(!isWasmInitialized) {
25210 throw new Error("initializeWasm() must be awaited first!");
25212 const nativeResponseValue = wasm.TS_ClosingTransaction_verify(this_arg, funding_outpoint);
25213 return nativeResponseValue;
25215 // MUST_USE_RES uint64_t ClosingTransaction_to_holder_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
25217 export function ClosingTransaction_to_holder_value_sat(this_arg: number): bigint {
25218 if(!isWasmInitialized) {
25219 throw new Error("initializeWasm() must be awaited first!");
25221 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_value_sat(this_arg);
25222 return nativeResponseValue;
25224 // MUST_USE_RES uint64_t ClosingTransaction_to_counterparty_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
25226 export function ClosingTransaction_to_counterparty_value_sat(this_arg: number): bigint {
25227 if(!isWasmInitialized) {
25228 throw new Error("initializeWasm() must be awaited first!");
25230 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_value_sat(this_arg);
25231 return nativeResponseValue;
25233 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_holder_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
25235 export function ClosingTransaction_to_holder_script(this_arg: number): number {
25236 if(!isWasmInitialized) {
25237 throw new Error("initializeWasm() must be awaited first!");
25239 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_script(this_arg);
25240 return nativeResponseValue;
25242 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_counterparty_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
25244 export function ClosingTransaction_to_counterparty_script(this_arg: number): number {
25245 if(!isWasmInitialized) {
25246 throw new Error("initializeWasm() must be awaited first!");
25248 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_script(this_arg);
25249 return nativeResponseValue;
25251 // void TrustedClosingTransaction_free(struct LDKTrustedClosingTransaction this_obj);
25253 export function TrustedClosingTransaction_free(this_obj: number): void {
25254 if(!isWasmInitialized) {
25255 throw new Error("initializeWasm() must be awaited first!");
25257 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_free(this_obj);
25258 // debug statements here
25260 // MUST_USE_RES struct LDKTransaction TrustedClosingTransaction_built_transaction(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg);
25262 export function TrustedClosingTransaction_built_transaction(this_arg: number): number {
25263 if(!isWasmInitialized) {
25264 throw new Error("initializeWasm() must be awaited first!");
25266 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_built_transaction(this_arg);
25267 return nativeResponseValue;
25269 // 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);
25271 export function TrustedClosingTransaction_get_sighash_all(this_arg: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
25272 if(!isWasmInitialized) {
25273 throw new Error("initializeWasm() must be awaited first!");
25275 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
25276 return nativeResponseValue;
25278 // 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);
25280 export function TrustedClosingTransaction_sign(this_arg: number, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
25281 if(!isWasmInitialized) {
25282 throw new Error("initializeWasm() must be awaited first!");
25284 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
25285 return nativeResponseValue;
25287 // void CommitmentTransaction_free(struct LDKCommitmentTransaction this_obj);
25289 export function CommitmentTransaction_free(this_obj: number): void {
25290 if(!isWasmInitialized) {
25291 throw new Error("initializeWasm() must be awaited first!");
25293 const nativeResponseValue = wasm.TS_CommitmentTransaction_free(this_obj);
25294 // debug statements here
25296 // uintptr_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg);
25298 export function CommitmentTransaction_clone_ptr(arg: number): number {
25299 if(!isWasmInitialized) {
25300 throw new Error("initializeWasm() must be awaited first!");
25302 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone_ptr(arg);
25303 return nativeResponseValue;
25305 // struct LDKCommitmentTransaction CommitmentTransaction_clone(const struct LDKCommitmentTransaction *NONNULL_PTR orig);
25307 export function CommitmentTransaction_clone(orig: number): number {
25308 if(!isWasmInitialized) {
25309 throw new Error("initializeWasm() must be awaited first!");
25311 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone(orig);
25312 return nativeResponseValue;
25314 // struct LDKCVec_u8Z CommitmentTransaction_write(const struct LDKCommitmentTransaction *NONNULL_PTR obj);
25316 export function CommitmentTransaction_write(obj: number): number {
25317 if(!isWasmInitialized) {
25318 throw new Error("initializeWasm() must be awaited first!");
25320 const nativeResponseValue = wasm.TS_CommitmentTransaction_write(obj);
25321 return nativeResponseValue;
25323 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CommitmentTransaction_read(struct LDKu8slice ser);
25325 export function CommitmentTransaction_read(ser: number): number {
25326 if(!isWasmInitialized) {
25327 throw new Error("initializeWasm() must be awaited first!");
25329 const nativeResponseValue = wasm.TS_CommitmentTransaction_read(ser);
25330 return nativeResponseValue;
25332 // MUST_USE_RES uint64_t CommitmentTransaction_commitment_number(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
25334 export function CommitmentTransaction_commitment_number(this_arg: number): bigint {
25335 if(!isWasmInitialized) {
25336 throw new Error("initializeWasm() must be awaited first!");
25338 const nativeResponseValue = wasm.TS_CommitmentTransaction_commitment_number(this_arg);
25339 return nativeResponseValue;
25341 // MUST_USE_RES uint64_t CommitmentTransaction_to_broadcaster_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
25343 export function CommitmentTransaction_to_broadcaster_value_sat(this_arg: number): bigint {
25344 if(!isWasmInitialized) {
25345 throw new Error("initializeWasm() must be awaited first!");
25347 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_broadcaster_value_sat(this_arg);
25348 return nativeResponseValue;
25350 // MUST_USE_RES uint64_t CommitmentTransaction_to_countersignatory_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
25352 export function CommitmentTransaction_to_countersignatory_value_sat(this_arg: number): bigint {
25353 if(!isWasmInitialized) {
25354 throw new Error("initializeWasm() must be awaited first!");
25356 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_countersignatory_value_sat(this_arg);
25357 return nativeResponseValue;
25359 // MUST_USE_RES uint32_t CommitmentTransaction_feerate_per_kw(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
25361 export function CommitmentTransaction_feerate_per_kw(this_arg: number): number {
25362 if(!isWasmInitialized) {
25363 throw new Error("initializeWasm() must be awaited first!");
25365 const nativeResponseValue = wasm.TS_CommitmentTransaction_feerate_per_kw(this_arg);
25366 return nativeResponseValue;
25368 // MUST_USE_RES struct LDKTrustedCommitmentTransaction CommitmentTransaction_trust(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
25370 export function CommitmentTransaction_trust(this_arg: number): number {
25371 if(!isWasmInitialized) {
25372 throw new Error("initializeWasm() must be awaited first!");
25374 const nativeResponseValue = wasm.TS_CommitmentTransaction_trust(this_arg);
25375 return nativeResponseValue;
25377 // 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);
25379 export function CommitmentTransaction_verify(this_arg: number, channel_parameters: number, broadcaster_keys: number, countersignatory_keys: number): number {
25380 if(!isWasmInitialized) {
25381 throw new Error("initializeWasm() must be awaited first!");
25383 const nativeResponseValue = wasm.TS_CommitmentTransaction_verify(this_arg, channel_parameters, broadcaster_keys, countersignatory_keys);
25384 return nativeResponseValue;
25386 // void TrustedCommitmentTransaction_free(struct LDKTrustedCommitmentTransaction this_obj);
25388 export function TrustedCommitmentTransaction_free(this_obj: number): void {
25389 if(!isWasmInitialized) {
25390 throw new Error("initializeWasm() must be awaited first!");
25392 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_free(this_obj);
25393 // debug statements here
25395 // MUST_USE_RES struct LDKThirtyTwoBytes TrustedCommitmentTransaction_txid(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
25397 export function TrustedCommitmentTransaction_txid(this_arg: number): number {
25398 if(!isWasmInitialized) {
25399 throw new Error("initializeWasm() must be awaited first!");
25401 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_txid(this_arg);
25402 return nativeResponseValue;
25404 // MUST_USE_RES struct LDKBuiltCommitmentTransaction TrustedCommitmentTransaction_built_transaction(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
25406 export function TrustedCommitmentTransaction_built_transaction(this_arg: number): number {
25407 if(!isWasmInitialized) {
25408 throw new Error("initializeWasm() must be awaited first!");
25410 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_built_transaction(this_arg);
25411 return nativeResponseValue;
25413 // MUST_USE_RES struct LDKTxCreationKeys TrustedCommitmentTransaction_keys(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
25415 export function TrustedCommitmentTransaction_keys(this_arg: number): number {
25416 if(!isWasmInitialized) {
25417 throw new Error("initializeWasm() must be awaited first!");
25419 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_keys(this_arg);
25420 return nativeResponseValue;
25422 // MUST_USE_RES bool TrustedCommitmentTransaction_opt_anchors(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
25424 export function TrustedCommitmentTransaction_opt_anchors(this_arg: number): boolean {
25425 if(!isWasmInitialized) {
25426 throw new Error("initializeWasm() must be awaited first!");
25428 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_opt_anchors(this_arg);
25429 return nativeResponseValue;
25431 // 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);
25433 export function TrustedCommitmentTransaction_get_htlc_sigs(this_arg: number, htlc_base_key: number, channel_parameters: number): number {
25434 if(!isWasmInitialized) {
25435 throw new Error("initializeWasm() must be awaited first!");
25437 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_get_htlc_sigs(this_arg, htlc_base_key, channel_parameters);
25438 return nativeResponseValue;
25440 // uint64_t get_commitment_transaction_number_obscure_factor(struct LDKPublicKey broadcaster_payment_basepoint, struct LDKPublicKey countersignatory_payment_basepoint, bool outbound_from_broadcaster);
25442 export function get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint: number, countersignatory_payment_basepoint: number, outbound_from_broadcaster: boolean): bigint {
25443 if(!isWasmInitialized) {
25444 throw new Error("initializeWasm() must be awaited first!");
25446 const nativeResponseValue = wasm.TS_get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint, countersignatory_payment_basepoint, outbound_from_broadcaster);
25447 return nativeResponseValue;
25449 // bool InitFeatures_eq(const struct LDKInitFeatures *NONNULL_PTR a, const struct LDKInitFeatures *NONNULL_PTR b);
25451 export function InitFeatures_eq(a: number, b: number): boolean {
25452 if(!isWasmInitialized) {
25453 throw new Error("initializeWasm() must be awaited first!");
25455 const nativeResponseValue = wasm.TS_InitFeatures_eq(a, b);
25456 return nativeResponseValue;
25458 // bool NodeFeatures_eq(const struct LDKNodeFeatures *NONNULL_PTR a, const struct LDKNodeFeatures *NONNULL_PTR b);
25460 export function NodeFeatures_eq(a: number, b: number): boolean {
25461 if(!isWasmInitialized) {
25462 throw new Error("initializeWasm() must be awaited first!");
25464 const nativeResponseValue = wasm.TS_NodeFeatures_eq(a, b);
25465 return nativeResponseValue;
25467 // bool ChannelFeatures_eq(const struct LDKChannelFeatures *NONNULL_PTR a, const struct LDKChannelFeatures *NONNULL_PTR b);
25469 export function ChannelFeatures_eq(a: number, b: number): boolean {
25470 if(!isWasmInitialized) {
25471 throw new Error("initializeWasm() must be awaited first!");
25473 const nativeResponseValue = wasm.TS_ChannelFeatures_eq(a, b);
25474 return nativeResponseValue;
25476 // bool InvoiceFeatures_eq(const struct LDKInvoiceFeatures *NONNULL_PTR a, const struct LDKInvoiceFeatures *NONNULL_PTR b);
25478 export function InvoiceFeatures_eq(a: number, b: number): boolean {
25479 if(!isWasmInitialized) {
25480 throw new Error("initializeWasm() must be awaited first!");
25482 const nativeResponseValue = wasm.TS_InvoiceFeatures_eq(a, b);
25483 return nativeResponseValue;
25485 // bool ChannelTypeFeatures_eq(const struct LDKChannelTypeFeatures *NONNULL_PTR a, const struct LDKChannelTypeFeatures *NONNULL_PTR b);
25487 export function ChannelTypeFeatures_eq(a: number, b: number): boolean {
25488 if(!isWasmInitialized) {
25489 throw new Error("initializeWasm() must be awaited first!");
25491 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_eq(a, b);
25492 return nativeResponseValue;
25494 // uintptr_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg);
25496 export function InitFeatures_clone_ptr(arg: number): number {
25497 if(!isWasmInitialized) {
25498 throw new Error("initializeWasm() must be awaited first!");
25500 const nativeResponseValue = wasm.TS_InitFeatures_clone_ptr(arg);
25501 return nativeResponseValue;
25503 // struct LDKInitFeatures InitFeatures_clone(const struct LDKInitFeatures *NONNULL_PTR orig);
25505 export function InitFeatures_clone(orig: number): number {
25506 if(!isWasmInitialized) {
25507 throw new Error("initializeWasm() must be awaited first!");
25509 const nativeResponseValue = wasm.TS_InitFeatures_clone(orig);
25510 return nativeResponseValue;
25512 // uintptr_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg);
25514 export function NodeFeatures_clone_ptr(arg: number): number {
25515 if(!isWasmInitialized) {
25516 throw new Error("initializeWasm() must be awaited first!");
25518 const nativeResponseValue = wasm.TS_NodeFeatures_clone_ptr(arg);
25519 return nativeResponseValue;
25521 // struct LDKNodeFeatures NodeFeatures_clone(const struct LDKNodeFeatures *NONNULL_PTR orig);
25523 export function NodeFeatures_clone(orig: number): number {
25524 if(!isWasmInitialized) {
25525 throw new Error("initializeWasm() must be awaited first!");
25527 const nativeResponseValue = wasm.TS_NodeFeatures_clone(orig);
25528 return nativeResponseValue;
25530 // uintptr_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg);
25532 export function ChannelFeatures_clone_ptr(arg: number): number {
25533 if(!isWasmInitialized) {
25534 throw new Error("initializeWasm() must be awaited first!");
25536 const nativeResponseValue = wasm.TS_ChannelFeatures_clone_ptr(arg);
25537 return nativeResponseValue;
25539 // struct LDKChannelFeatures ChannelFeatures_clone(const struct LDKChannelFeatures *NONNULL_PTR orig);
25541 export function ChannelFeatures_clone(orig: number): number {
25542 if(!isWasmInitialized) {
25543 throw new Error("initializeWasm() must be awaited first!");
25545 const nativeResponseValue = wasm.TS_ChannelFeatures_clone(orig);
25546 return nativeResponseValue;
25548 // uintptr_t InvoiceFeatures_clone_ptr(LDKInvoiceFeatures *NONNULL_PTR arg);
25550 export function InvoiceFeatures_clone_ptr(arg: number): number {
25551 if(!isWasmInitialized) {
25552 throw new Error("initializeWasm() must be awaited first!");
25554 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone_ptr(arg);
25555 return nativeResponseValue;
25557 // struct LDKInvoiceFeatures InvoiceFeatures_clone(const struct LDKInvoiceFeatures *NONNULL_PTR orig);
25559 export function InvoiceFeatures_clone(orig: number): number {
25560 if(!isWasmInitialized) {
25561 throw new Error("initializeWasm() must be awaited first!");
25563 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone(orig);
25564 return nativeResponseValue;
25566 // uintptr_t ChannelTypeFeatures_clone_ptr(LDKChannelTypeFeatures *NONNULL_PTR arg);
25568 export function ChannelTypeFeatures_clone_ptr(arg: number): number {
25569 if(!isWasmInitialized) {
25570 throw new Error("initializeWasm() must be awaited first!");
25572 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone_ptr(arg);
25573 return nativeResponseValue;
25575 // struct LDKChannelTypeFeatures ChannelTypeFeatures_clone(const struct LDKChannelTypeFeatures *NONNULL_PTR orig);
25577 export function ChannelTypeFeatures_clone(orig: number): number {
25578 if(!isWasmInitialized) {
25579 throw new Error("initializeWasm() must be awaited first!");
25581 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone(orig);
25582 return nativeResponseValue;
25584 // void InitFeatures_free(struct LDKInitFeatures this_obj);
25586 export function InitFeatures_free(this_obj: number): void {
25587 if(!isWasmInitialized) {
25588 throw new Error("initializeWasm() must be awaited first!");
25590 const nativeResponseValue = wasm.TS_InitFeatures_free(this_obj);
25591 // debug statements here
25593 // void NodeFeatures_free(struct LDKNodeFeatures this_obj);
25595 export function NodeFeatures_free(this_obj: number): void {
25596 if(!isWasmInitialized) {
25597 throw new Error("initializeWasm() must be awaited first!");
25599 const nativeResponseValue = wasm.TS_NodeFeatures_free(this_obj);
25600 // debug statements here
25602 // void ChannelFeatures_free(struct LDKChannelFeatures this_obj);
25604 export function ChannelFeatures_free(this_obj: number): void {
25605 if(!isWasmInitialized) {
25606 throw new Error("initializeWasm() must be awaited first!");
25608 const nativeResponseValue = wasm.TS_ChannelFeatures_free(this_obj);
25609 // debug statements here
25611 // void InvoiceFeatures_free(struct LDKInvoiceFeatures this_obj);
25613 export function InvoiceFeatures_free(this_obj: number): void {
25614 if(!isWasmInitialized) {
25615 throw new Error("initializeWasm() must be awaited first!");
25617 const nativeResponseValue = wasm.TS_InvoiceFeatures_free(this_obj);
25618 // debug statements here
25620 // void ChannelTypeFeatures_free(struct LDKChannelTypeFeatures this_obj);
25622 export function ChannelTypeFeatures_free(this_obj: number): void {
25623 if(!isWasmInitialized) {
25624 throw new Error("initializeWasm() must be awaited first!");
25626 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_free(this_obj);
25627 // debug statements here
25629 // MUST_USE_RES struct LDKInitFeatures InitFeatures_empty(void);
25631 export function InitFeatures_empty(): number {
25632 if(!isWasmInitialized) {
25633 throw new Error("initializeWasm() must be awaited first!");
25635 const nativeResponseValue = wasm.TS_InitFeatures_empty();
25636 return nativeResponseValue;
25638 // MUST_USE_RES struct LDKInitFeatures InitFeatures_known(void);
25640 export function InitFeatures_known(): number {
25641 if(!isWasmInitialized) {
25642 throw new Error("initializeWasm() must be awaited first!");
25644 const nativeResponseValue = wasm.TS_InitFeatures_known();
25645 return nativeResponseValue;
25647 // MUST_USE_RES bool InitFeatures_requires_unknown_bits(const struct LDKInitFeatures *NONNULL_PTR this_arg);
25649 export function InitFeatures_requires_unknown_bits(this_arg: number): boolean {
25650 if(!isWasmInitialized) {
25651 throw new Error("initializeWasm() must be awaited first!");
25653 const nativeResponseValue = wasm.TS_InitFeatures_requires_unknown_bits(this_arg);
25654 return nativeResponseValue;
25656 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_empty(void);
25658 export function NodeFeatures_empty(): number {
25659 if(!isWasmInitialized) {
25660 throw new Error("initializeWasm() must be awaited first!");
25662 const nativeResponseValue = wasm.TS_NodeFeatures_empty();
25663 return nativeResponseValue;
25665 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_known(void);
25667 export function NodeFeatures_known(): number {
25668 if(!isWasmInitialized) {
25669 throw new Error("initializeWasm() must be awaited first!");
25671 const nativeResponseValue = wasm.TS_NodeFeatures_known();
25672 return nativeResponseValue;
25674 // MUST_USE_RES bool NodeFeatures_requires_unknown_bits(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
25676 export function NodeFeatures_requires_unknown_bits(this_arg: number): boolean {
25677 if(!isWasmInitialized) {
25678 throw new Error("initializeWasm() must be awaited first!");
25680 const nativeResponseValue = wasm.TS_NodeFeatures_requires_unknown_bits(this_arg);
25681 return nativeResponseValue;
25683 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_empty(void);
25685 export function ChannelFeatures_empty(): number {
25686 if(!isWasmInitialized) {
25687 throw new Error("initializeWasm() must be awaited first!");
25689 const nativeResponseValue = wasm.TS_ChannelFeatures_empty();
25690 return nativeResponseValue;
25692 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_known(void);
25694 export function ChannelFeatures_known(): number {
25695 if(!isWasmInitialized) {
25696 throw new Error("initializeWasm() must be awaited first!");
25698 const nativeResponseValue = wasm.TS_ChannelFeatures_known();
25699 return nativeResponseValue;
25701 // MUST_USE_RES bool ChannelFeatures_requires_unknown_bits(const struct LDKChannelFeatures *NONNULL_PTR this_arg);
25703 export function ChannelFeatures_requires_unknown_bits(this_arg: number): boolean {
25704 if(!isWasmInitialized) {
25705 throw new Error("initializeWasm() must be awaited first!");
25707 const nativeResponseValue = wasm.TS_ChannelFeatures_requires_unknown_bits(this_arg);
25708 return nativeResponseValue;
25710 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_empty(void);
25712 export function InvoiceFeatures_empty(): number {
25713 if(!isWasmInitialized) {
25714 throw new Error("initializeWasm() must be awaited first!");
25716 const nativeResponseValue = wasm.TS_InvoiceFeatures_empty();
25717 return nativeResponseValue;
25719 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_known(void);
25721 export function InvoiceFeatures_known(): number {
25722 if(!isWasmInitialized) {
25723 throw new Error("initializeWasm() must be awaited first!");
25725 const nativeResponseValue = wasm.TS_InvoiceFeatures_known();
25726 return nativeResponseValue;
25728 // MUST_USE_RES bool InvoiceFeatures_requires_unknown_bits(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
25730 export function InvoiceFeatures_requires_unknown_bits(this_arg: number): boolean {
25731 if(!isWasmInitialized) {
25732 throw new Error("initializeWasm() must be awaited first!");
25734 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_unknown_bits(this_arg);
25735 return nativeResponseValue;
25737 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_empty(void);
25739 export function ChannelTypeFeatures_empty(): number {
25740 if(!isWasmInitialized) {
25741 throw new Error("initializeWasm() must be awaited first!");
25743 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_empty();
25744 return nativeResponseValue;
25746 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_known(void);
25748 export function ChannelTypeFeatures_known(): number {
25749 if(!isWasmInitialized) {
25750 throw new Error("initializeWasm() must be awaited first!");
25752 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_known();
25753 return nativeResponseValue;
25755 // MUST_USE_RES bool ChannelTypeFeatures_requires_unknown_bits(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
25757 export function ChannelTypeFeatures_requires_unknown_bits(this_arg: number): boolean {
25758 if(!isWasmInitialized) {
25759 throw new Error("initializeWasm() must be awaited first!");
25761 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_unknown_bits(this_arg);
25762 return nativeResponseValue;
25764 // struct LDKCVec_u8Z InitFeatures_write(const struct LDKInitFeatures *NONNULL_PTR obj);
25766 export function InitFeatures_write(obj: number): number {
25767 if(!isWasmInitialized) {
25768 throw new Error("initializeWasm() must be awaited first!");
25770 const nativeResponseValue = wasm.TS_InitFeatures_write(obj);
25771 return nativeResponseValue;
25773 // struct LDKCResult_InitFeaturesDecodeErrorZ InitFeatures_read(struct LDKu8slice ser);
25775 export function InitFeatures_read(ser: number): number {
25776 if(!isWasmInitialized) {
25777 throw new Error("initializeWasm() must be awaited first!");
25779 const nativeResponseValue = wasm.TS_InitFeatures_read(ser);
25780 return nativeResponseValue;
25782 // struct LDKCVec_u8Z ChannelFeatures_write(const struct LDKChannelFeatures *NONNULL_PTR obj);
25784 export function ChannelFeatures_write(obj: number): number {
25785 if(!isWasmInitialized) {
25786 throw new Error("initializeWasm() must be awaited first!");
25788 const nativeResponseValue = wasm.TS_ChannelFeatures_write(obj);
25789 return nativeResponseValue;
25791 // struct LDKCResult_ChannelFeaturesDecodeErrorZ ChannelFeatures_read(struct LDKu8slice ser);
25793 export function ChannelFeatures_read(ser: number): number {
25794 if(!isWasmInitialized) {
25795 throw new Error("initializeWasm() must be awaited first!");
25797 const nativeResponseValue = wasm.TS_ChannelFeatures_read(ser);
25798 return nativeResponseValue;
25800 // struct LDKCVec_u8Z NodeFeatures_write(const struct LDKNodeFeatures *NONNULL_PTR obj);
25802 export function NodeFeatures_write(obj: number): number {
25803 if(!isWasmInitialized) {
25804 throw new Error("initializeWasm() must be awaited first!");
25806 const nativeResponseValue = wasm.TS_NodeFeatures_write(obj);
25807 return nativeResponseValue;
25809 // struct LDKCResult_NodeFeaturesDecodeErrorZ NodeFeatures_read(struct LDKu8slice ser);
25811 export function NodeFeatures_read(ser: number): number {
25812 if(!isWasmInitialized) {
25813 throw new Error("initializeWasm() must be awaited first!");
25815 const nativeResponseValue = wasm.TS_NodeFeatures_read(ser);
25816 return nativeResponseValue;
25818 // struct LDKCVec_u8Z InvoiceFeatures_write(const struct LDKInvoiceFeatures *NONNULL_PTR obj);
25820 export function InvoiceFeatures_write(obj: number): number {
25821 if(!isWasmInitialized) {
25822 throw new Error("initializeWasm() must be awaited first!");
25824 const nativeResponseValue = wasm.TS_InvoiceFeatures_write(obj);
25825 return nativeResponseValue;
25827 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ InvoiceFeatures_read(struct LDKu8slice ser);
25829 export function InvoiceFeatures_read(ser: number): number {
25830 if(!isWasmInitialized) {
25831 throw new Error("initializeWasm() must be awaited first!");
25833 const nativeResponseValue = wasm.TS_InvoiceFeatures_read(ser);
25834 return nativeResponseValue;
25836 // struct LDKCVec_u8Z ChannelTypeFeatures_write(const struct LDKChannelTypeFeatures *NONNULL_PTR obj);
25838 export function ChannelTypeFeatures_write(obj: number): number {
25839 if(!isWasmInitialized) {
25840 throw new Error("initializeWasm() must be awaited first!");
25842 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_write(obj);
25843 return nativeResponseValue;
25845 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ ChannelTypeFeatures_read(struct LDKu8slice ser);
25847 export function ChannelTypeFeatures_read(ser: number): number {
25848 if(!isWasmInitialized) {
25849 throw new Error("initializeWasm() must be awaited first!");
25851 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_read(ser);
25852 return nativeResponseValue;
25854 // void ShutdownScript_free(struct LDKShutdownScript this_obj);
25856 export function ShutdownScript_free(this_obj: number): void {
25857 if(!isWasmInitialized) {
25858 throw new Error("initializeWasm() must be awaited first!");
25860 const nativeResponseValue = wasm.TS_ShutdownScript_free(this_obj);
25861 // debug statements here
25863 // uintptr_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg);
25865 export function ShutdownScript_clone_ptr(arg: number): number {
25866 if(!isWasmInitialized) {
25867 throw new Error("initializeWasm() must be awaited first!");
25869 const nativeResponseValue = wasm.TS_ShutdownScript_clone_ptr(arg);
25870 return nativeResponseValue;
25872 // struct LDKShutdownScript ShutdownScript_clone(const struct LDKShutdownScript *NONNULL_PTR orig);
25874 export function ShutdownScript_clone(orig: number): number {
25875 if(!isWasmInitialized) {
25876 throw new Error("initializeWasm() must be awaited first!");
25878 const nativeResponseValue = wasm.TS_ShutdownScript_clone(orig);
25879 return nativeResponseValue;
25881 // void InvalidShutdownScript_free(struct LDKInvalidShutdownScript this_obj);
25883 export function InvalidShutdownScript_free(this_obj: number): void {
25884 if(!isWasmInitialized) {
25885 throw new Error("initializeWasm() must be awaited first!");
25887 const nativeResponseValue = wasm.TS_InvalidShutdownScript_free(this_obj);
25888 // debug statements here
25890 // struct LDKu8slice InvalidShutdownScript_get_script(const struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr);
25892 export function InvalidShutdownScript_get_script(this_ptr: number): number {
25893 if(!isWasmInitialized) {
25894 throw new Error("initializeWasm() must be awaited first!");
25896 const nativeResponseValue = wasm.TS_InvalidShutdownScript_get_script(this_ptr);
25897 return nativeResponseValue;
25899 // void InvalidShutdownScript_set_script(struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
25901 export function InvalidShutdownScript_set_script(this_ptr: number, val: number): void {
25902 if(!isWasmInitialized) {
25903 throw new Error("initializeWasm() must be awaited first!");
25905 const nativeResponseValue = wasm.TS_InvalidShutdownScript_set_script(this_ptr, val);
25906 // debug statements here
25908 // MUST_USE_RES struct LDKInvalidShutdownScript InvalidShutdownScript_new(struct LDKCVec_u8Z script_arg);
25910 export function InvalidShutdownScript_new(script_arg: number): number {
25911 if(!isWasmInitialized) {
25912 throw new Error("initializeWasm() must be awaited first!");
25914 const nativeResponseValue = wasm.TS_InvalidShutdownScript_new(script_arg);
25915 return nativeResponseValue;
25917 // uintptr_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg);
25919 export function InvalidShutdownScript_clone_ptr(arg: number): number {
25920 if(!isWasmInitialized) {
25921 throw new Error("initializeWasm() must be awaited first!");
25923 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone_ptr(arg);
25924 return nativeResponseValue;
25926 // struct LDKInvalidShutdownScript InvalidShutdownScript_clone(const struct LDKInvalidShutdownScript *NONNULL_PTR orig);
25928 export function InvalidShutdownScript_clone(orig: number): number {
25929 if(!isWasmInitialized) {
25930 throw new Error("initializeWasm() must be awaited first!");
25932 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone(orig);
25933 return nativeResponseValue;
25935 // struct LDKCVec_u8Z ShutdownScript_write(const struct LDKShutdownScript *NONNULL_PTR obj);
25937 export function ShutdownScript_write(obj: number): number {
25938 if(!isWasmInitialized) {
25939 throw new Error("initializeWasm() must be awaited first!");
25941 const nativeResponseValue = wasm.TS_ShutdownScript_write(obj);
25942 return nativeResponseValue;
25944 // struct LDKCResult_ShutdownScriptDecodeErrorZ ShutdownScript_read(struct LDKu8slice ser);
25946 export function ShutdownScript_read(ser: number): number {
25947 if(!isWasmInitialized) {
25948 throw new Error("initializeWasm() must be awaited first!");
25950 const nativeResponseValue = wasm.TS_ShutdownScript_read(ser);
25951 return nativeResponseValue;
25953 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wpkh(const uint8_t (*pubkey_hash)[20]);
25955 export function ShutdownScript_new_p2wpkh(pubkey_hash: number): number {
25956 if(!isWasmInitialized) {
25957 throw new Error("initializeWasm() must be awaited first!");
25959 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wpkh(pubkey_hash);
25960 return nativeResponseValue;
25962 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wsh(const uint8_t (*script_hash)[32]);
25964 export function ShutdownScript_new_p2wsh(script_hash: number): number {
25965 if(!isWasmInitialized) {
25966 throw new Error("initializeWasm() must be awaited first!");
25968 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wsh(script_hash);
25969 return nativeResponseValue;
25971 // MUST_USE_RES struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ ShutdownScript_new_witness_program(uint8_t version, struct LDKu8slice program);
25973 export function ShutdownScript_new_witness_program(version: number, program: number): number {
25974 if(!isWasmInitialized) {
25975 throw new Error("initializeWasm() must be awaited first!");
25977 const nativeResponseValue = wasm.TS_ShutdownScript_new_witness_program(version, program);
25978 return nativeResponseValue;
25980 // MUST_USE_RES struct LDKCVec_u8Z ShutdownScript_into_inner(struct LDKShutdownScript this_arg);
25982 export function ShutdownScript_into_inner(this_arg: number): number {
25983 if(!isWasmInitialized) {
25984 throw new Error("initializeWasm() must be awaited first!");
25986 const nativeResponseValue = wasm.TS_ShutdownScript_into_inner(this_arg);
25987 return nativeResponseValue;
25989 // MUST_USE_RES struct LDKPublicKey ShutdownScript_as_legacy_pubkey(const struct LDKShutdownScript *NONNULL_PTR this_arg);
25991 export function ShutdownScript_as_legacy_pubkey(this_arg: number): number {
25992 if(!isWasmInitialized) {
25993 throw new Error("initializeWasm() must be awaited first!");
25995 const nativeResponseValue = wasm.TS_ShutdownScript_as_legacy_pubkey(this_arg);
25996 return nativeResponseValue;
25998 // MUST_USE_RES bool ShutdownScript_is_compatible(const struct LDKShutdownScript *NONNULL_PTR this_arg, const struct LDKInitFeatures *NONNULL_PTR features);
26000 export function ShutdownScript_is_compatible(this_arg: number, features: number): boolean {
26001 if(!isWasmInitialized) {
26002 throw new Error("initializeWasm() must be awaited first!");
26004 const nativeResponseValue = wasm.TS_ShutdownScript_is_compatible(this_arg, features);
26005 return nativeResponseValue;
26007 // void CustomMessageReader_free(struct LDKCustomMessageReader this_ptr);
26009 export function CustomMessageReader_free(this_ptr: number): void {
26010 if(!isWasmInitialized) {
26011 throw new Error("initializeWasm() must be awaited first!");
26013 const nativeResponseValue = wasm.TS_CustomMessageReader_free(this_ptr);
26014 // debug statements here
26016 // uintptr_t Type_clone_ptr(LDKType *NONNULL_PTR arg);
26018 export function Type_clone_ptr(arg: number): number {
26019 if(!isWasmInitialized) {
26020 throw new Error("initializeWasm() must be awaited first!");
26022 const nativeResponseValue = wasm.TS_Type_clone_ptr(arg);
26023 return nativeResponseValue;
26025 // struct LDKType Type_clone(const struct LDKType *NONNULL_PTR orig);
26027 export function Type_clone(orig: number): number {
26028 if(!isWasmInitialized) {
26029 throw new Error("initializeWasm() must be awaited first!");
26031 const nativeResponseValue = wasm.TS_Type_clone(orig);
26032 return nativeResponseValue;
26034 // void Type_free(struct LDKType this_ptr);
26036 export function Type_free(this_ptr: number): void {
26037 if(!isWasmInitialized) {
26038 throw new Error("initializeWasm() must be awaited first!");
26040 const nativeResponseValue = wasm.TS_Type_free(this_ptr);
26041 // debug statements here
26043 // void NodeId_free(struct LDKNodeId this_obj);
26045 export function NodeId_free(this_obj: number): void {
26046 if(!isWasmInitialized) {
26047 throw new Error("initializeWasm() must be awaited first!");
26049 const nativeResponseValue = wasm.TS_NodeId_free(this_obj);
26050 // debug statements here
26052 // uintptr_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg);
26054 export function NodeId_clone_ptr(arg: number): number {
26055 if(!isWasmInitialized) {
26056 throw new Error("initializeWasm() must be awaited first!");
26058 const nativeResponseValue = wasm.TS_NodeId_clone_ptr(arg);
26059 return nativeResponseValue;
26061 // struct LDKNodeId NodeId_clone(const struct LDKNodeId *NONNULL_PTR orig);
26063 export function NodeId_clone(orig: number): number {
26064 if(!isWasmInitialized) {
26065 throw new Error("initializeWasm() must be awaited first!");
26067 const nativeResponseValue = wasm.TS_NodeId_clone(orig);
26068 return nativeResponseValue;
26070 // MUST_USE_RES struct LDKNodeId NodeId_from_pubkey(struct LDKPublicKey pubkey);
26072 export function NodeId_from_pubkey(pubkey: number): number {
26073 if(!isWasmInitialized) {
26074 throw new Error("initializeWasm() must be awaited first!");
26076 const nativeResponseValue = wasm.TS_NodeId_from_pubkey(pubkey);
26077 return nativeResponseValue;
26079 // MUST_USE_RES struct LDKu8slice NodeId_as_slice(const struct LDKNodeId *NONNULL_PTR this_arg);
26081 export function NodeId_as_slice(this_arg: number): number {
26082 if(!isWasmInitialized) {
26083 throw new Error("initializeWasm() must be awaited first!");
26085 const nativeResponseValue = wasm.TS_NodeId_as_slice(this_arg);
26086 return nativeResponseValue;
26088 // uint64_t NodeId_hash(const struct LDKNodeId *NONNULL_PTR o);
26090 export function NodeId_hash(o: number): bigint {
26091 if(!isWasmInitialized) {
26092 throw new Error("initializeWasm() must be awaited first!");
26094 const nativeResponseValue = wasm.TS_NodeId_hash(o);
26095 return nativeResponseValue;
26097 // struct LDKCVec_u8Z NodeId_write(const struct LDKNodeId *NONNULL_PTR obj);
26099 export function NodeId_write(obj: number): number {
26100 if(!isWasmInitialized) {
26101 throw new Error("initializeWasm() must be awaited first!");
26103 const nativeResponseValue = wasm.TS_NodeId_write(obj);
26104 return nativeResponseValue;
26106 // struct LDKCResult_NodeIdDecodeErrorZ NodeId_read(struct LDKu8slice ser);
26108 export function NodeId_read(ser: number): number {
26109 if(!isWasmInitialized) {
26110 throw new Error("initializeWasm() must be awaited first!");
26112 const nativeResponseValue = wasm.TS_NodeId_read(ser);
26113 return nativeResponseValue;
26115 // void NetworkGraph_free(struct LDKNetworkGraph this_obj);
26117 export function NetworkGraph_free(this_obj: number): void {
26118 if(!isWasmInitialized) {
26119 throw new Error("initializeWasm() must be awaited first!");
26121 const nativeResponseValue = wasm.TS_NetworkGraph_free(this_obj);
26122 // debug statements here
26124 // uintptr_t NetworkGraph_clone_ptr(LDKNetworkGraph *NONNULL_PTR arg);
26126 export function NetworkGraph_clone_ptr(arg: number): number {
26127 if(!isWasmInitialized) {
26128 throw new Error("initializeWasm() must be awaited first!");
26130 const nativeResponseValue = wasm.TS_NetworkGraph_clone_ptr(arg);
26131 return nativeResponseValue;
26133 // struct LDKNetworkGraph NetworkGraph_clone(const struct LDKNetworkGraph *NONNULL_PTR orig);
26135 export function NetworkGraph_clone(orig: number): number {
26136 if(!isWasmInitialized) {
26137 throw new Error("initializeWasm() must be awaited first!");
26139 const nativeResponseValue = wasm.TS_NetworkGraph_clone(orig);
26140 return nativeResponseValue;
26142 // void ReadOnlyNetworkGraph_free(struct LDKReadOnlyNetworkGraph this_obj);
26144 export function ReadOnlyNetworkGraph_free(this_obj: number): void {
26145 if(!isWasmInitialized) {
26146 throw new Error("initializeWasm() must be awaited first!");
26148 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_free(this_obj);
26149 // debug statements here
26151 // void NetworkUpdate_free(struct LDKNetworkUpdate this_ptr);
26153 export function NetworkUpdate_free(this_ptr: number): void {
26154 if(!isWasmInitialized) {
26155 throw new Error("initializeWasm() must be awaited first!");
26157 const nativeResponseValue = wasm.TS_NetworkUpdate_free(this_ptr);
26158 // debug statements here
26160 // uintptr_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg);
26162 export function NetworkUpdate_clone_ptr(arg: number): number {
26163 if(!isWasmInitialized) {
26164 throw new Error("initializeWasm() must be awaited first!");
26166 const nativeResponseValue = wasm.TS_NetworkUpdate_clone_ptr(arg);
26167 return nativeResponseValue;
26169 // struct LDKNetworkUpdate NetworkUpdate_clone(const struct LDKNetworkUpdate *NONNULL_PTR orig);
26171 export function NetworkUpdate_clone(orig: number): number {
26172 if(!isWasmInitialized) {
26173 throw new Error("initializeWasm() must be awaited first!");
26175 const nativeResponseValue = wasm.TS_NetworkUpdate_clone(orig);
26176 return nativeResponseValue;
26178 // struct LDKNetworkUpdate NetworkUpdate_channel_update_message(struct LDKChannelUpdate msg);
26180 export function NetworkUpdate_channel_update_message(msg: number): number {
26181 if(!isWasmInitialized) {
26182 throw new Error("initializeWasm() must be awaited first!");
26184 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_update_message(msg);
26185 return nativeResponseValue;
26187 // struct LDKNetworkUpdate NetworkUpdate_channel_closed(uint64_t short_channel_id, bool is_permanent);
26189 export function NetworkUpdate_channel_closed(short_channel_id: bigint, is_permanent: boolean): number {
26190 if(!isWasmInitialized) {
26191 throw new Error("initializeWasm() must be awaited first!");
26193 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_closed(short_channel_id, is_permanent);
26194 return nativeResponseValue;
26196 // struct LDKNetworkUpdate NetworkUpdate_node_failure(struct LDKPublicKey node_id, bool is_permanent);
26198 export function NetworkUpdate_node_failure(node_id: number, is_permanent: boolean): number {
26199 if(!isWasmInitialized) {
26200 throw new Error("initializeWasm() must be awaited first!");
26202 const nativeResponseValue = wasm.TS_NetworkUpdate_node_failure(node_id, is_permanent);
26203 return nativeResponseValue;
26205 // struct LDKCVec_u8Z NetworkUpdate_write(const struct LDKNetworkUpdate *NONNULL_PTR obj);
26207 export function NetworkUpdate_write(obj: number): number {
26208 if(!isWasmInitialized) {
26209 throw new Error("initializeWasm() must be awaited first!");
26211 const nativeResponseValue = wasm.TS_NetworkUpdate_write(obj);
26212 return nativeResponseValue;
26214 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ NetworkUpdate_read(struct LDKu8slice ser);
26216 export function NetworkUpdate_read(ser: number): number {
26217 if(!isWasmInitialized) {
26218 throw new Error("initializeWasm() must be awaited first!");
26220 const nativeResponseValue = wasm.TS_NetworkUpdate_read(ser);
26221 return nativeResponseValue;
26223 // struct LDKEventHandler NetGraphMsgHandler_as_EventHandler(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
26225 export function NetGraphMsgHandler_as_EventHandler(this_arg: number): number {
26226 if(!isWasmInitialized) {
26227 throw new Error("initializeWasm() must be awaited first!");
26229 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_as_EventHandler(this_arg);
26230 return nativeResponseValue;
26232 // void NetGraphMsgHandler_free(struct LDKNetGraphMsgHandler this_obj);
26234 export function NetGraphMsgHandler_free(this_obj: number): void {
26235 if(!isWasmInitialized) {
26236 throw new Error("initializeWasm() must be awaited first!");
26238 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_free(this_obj);
26239 // debug statements here
26241 // MUST_USE_RES struct LDKNetGraphMsgHandler NetGraphMsgHandler_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCOption_AccessZ chain_access, struct LDKLogger logger);
26243 export function NetGraphMsgHandler_new(network_graph: number, chain_access: number, logger: number): number {
26244 if(!isWasmInitialized) {
26245 throw new Error("initializeWasm() must be awaited first!");
26247 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_new(network_graph, chain_access, logger);
26248 return nativeResponseValue;
26250 // void NetGraphMsgHandler_add_chain_access(struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg, struct LDKCOption_AccessZ chain_access);
26252 export function NetGraphMsgHandler_add_chain_access(this_arg: number, chain_access: number): void {
26253 if(!isWasmInitialized) {
26254 throw new Error("initializeWasm() must be awaited first!");
26256 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_add_chain_access(this_arg, chain_access);
26257 // debug statements here
26259 // struct LDKRoutingMessageHandler NetGraphMsgHandler_as_RoutingMessageHandler(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
26261 export function NetGraphMsgHandler_as_RoutingMessageHandler(this_arg: number): number {
26262 if(!isWasmInitialized) {
26263 throw new Error("initializeWasm() must be awaited first!");
26265 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_as_RoutingMessageHandler(this_arg);
26266 return nativeResponseValue;
26268 // struct LDKMessageSendEventsProvider NetGraphMsgHandler_as_MessageSendEventsProvider(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
26270 export function NetGraphMsgHandler_as_MessageSendEventsProvider(this_arg: number): number {
26271 if(!isWasmInitialized) {
26272 throw new Error("initializeWasm() must be awaited first!");
26274 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_as_MessageSendEventsProvider(this_arg);
26275 return nativeResponseValue;
26277 // void ChannelUpdateInfo_free(struct LDKChannelUpdateInfo this_obj);
26279 export function ChannelUpdateInfo_free(this_obj: number): void {
26280 if(!isWasmInitialized) {
26281 throw new Error("initializeWasm() must be awaited first!");
26283 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_free(this_obj);
26284 // debug statements here
26286 // uint32_t ChannelUpdateInfo_get_last_update(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
26288 export function ChannelUpdateInfo_get_last_update(this_ptr: number): number {
26289 if(!isWasmInitialized) {
26290 throw new Error("initializeWasm() must be awaited first!");
26292 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update(this_ptr);
26293 return nativeResponseValue;
26295 // void ChannelUpdateInfo_set_last_update(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint32_t val);
26297 export function ChannelUpdateInfo_set_last_update(this_ptr: number, val: number): void {
26298 if(!isWasmInitialized) {
26299 throw new Error("initializeWasm() must be awaited first!");
26301 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update(this_ptr, val);
26302 // debug statements here
26304 // bool ChannelUpdateInfo_get_enabled(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
26306 export function ChannelUpdateInfo_get_enabled(this_ptr: number): boolean {
26307 if(!isWasmInitialized) {
26308 throw new Error("initializeWasm() must be awaited first!");
26310 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_enabled(this_ptr);
26311 return nativeResponseValue;
26313 // void ChannelUpdateInfo_set_enabled(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, bool val);
26315 export function ChannelUpdateInfo_set_enabled(this_ptr: number, val: boolean): void {
26316 if(!isWasmInitialized) {
26317 throw new Error("initializeWasm() must be awaited first!");
26319 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_enabled(this_ptr, val);
26320 // debug statements here
26322 // uint16_t ChannelUpdateInfo_get_cltv_expiry_delta(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
26324 export function ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr: number): number {
26325 if(!isWasmInitialized) {
26326 throw new Error("initializeWasm() must be awaited first!");
26328 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr);
26329 return nativeResponseValue;
26331 // void ChannelUpdateInfo_set_cltv_expiry_delta(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint16_t val);
26333 export function ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr: number, val: number): void {
26334 if(!isWasmInitialized) {
26335 throw new Error("initializeWasm() must be awaited first!");
26337 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr, val);
26338 // debug statements here
26340 // uint64_t ChannelUpdateInfo_get_htlc_minimum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
26342 export function ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr: number): bigint {
26343 if(!isWasmInitialized) {
26344 throw new Error("initializeWasm() must be awaited first!");
26346 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr);
26347 return nativeResponseValue;
26349 // void ChannelUpdateInfo_set_htlc_minimum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
26351 export function ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
26352 if(!isWasmInitialized) {
26353 throw new Error("initializeWasm() must be awaited first!");
26355 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr, val);
26356 // debug statements here
26358 // struct LDKCOption_u64Z ChannelUpdateInfo_get_htlc_maximum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
26360 export function ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr: number): number {
26361 if(!isWasmInitialized) {
26362 throw new Error("initializeWasm() must be awaited first!");
26364 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr);
26365 return nativeResponseValue;
26367 // void ChannelUpdateInfo_set_htlc_maximum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
26369 export function ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr: number, val: number): void {
26370 if(!isWasmInitialized) {
26371 throw new Error("initializeWasm() must be awaited first!");
26373 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr, val);
26374 // debug statements here
26376 // struct LDKRoutingFees ChannelUpdateInfo_get_fees(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
26378 export function ChannelUpdateInfo_get_fees(this_ptr: number): number {
26379 if(!isWasmInitialized) {
26380 throw new Error("initializeWasm() must be awaited first!");
26382 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_fees(this_ptr);
26383 return nativeResponseValue;
26385 // void ChannelUpdateInfo_set_fees(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
26387 export function ChannelUpdateInfo_set_fees(this_ptr: number, val: number): void {
26388 if(!isWasmInitialized) {
26389 throw new Error("initializeWasm() must be awaited first!");
26391 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_fees(this_ptr, val);
26392 // debug statements here
26394 // struct LDKChannelUpdate ChannelUpdateInfo_get_last_update_message(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
26396 export function ChannelUpdateInfo_get_last_update_message(this_ptr: number): number {
26397 if(!isWasmInitialized) {
26398 throw new Error("initializeWasm() must be awaited first!");
26400 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update_message(this_ptr);
26401 return nativeResponseValue;
26403 // void ChannelUpdateInfo_set_last_update_message(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdate val);
26405 export function ChannelUpdateInfo_set_last_update_message(this_ptr: number, val: number): void {
26406 if(!isWasmInitialized) {
26407 throw new Error("initializeWasm() must be awaited first!");
26409 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update_message(this_ptr, val);
26410 // debug statements here
26412 // 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);
26414 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 {
26415 if(!isWasmInitialized) {
26416 throw new Error("initializeWasm() must be awaited first!");
26418 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);
26419 return nativeResponseValue;
26421 // uintptr_t ChannelUpdateInfo_clone_ptr(LDKChannelUpdateInfo *NONNULL_PTR arg);
26423 export function ChannelUpdateInfo_clone_ptr(arg: number): number {
26424 if(!isWasmInitialized) {
26425 throw new Error("initializeWasm() must be awaited first!");
26427 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone_ptr(arg);
26428 return nativeResponseValue;
26430 // struct LDKChannelUpdateInfo ChannelUpdateInfo_clone(const struct LDKChannelUpdateInfo *NONNULL_PTR orig);
26432 export function ChannelUpdateInfo_clone(orig: number): number {
26433 if(!isWasmInitialized) {
26434 throw new Error("initializeWasm() must be awaited first!");
26436 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone(orig);
26437 return nativeResponseValue;
26439 // struct LDKCVec_u8Z ChannelUpdateInfo_write(const struct LDKChannelUpdateInfo *NONNULL_PTR obj);
26441 export function ChannelUpdateInfo_write(obj: number): number {
26442 if(!isWasmInitialized) {
26443 throw new Error("initializeWasm() must be awaited first!");
26445 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_write(obj);
26446 return nativeResponseValue;
26448 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ ChannelUpdateInfo_read(struct LDKu8slice ser);
26450 export function ChannelUpdateInfo_read(ser: number): number {
26451 if(!isWasmInitialized) {
26452 throw new Error("initializeWasm() must be awaited first!");
26454 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_read(ser);
26455 return nativeResponseValue;
26457 // void ChannelInfo_free(struct LDKChannelInfo this_obj);
26459 export function ChannelInfo_free(this_obj: number): void {
26460 if(!isWasmInitialized) {
26461 throw new Error("initializeWasm() must be awaited first!");
26463 const nativeResponseValue = wasm.TS_ChannelInfo_free(this_obj);
26464 // debug statements here
26466 // struct LDKChannelFeatures ChannelInfo_get_features(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
26468 export function ChannelInfo_get_features(this_ptr: number): number {
26469 if(!isWasmInitialized) {
26470 throw new Error("initializeWasm() must be awaited first!");
26472 const nativeResponseValue = wasm.TS_ChannelInfo_get_features(this_ptr);
26473 return nativeResponseValue;
26475 // void ChannelInfo_set_features(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
26477 export function ChannelInfo_set_features(this_ptr: number, val: number): void {
26478 if(!isWasmInitialized) {
26479 throw new Error("initializeWasm() must be awaited first!");
26481 const nativeResponseValue = wasm.TS_ChannelInfo_set_features(this_ptr, val);
26482 // debug statements here
26484 // struct LDKNodeId ChannelInfo_get_node_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
26486 export function ChannelInfo_get_node_one(this_ptr: number): number {
26487 if(!isWasmInitialized) {
26488 throw new Error("initializeWasm() must be awaited first!");
26490 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_one(this_ptr);
26491 return nativeResponseValue;
26493 // void ChannelInfo_set_node_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
26495 export function ChannelInfo_set_node_one(this_ptr: number, val: number): void {
26496 if(!isWasmInitialized) {
26497 throw new Error("initializeWasm() must be awaited first!");
26499 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_one(this_ptr, val);
26500 // debug statements here
26502 // struct LDKChannelUpdateInfo ChannelInfo_get_one_to_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
26504 export function ChannelInfo_get_one_to_two(this_ptr: number): number {
26505 if(!isWasmInitialized) {
26506 throw new Error("initializeWasm() must be awaited first!");
26508 const nativeResponseValue = wasm.TS_ChannelInfo_get_one_to_two(this_ptr);
26509 return nativeResponseValue;
26511 // void ChannelInfo_set_one_to_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
26513 export function ChannelInfo_set_one_to_two(this_ptr: number, val: number): void {
26514 if(!isWasmInitialized) {
26515 throw new Error("initializeWasm() must be awaited first!");
26517 const nativeResponseValue = wasm.TS_ChannelInfo_set_one_to_two(this_ptr, val);
26518 // debug statements here
26520 // struct LDKNodeId ChannelInfo_get_node_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
26522 export function ChannelInfo_get_node_two(this_ptr: number): number {
26523 if(!isWasmInitialized) {
26524 throw new Error("initializeWasm() must be awaited first!");
26526 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_two(this_ptr);
26527 return nativeResponseValue;
26529 // void ChannelInfo_set_node_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
26531 export function ChannelInfo_set_node_two(this_ptr: number, val: number): void {
26532 if(!isWasmInitialized) {
26533 throw new Error("initializeWasm() must be awaited first!");
26535 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_two(this_ptr, val);
26536 // debug statements here
26538 // struct LDKChannelUpdateInfo ChannelInfo_get_two_to_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
26540 export function ChannelInfo_get_two_to_one(this_ptr: number): number {
26541 if(!isWasmInitialized) {
26542 throw new Error("initializeWasm() must be awaited first!");
26544 const nativeResponseValue = wasm.TS_ChannelInfo_get_two_to_one(this_ptr);
26545 return nativeResponseValue;
26547 // void ChannelInfo_set_two_to_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
26549 export function ChannelInfo_set_two_to_one(this_ptr: number, val: number): void {
26550 if(!isWasmInitialized) {
26551 throw new Error("initializeWasm() must be awaited first!");
26553 const nativeResponseValue = wasm.TS_ChannelInfo_set_two_to_one(this_ptr, val);
26554 // debug statements here
26556 // struct LDKCOption_u64Z ChannelInfo_get_capacity_sats(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
26558 export function ChannelInfo_get_capacity_sats(this_ptr: number): number {
26559 if(!isWasmInitialized) {
26560 throw new Error("initializeWasm() must be awaited first!");
26562 const nativeResponseValue = wasm.TS_ChannelInfo_get_capacity_sats(this_ptr);
26563 return nativeResponseValue;
26565 // void ChannelInfo_set_capacity_sats(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
26567 export function ChannelInfo_set_capacity_sats(this_ptr: number, val: number): void {
26568 if(!isWasmInitialized) {
26569 throw new Error("initializeWasm() must be awaited first!");
26571 const nativeResponseValue = wasm.TS_ChannelInfo_set_capacity_sats(this_ptr, val);
26572 // debug statements here
26574 // struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
26576 export function ChannelInfo_get_announcement_message(this_ptr: number): number {
26577 if(!isWasmInitialized) {
26578 throw new Error("initializeWasm() must be awaited first!");
26580 const nativeResponseValue = wasm.TS_ChannelInfo_get_announcement_message(this_ptr);
26581 return nativeResponseValue;
26583 // void ChannelInfo_set_announcement_message(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelAnnouncement val);
26585 export function ChannelInfo_set_announcement_message(this_ptr: number, val: number): void {
26586 if(!isWasmInitialized) {
26587 throw new Error("initializeWasm() must be awaited first!");
26589 const nativeResponseValue = wasm.TS_ChannelInfo_set_announcement_message(this_ptr, val);
26590 // debug statements here
26592 // uintptr_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg);
26594 export function ChannelInfo_clone_ptr(arg: number): number {
26595 if(!isWasmInitialized) {
26596 throw new Error("initializeWasm() must be awaited first!");
26598 const nativeResponseValue = wasm.TS_ChannelInfo_clone_ptr(arg);
26599 return nativeResponseValue;
26601 // struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
26603 export function ChannelInfo_clone(orig: number): number {
26604 if(!isWasmInitialized) {
26605 throw new Error("initializeWasm() must be awaited first!");
26607 const nativeResponseValue = wasm.TS_ChannelInfo_clone(orig);
26608 return nativeResponseValue;
26610 // struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
26612 export function ChannelInfo_write(obj: number): number {
26613 if(!isWasmInitialized) {
26614 throw new Error("initializeWasm() must be awaited first!");
26616 const nativeResponseValue = wasm.TS_ChannelInfo_write(obj);
26617 return nativeResponseValue;
26619 // struct LDKCResult_ChannelInfoDecodeErrorZ ChannelInfo_read(struct LDKu8slice ser);
26621 export function ChannelInfo_read(ser: number): number {
26622 if(!isWasmInitialized) {
26623 throw new Error("initializeWasm() must be awaited first!");
26625 const nativeResponseValue = wasm.TS_ChannelInfo_read(ser);
26626 return nativeResponseValue;
26628 // void DirectedChannelInfo_free(struct LDKDirectedChannelInfo this_obj);
26630 export function DirectedChannelInfo_free(this_obj: number): void {
26631 if(!isWasmInitialized) {
26632 throw new Error("initializeWasm() must be awaited first!");
26634 const nativeResponseValue = wasm.TS_DirectedChannelInfo_free(this_obj);
26635 // debug statements here
26637 // uintptr_t DirectedChannelInfo_clone_ptr(LDKDirectedChannelInfo *NONNULL_PTR arg);
26639 export function DirectedChannelInfo_clone_ptr(arg: number): number {
26640 if(!isWasmInitialized) {
26641 throw new Error("initializeWasm() must be awaited first!");
26643 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone_ptr(arg);
26644 return nativeResponseValue;
26646 // struct LDKDirectedChannelInfo DirectedChannelInfo_clone(const struct LDKDirectedChannelInfo *NONNULL_PTR orig);
26648 export function DirectedChannelInfo_clone(orig: number): number {
26649 if(!isWasmInitialized) {
26650 throw new Error("initializeWasm() must be awaited first!");
26652 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone(orig);
26653 return nativeResponseValue;
26655 // MUST_USE_RES struct LDKChannelInfo DirectedChannelInfo_channel(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
26657 export function DirectedChannelInfo_channel(this_arg: number): number {
26658 if(!isWasmInitialized) {
26659 throw new Error("initializeWasm() must be awaited first!");
26661 const nativeResponseValue = wasm.TS_DirectedChannelInfo_channel(this_arg);
26662 return nativeResponseValue;
26664 // MUST_USE_RES struct LDKChannelUpdateInfo DirectedChannelInfo_direction(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
26666 export function DirectedChannelInfo_direction(this_arg: number): number {
26667 if(!isWasmInitialized) {
26668 throw new Error("initializeWasm() must be awaited first!");
26670 const nativeResponseValue = wasm.TS_DirectedChannelInfo_direction(this_arg);
26671 return nativeResponseValue;
26673 // MUST_USE_RES struct LDKEffectiveCapacity DirectedChannelInfo_effective_capacity(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
26675 export function DirectedChannelInfo_effective_capacity(this_arg: number): number {
26676 if(!isWasmInitialized) {
26677 throw new Error("initializeWasm() must be awaited first!");
26679 const nativeResponseValue = wasm.TS_DirectedChannelInfo_effective_capacity(this_arg);
26680 return nativeResponseValue;
26682 // void EffectiveCapacity_free(struct LDKEffectiveCapacity this_ptr);
26684 export function EffectiveCapacity_free(this_ptr: number): void {
26685 if(!isWasmInitialized) {
26686 throw new Error("initializeWasm() must be awaited first!");
26688 const nativeResponseValue = wasm.TS_EffectiveCapacity_free(this_ptr);
26689 // debug statements here
26691 // uintptr_t EffectiveCapacity_clone_ptr(LDKEffectiveCapacity *NONNULL_PTR arg);
26693 export function EffectiveCapacity_clone_ptr(arg: number): number {
26694 if(!isWasmInitialized) {
26695 throw new Error("initializeWasm() must be awaited first!");
26697 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone_ptr(arg);
26698 return nativeResponseValue;
26700 // struct LDKEffectiveCapacity EffectiveCapacity_clone(const struct LDKEffectiveCapacity *NONNULL_PTR orig);
26702 export function EffectiveCapacity_clone(orig: number): number {
26703 if(!isWasmInitialized) {
26704 throw new Error("initializeWasm() must be awaited first!");
26706 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone(orig);
26707 return nativeResponseValue;
26709 // struct LDKEffectiveCapacity EffectiveCapacity_exact_liquidity(uint64_t liquidity_msat);
26711 export function EffectiveCapacity_exact_liquidity(liquidity_msat: bigint): number {
26712 if(!isWasmInitialized) {
26713 throw new Error("initializeWasm() must be awaited first!");
26715 const nativeResponseValue = wasm.TS_EffectiveCapacity_exact_liquidity(liquidity_msat);
26716 return nativeResponseValue;
26718 // struct LDKEffectiveCapacity EffectiveCapacity_maximum_htlc(uint64_t amount_msat);
26720 export function EffectiveCapacity_maximum_htlc(amount_msat: bigint): number {
26721 if(!isWasmInitialized) {
26722 throw new Error("initializeWasm() must be awaited first!");
26724 const nativeResponseValue = wasm.TS_EffectiveCapacity_maximum_htlc(amount_msat);
26725 return nativeResponseValue;
26727 // struct LDKEffectiveCapacity EffectiveCapacity_total(uint64_t capacity_msat);
26729 export function EffectiveCapacity_total(capacity_msat: bigint): number {
26730 if(!isWasmInitialized) {
26731 throw new Error("initializeWasm() must be awaited first!");
26733 const nativeResponseValue = wasm.TS_EffectiveCapacity_total(capacity_msat);
26734 return nativeResponseValue;
26736 // struct LDKEffectiveCapacity EffectiveCapacity_infinite(void);
26738 export function EffectiveCapacity_infinite(): number {
26739 if(!isWasmInitialized) {
26740 throw new Error("initializeWasm() must be awaited first!");
26742 const nativeResponseValue = wasm.TS_EffectiveCapacity_infinite();
26743 return nativeResponseValue;
26745 // struct LDKEffectiveCapacity EffectiveCapacity_unknown(void);
26747 export function EffectiveCapacity_unknown(): number {
26748 if(!isWasmInitialized) {
26749 throw new Error("initializeWasm() must be awaited first!");
26751 const nativeResponseValue = wasm.TS_EffectiveCapacity_unknown();
26752 return nativeResponseValue;
26754 // MUST_USE_RES uint64_t EffectiveCapacity_as_msat(const struct LDKEffectiveCapacity *NONNULL_PTR this_arg);
26756 export function EffectiveCapacity_as_msat(this_arg: number): bigint {
26757 if(!isWasmInitialized) {
26758 throw new Error("initializeWasm() must be awaited first!");
26760 const nativeResponseValue = wasm.TS_EffectiveCapacity_as_msat(this_arg);
26761 return nativeResponseValue;
26763 // void RoutingFees_free(struct LDKRoutingFees this_obj);
26765 export function RoutingFees_free(this_obj: number): void {
26766 if(!isWasmInitialized) {
26767 throw new Error("initializeWasm() must be awaited first!");
26769 const nativeResponseValue = wasm.TS_RoutingFees_free(this_obj);
26770 // debug statements here
26772 // uint32_t RoutingFees_get_base_msat(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
26774 export function RoutingFees_get_base_msat(this_ptr: number): number {
26775 if(!isWasmInitialized) {
26776 throw new Error("initializeWasm() must be awaited first!");
26778 const nativeResponseValue = wasm.TS_RoutingFees_get_base_msat(this_ptr);
26779 return nativeResponseValue;
26781 // void RoutingFees_set_base_msat(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
26783 export function RoutingFees_set_base_msat(this_ptr: number, val: number): void {
26784 if(!isWasmInitialized) {
26785 throw new Error("initializeWasm() must be awaited first!");
26787 const nativeResponseValue = wasm.TS_RoutingFees_set_base_msat(this_ptr, val);
26788 // debug statements here
26790 // uint32_t RoutingFees_get_proportional_millionths(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
26792 export function RoutingFees_get_proportional_millionths(this_ptr: number): number {
26793 if(!isWasmInitialized) {
26794 throw new Error("initializeWasm() must be awaited first!");
26796 const nativeResponseValue = wasm.TS_RoutingFees_get_proportional_millionths(this_ptr);
26797 return nativeResponseValue;
26799 // void RoutingFees_set_proportional_millionths(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
26801 export function RoutingFees_set_proportional_millionths(this_ptr: number, val: number): void {
26802 if(!isWasmInitialized) {
26803 throw new Error("initializeWasm() must be awaited first!");
26805 const nativeResponseValue = wasm.TS_RoutingFees_set_proportional_millionths(this_ptr, val);
26806 // debug statements here
26808 // MUST_USE_RES struct LDKRoutingFees RoutingFees_new(uint32_t base_msat_arg, uint32_t proportional_millionths_arg);
26810 export function RoutingFees_new(base_msat_arg: number, proportional_millionths_arg: number): number {
26811 if(!isWasmInitialized) {
26812 throw new Error("initializeWasm() must be awaited first!");
26814 const nativeResponseValue = wasm.TS_RoutingFees_new(base_msat_arg, proportional_millionths_arg);
26815 return nativeResponseValue;
26817 // bool RoutingFees_eq(const struct LDKRoutingFees *NONNULL_PTR a, const struct LDKRoutingFees *NONNULL_PTR b);
26819 export function RoutingFees_eq(a: number, b: number): boolean {
26820 if(!isWasmInitialized) {
26821 throw new Error("initializeWasm() must be awaited first!");
26823 const nativeResponseValue = wasm.TS_RoutingFees_eq(a, b);
26824 return nativeResponseValue;
26826 // uintptr_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg);
26828 export function RoutingFees_clone_ptr(arg: number): number {
26829 if(!isWasmInitialized) {
26830 throw new Error("initializeWasm() must be awaited first!");
26832 const nativeResponseValue = wasm.TS_RoutingFees_clone_ptr(arg);
26833 return nativeResponseValue;
26835 // struct LDKRoutingFees RoutingFees_clone(const struct LDKRoutingFees *NONNULL_PTR orig);
26837 export function RoutingFees_clone(orig: number): number {
26838 if(!isWasmInitialized) {
26839 throw new Error("initializeWasm() must be awaited first!");
26841 const nativeResponseValue = wasm.TS_RoutingFees_clone(orig);
26842 return nativeResponseValue;
26844 // uint64_t RoutingFees_hash(const struct LDKRoutingFees *NONNULL_PTR o);
26846 export function RoutingFees_hash(o: number): bigint {
26847 if(!isWasmInitialized) {
26848 throw new Error("initializeWasm() must be awaited first!");
26850 const nativeResponseValue = wasm.TS_RoutingFees_hash(o);
26851 return nativeResponseValue;
26853 // struct LDKCVec_u8Z RoutingFees_write(const struct LDKRoutingFees *NONNULL_PTR obj);
26855 export function RoutingFees_write(obj: number): number {
26856 if(!isWasmInitialized) {
26857 throw new Error("initializeWasm() must be awaited first!");
26859 const nativeResponseValue = wasm.TS_RoutingFees_write(obj);
26860 return nativeResponseValue;
26862 // struct LDKCResult_RoutingFeesDecodeErrorZ RoutingFees_read(struct LDKu8slice ser);
26864 export function RoutingFees_read(ser: number): number {
26865 if(!isWasmInitialized) {
26866 throw new Error("initializeWasm() must be awaited first!");
26868 const nativeResponseValue = wasm.TS_RoutingFees_read(ser);
26869 return nativeResponseValue;
26871 // void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_obj);
26873 export function NodeAnnouncementInfo_free(this_obj: number): void {
26874 if(!isWasmInitialized) {
26875 throw new Error("initializeWasm() must be awaited first!");
26877 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_free(this_obj);
26878 // debug statements here
26880 // struct LDKNodeFeatures NodeAnnouncementInfo_get_features(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
26882 export function NodeAnnouncementInfo_get_features(this_ptr: number): number {
26883 if(!isWasmInitialized) {
26884 throw new Error("initializeWasm() must be awaited first!");
26886 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_features(this_ptr);
26887 return nativeResponseValue;
26889 // void NodeAnnouncementInfo_set_features(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
26891 export function NodeAnnouncementInfo_set_features(this_ptr: number, val: number): void {
26892 if(!isWasmInitialized) {
26893 throw new Error("initializeWasm() must be awaited first!");
26895 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_features(this_ptr, val);
26896 // debug statements here
26898 // uint32_t NodeAnnouncementInfo_get_last_update(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
26900 export function NodeAnnouncementInfo_get_last_update(this_ptr: number): number {
26901 if(!isWasmInitialized) {
26902 throw new Error("initializeWasm() must be awaited first!");
26904 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_last_update(this_ptr);
26905 return nativeResponseValue;
26907 // void NodeAnnouncementInfo_set_last_update(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, uint32_t val);
26909 export function NodeAnnouncementInfo_set_last_update(this_ptr: number, val: number): void {
26910 if(!isWasmInitialized) {
26911 throw new Error("initializeWasm() must be awaited first!");
26913 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_last_update(this_ptr, val);
26914 // debug statements here
26916 // const uint8_t (*NodeAnnouncementInfo_get_rgb(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[3];
26918 export function NodeAnnouncementInfo_get_rgb(this_ptr: number): number {
26919 if(!isWasmInitialized) {
26920 throw new Error("initializeWasm() must be awaited first!");
26922 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_rgb(this_ptr);
26923 return nativeResponseValue;
26925 // void NodeAnnouncementInfo_set_rgb(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
26927 export function NodeAnnouncementInfo_set_rgb(this_ptr: number, val: number): void {
26928 if(!isWasmInitialized) {
26929 throw new Error("initializeWasm() must be awaited first!");
26931 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_rgb(this_ptr, val);
26932 // debug statements here
26934 // const uint8_t (*NodeAnnouncementInfo_get_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[32];
26936 export function NodeAnnouncementInfo_get_alias(this_ptr: number): number {
26937 if(!isWasmInitialized) {
26938 throw new Error("initializeWasm() must be awaited first!");
26940 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_alias(this_ptr);
26941 return nativeResponseValue;
26943 // void NodeAnnouncementInfo_set_alias(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26945 export function NodeAnnouncementInfo_set_alias(this_ptr: number, val: number): void {
26946 if(!isWasmInitialized) {
26947 throw new Error("initializeWasm() must be awaited first!");
26949 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_alias(this_ptr, val);
26950 // debug statements here
26952 // void NodeAnnouncementInfo_set_addresses(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
26954 export function NodeAnnouncementInfo_set_addresses(this_ptr: number, val: number): void {
26955 if(!isWasmInitialized) {
26956 throw new Error("initializeWasm() must be awaited first!");
26958 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_addresses(this_ptr, val);
26959 // debug statements here
26961 // struct LDKNodeAnnouncement NodeAnnouncementInfo_get_announcement_message(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
26963 export function NodeAnnouncementInfo_get_announcement_message(this_ptr: number): number {
26964 if(!isWasmInitialized) {
26965 throw new Error("initializeWasm() must be awaited first!");
26967 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_announcement_message(this_ptr);
26968 return nativeResponseValue;
26970 // void NodeAnnouncementInfo_set_announcement_message(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncement val);
26972 export function NodeAnnouncementInfo_set_announcement_message(this_ptr: number, val: number): void {
26973 if(!isWasmInitialized) {
26974 throw new Error("initializeWasm() must be awaited first!");
26976 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_announcement_message(this_ptr, val);
26977 // debug statements here
26979 // 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);
26981 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 {
26982 if(!isWasmInitialized) {
26983 throw new Error("initializeWasm() must be awaited first!");
26985 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_new(features_arg, last_update_arg, rgb_arg, alias_arg, addresses_arg, announcement_message_arg);
26986 return nativeResponseValue;
26988 // uintptr_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg);
26990 export function NodeAnnouncementInfo_clone_ptr(arg: number): number {
26991 if(!isWasmInitialized) {
26992 throw new Error("initializeWasm() must be awaited first!");
26994 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone_ptr(arg);
26995 return nativeResponseValue;
26997 // struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
26999 export function NodeAnnouncementInfo_clone(orig: number): number {
27000 if(!isWasmInitialized) {
27001 throw new Error("initializeWasm() must be awaited first!");
27003 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone(orig);
27004 return nativeResponseValue;
27006 // struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementInfo *NONNULL_PTR obj);
27008 export function NodeAnnouncementInfo_write(obj: number): number {
27009 if(!isWasmInitialized) {
27010 throw new Error("initializeWasm() must be awaited first!");
27012 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_write(obj);
27013 return nativeResponseValue;
27015 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ NodeAnnouncementInfo_read(struct LDKu8slice ser);
27017 export function NodeAnnouncementInfo_read(ser: number): number {
27018 if(!isWasmInitialized) {
27019 throw new Error("initializeWasm() must be awaited first!");
27021 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_read(ser);
27022 return nativeResponseValue;
27024 // void NodeInfo_free(struct LDKNodeInfo this_obj);
27026 export function NodeInfo_free(this_obj: number): void {
27027 if(!isWasmInitialized) {
27028 throw new Error("initializeWasm() must be awaited first!");
27030 const nativeResponseValue = wasm.TS_NodeInfo_free(this_obj);
27031 // debug statements here
27033 // void NodeInfo_set_channels(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
27035 export function NodeInfo_set_channels(this_ptr: number, val: number): void {
27036 if(!isWasmInitialized) {
27037 throw new Error("initializeWasm() must be awaited first!");
27039 const nativeResponseValue = wasm.TS_NodeInfo_set_channels(this_ptr, val);
27040 // debug statements here
27042 // struct LDKRoutingFees NodeInfo_get_lowest_inbound_channel_fees(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
27044 export function NodeInfo_get_lowest_inbound_channel_fees(this_ptr: number): number {
27045 if(!isWasmInitialized) {
27046 throw new Error("initializeWasm() must be awaited first!");
27048 const nativeResponseValue = wasm.TS_NodeInfo_get_lowest_inbound_channel_fees(this_ptr);
27049 return nativeResponseValue;
27051 // void NodeInfo_set_lowest_inbound_channel_fees(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
27053 export function NodeInfo_set_lowest_inbound_channel_fees(this_ptr: number, val: number): void {
27054 if(!isWasmInitialized) {
27055 throw new Error("initializeWasm() must be awaited first!");
27057 const nativeResponseValue = wasm.TS_NodeInfo_set_lowest_inbound_channel_fees(this_ptr, val);
27058 // debug statements here
27060 // struct LDKNodeAnnouncementInfo NodeInfo_get_announcement_info(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
27062 export function NodeInfo_get_announcement_info(this_ptr: number): number {
27063 if(!isWasmInitialized) {
27064 throw new Error("initializeWasm() must be awaited first!");
27066 const nativeResponseValue = wasm.TS_NodeInfo_get_announcement_info(this_ptr);
27067 return nativeResponseValue;
27069 // void NodeInfo_set_announcement_info(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncementInfo val);
27071 export function NodeInfo_set_announcement_info(this_ptr: number, val: number): void {
27072 if(!isWasmInitialized) {
27073 throw new Error("initializeWasm() must be awaited first!");
27075 const nativeResponseValue = wasm.TS_NodeInfo_set_announcement_info(this_ptr, val);
27076 // debug statements here
27078 // MUST_USE_RES struct LDKNodeInfo NodeInfo_new(struct LDKCVec_u64Z channels_arg, struct LDKRoutingFees lowest_inbound_channel_fees_arg, struct LDKNodeAnnouncementInfo announcement_info_arg);
27080 export function NodeInfo_new(channels_arg: number, lowest_inbound_channel_fees_arg: number, announcement_info_arg: number): number {
27081 if(!isWasmInitialized) {
27082 throw new Error("initializeWasm() must be awaited first!");
27084 const nativeResponseValue = wasm.TS_NodeInfo_new(channels_arg, lowest_inbound_channel_fees_arg, announcement_info_arg);
27085 return nativeResponseValue;
27087 // uintptr_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg);
27089 export function NodeInfo_clone_ptr(arg: number): number {
27090 if(!isWasmInitialized) {
27091 throw new Error("initializeWasm() must be awaited first!");
27093 const nativeResponseValue = wasm.TS_NodeInfo_clone_ptr(arg);
27094 return nativeResponseValue;
27096 // struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
27098 export function NodeInfo_clone(orig: number): number {
27099 if(!isWasmInitialized) {
27100 throw new Error("initializeWasm() must be awaited first!");
27102 const nativeResponseValue = wasm.TS_NodeInfo_clone(orig);
27103 return nativeResponseValue;
27105 // struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
27107 export function NodeInfo_write(obj: number): number {
27108 if(!isWasmInitialized) {
27109 throw new Error("initializeWasm() must be awaited first!");
27111 const nativeResponseValue = wasm.TS_NodeInfo_write(obj);
27112 return nativeResponseValue;
27114 // struct LDKCResult_NodeInfoDecodeErrorZ NodeInfo_read(struct LDKu8slice ser);
27116 export function NodeInfo_read(ser: number): number {
27117 if(!isWasmInitialized) {
27118 throw new Error("initializeWasm() must be awaited first!");
27120 const nativeResponseValue = wasm.TS_NodeInfo_read(ser);
27121 return nativeResponseValue;
27123 // struct LDKCVec_u8Z NetworkGraph_write(const struct LDKNetworkGraph *NONNULL_PTR obj);
27125 export function NetworkGraph_write(obj: number): number {
27126 if(!isWasmInitialized) {
27127 throw new Error("initializeWasm() must be awaited first!");
27129 const nativeResponseValue = wasm.TS_NetworkGraph_write(obj);
27130 return nativeResponseValue;
27132 // struct LDKCResult_NetworkGraphDecodeErrorZ NetworkGraph_read(struct LDKu8slice ser);
27134 export function NetworkGraph_read(ser: number): number {
27135 if(!isWasmInitialized) {
27136 throw new Error("initializeWasm() must be awaited first!");
27138 const nativeResponseValue = wasm.TS_NetworkGraph_read(ser);
27139 return nativeResponseValue;
27141 // MUST_USE_RES struct LDKNetworkGraph NetworkGraph_new(struct LDKThirtyTwoBytes genesis_hash);
27143 export function NetworkGraph_new(genesis_hash: number): number {
27144 if(!isWasmInitialized) {
27145 throw new Error("initializeWasm() must be awaited first!");
27147 const nativeResponseValue = wasm.TS_NetworkGraph_new(genesis_hash);
27148 return nativeResponseValue;
27150 // MUST_USE_RES struct LDKReadOnlyNetworkGraph NetworkGraph_read_only(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
27152 export function NetworkGraph_read_only(this_arg: number): number {
27153 if(!isWasmInitialized) {
27154 throw new Error("initializeWasm() must be awaited first!");
27156 const nativeResponseValue = wasm.TS_NetworkGraph_read_only(this_arg);
27157 return nativeResponseValue;
27159 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
27161 export function NetworkGraph_update_node_from_announcement(this_arg: number, msg: number): number {
27162 if(!isWasmInitialized) {
27163 throw new Error("initializeWasm() must be awaited first!");
27165 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_announcement(this_arg, msg);
27166 return nativeResponseValue;
27168 // 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);
27170 export function NetworkGraph_update_node_from_unsigned_announcement(this_arg: number, msg: number): number {
27171 if(!isWasmInitialized) {
27172 throw new Error("initializeWasm() must be awaited first!");
27174 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_unsigned_announcement(this_arg, msg);
27175 return nativeResponseValue;
27177 // 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);
27179 export function NetworkGraph_update_channel_from_announcement(this_arg: number, msg: number, chain_access: number): number {
27180 if(!isWasmInitialized) {
27181 throw new Error("initializeWasm() must be awaited first!");
27183 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement(this_arg, msg, chain_access);
27184 return nativeResponseValue;
27186 // 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);
27188 export function NetworkGraph_update_channel_from_unsigned_announcement(this_arg: number, msg: number, chain_access: number): number {
27189 if(!isWasmInitialized) {
27190 throw new Error("initializeWasm() must be awaited first!");
27192 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_unsigned_announcement(this_arg, msg, chain_access);
27193 return nativeResponseValue;
27195 // void NetworkGraph_close_channel_from_update(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id, bool is_permanent);
27197 export function NetworkGraph_close_channel_from_update(this_arg: number, short_channel_id: bigint, is_permanent: boolean): void {
27198 if(!isWasmInitialized) {
27199 throw new Error("initializeWasm() must be awaited first!");
27201 const nativeResponseValue = wasm.TS_NetworkGraph_close_channel_from_update(this_arg, short_channel_id, is_permanent);
27202 // debug statements here
27204 // void NetworkGraph_fail_node(const struct LDKNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey _node_id, bool is_permanent);
27206 export function NetworkGraph_fail_node(this_arg: number, _node_id: number, is_permanent: boolean): void {
27207 if(!isWasmInitialized) {
27208 throw new Error("initializeWasm() must be awaited first!");
27210 const nativeResponseValue = wasm.TS_NetworkGraph_fail_node(this_arg, _node_id, is_permanent);
27211 // debug statements here
27213 // void NetworkGraph_remove_stale_channels_with_time(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t current_time_unix);
27215 export function NetworkGraph_remove_stale_channels_with_time(this_arg: number, current_time_unix: bigint): void {
27216 if(!isWasmInitialized) {
27217 throw new Error("initializeWasm() must be awaited first!");
27219 const nativeResponseValue = wasm.TS_NetworkGraph_remove_stale_channels_with_time(this_arg, current_time_unix);
27220 // debug statements here
27222 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
27224 export function NetworkGraph_update_channel(this_arg: number, msg: number): number {
27225 if(!isWasmInitialized) {
27226 throw new Error("initializeWasm() must be awaited first!");
27228 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel(this_arg, msg);
27229 return nativeResponseValue;
27231 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_unsigned(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelUpdate *NONNULL_PTR msg);
27233 export function NetworkGraph_update_channel_unsigned(this_arg: number, msg: number): number {
27234 if(!isWasmInitialized) {
27235 throw new Error("initializeWasm() must be awaited first!");
27237 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_unsigned(this_arg, msg);
27238 return nativeResponseValue;
27240 // MUST_USE_RES struct LDKCOption_CVec_NetAddressZZ ReadOnlyNetworkGraph_get_addresses(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey pubkey);
27242 export function ReadOnlyNetworkGraph_get_addresses(this_arg: number, pubkey: number): number {
27243 if(!isWasmInitialized) {
27244 throw new Error("initializeWasm() must be awaited first!");
27246 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_get_addresses(this_arg, pubkey);
27247 return nativeResponseValue;
27249 // void RouteHop_free(struct LDKRouteHop this_obj);
27251 export function RouteHop_free(this_obj: number): void {
27252 if(!isWasmInitialized) {
27253 throw new Error("initializeWasm() must be awaited first!");
27255 const nativeResponseValue = wasm.TS_RouteHop_free(this_obj);
27256 // debug statements here
27258 // struct LDKPublicKey RouteHop_get_pubkey(const struct LDKRouteHop *NONNULL_PTR this_ptr);
27260 export function RouteHop_get_pubkey(this_ptr: number): number {
27261 if(!isWasmInitialized) {
27262 throw new Error("initializeWasm() must be awaited first!");
27264 const nativeResponseValue = wasm.TS_RouteHop_get_pubkey(this_ptr);
27265 return nativeResponseValue;
27267 // void RouteHop_set_pubkey(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
27269 export function RouteHop_set_pubkey(this_ptr: number, val: number): void {
27270 if(!isWasmInitialized) {
27271 throw new Error("initializeWasm() must be awaited first!");
27273 const nativeResponseValue = wasm.TS_RouteHop_set_pubkey(this_ptr, val);
27274 // debug statements here
27276 // struct LDKNodeFeatures RouteHop_get_node_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
27278 export function RouteHop_get_node_features(this_ptr: number): number {
27279 if(!isWasmInitialized) {
27280 throw new Error("initializeWasm() must be awaited first!");
27282 const nativeResponseValue = wasm.TS_RouteHop_get_node_features(this_ptr);
27283 return nativeResponseValue;
27285 // void RouteHop_set_node_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
27287 export function RouteHop_set_node_features(this_ptr: number, val: number): void {
27288 if(!isWasmInitialized) {
27289 throw new Error("initializeWasm() must be awaited first!");
27291 const nativeResponseValue = wasm.TS_RouteHop_set_node_features(this_ptr, val);
27292 // debug statements here
27294 // uint64_t RouteHop_get_short_channel_id(const struct LDKRouteHop *NONNULL_PTR this_ptr);
27296 export function RouteHop_get_short_channel_id(this_ptr: number): bigint {
27297 if(!isWasmInitialized) {
27298 throw new Error("initializeWasm() must be awaited first!");
27300 const nativeResponseValue = wasm.TS_RouteHop_get_short_channel_id(this_ptr);
27301 return nativeResponseValue;
27303 // void RouteHop_set_short_channel_id(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
27305 export function RouteHop_set_short_channel_id(this_ptr: number, val: bigint): void {
27306 if(!isWasmInitialized) {
27307 throw new Error("initializeWasm() must be awaited first!");
27309 const nativeResponseValue = wasm.TS_RouteHop_set_short_channel_id(this_ptr, val);
27310 // debug statements here
27312 // struct LDKChannelFeatures RouteHop_get_channel_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
27314 export function RouteHop_get_channel_features(this_ptr: number): number {
27315 if(!isWasmInitialized) {
27316 throw new Error("initializeWasm() must be awaited first!");
27318 const nativeResponseValue = wasm.TS_RouteHop_get_channel_features(this_ptr);
27319 return nativeResponseValue;
27321 // void RouteHop_set_channel_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
27323 export function RouteHop_set_channel_features(this_ptr: number, val: number): void {
27324 if(!isWasmInitialized) {
27325 throw new Error("initializeWasm() must be awaited first!");
27327 const nativeResponseValue = wasm.TS_RouteHop_set_channel_features(this_ptr, val);
27328 // debug statements here
27330 // uint64_t RouteHop_get_fee_msat(const struct LDKRouteHop *NONNULL_PTR this_ptr);
27332 export function RouteHop_get_fee_msat(this_ptr: number): bigint {
27333 if(!isWasmInitialized) {
27334 throw new Error("initializeWasm() must be awaited first!");
27336 const nativeResponseValue = wasm.TS_RouteHop_get_fee_msat(this_ptr);
27337 return nativeResponseValue;
27339 // void RouteHop_set_fee_msat(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
27341 export function RouteHop_set_fee_msat(this_ptr: number, val: bigint): void {
27342 if(!isWasmInitialized) {
27343 throw new Error("initializeWasm() must be awaited first!");
27345 const nativeResponseValue = wasm.TS_RouteHop_set_fee_msat(this_ptr, val);
27346 // debug statements here
27348 // uint32_t RouteHop_get_cltv_expiry_delta(const struct LDKRouteHop *NONNULL_PTR this_ptr);
27350 export function RouteHop_get_cltv_expiry_delta(this_ptr: number): number {
27351 if(!isWasmInitialized) {
27352 throw new Error("initializeWasm() must be awaited first!");
27354 const nativeResponseValue = wasm.TS_RouteHop_get_cltv_expiry_delta(this_ptr);
27355 return nativeResponseValue;
27357 // void RouteHop_set_cltv_expiry_delta(struct LDKRouteHop *NONNULL_PTR this_ptr, uint32_t val);
27359 export function RouteHop_set_cltv_expiry_delta(this_ptr: number, val: number): void {
27360 if(!isWasmInitialized) {
27361 throw new Error("initializeWasm() must be awaited first!");
27363 const nativeResponseValue = wasm.TS_RouteHop_set_cltv_expiry_delta(this_ptr, val);
27364 // debug statements here
27366 // 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);
27368 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 {
27369 if(!isWasmInitialized) {
27370 throw new Error("initializeWasm() must be awaited first!");
27372 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);
27373 return nativeResponseValue;
27375 // uintptr_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg);
27377 export function RouteHop_clone_ptr(arg: number): number {
27378 if(!isWasmInitialized) {
27379 throw new Error("initializeWasm() must be awaited first!");
27381 const nativeResponseValue = wasm.TS_RouteHop_clone_ptr(arg);
27382 return nativeResponseValue;
27384 // struct LDKRouteHop RouteHop_clone(const struct LDKRouteHop *NONNULL_PTR orig);
27386 export function RouteHop_clone(orig: number): number {
27387 if(!isWasmInitialized) {
27388 throw new Error("initializeWasm() must be awaited first!");
27390 const nativeResponseValue = wasm.TS_RouteHop_clone(orig);
27391 return nativeResponseValue;
27393 // uint64_t RouteHop_hash(const struct LDKRouteHop *NONNULL_PTR o);
27395 export function RouteHop_hash(o: number): bigint {
27396 if(!isWasmInitialized) {
27397 throw new Error("initializeWasm() must be awaited first!");
27399 const nativeResponseValue = wasm.TS_RouteHop_hash(o);
27400 return nativeResponseValue;
27402 // bool RouteHop_eq(const struct LDKRouteHop *NONNULL_PTR a, const struct LDKRouteHop *NONNULL_PTR b);
27404 export function RouteHop_eq(a: number, b: number): boolean {
27405 if(!isWasmInitialized) {
27406 throw new Error("initializeWasm() must be awaited first!");
27408 const nativeResponseValue = wasm.TS_RouteHop_eq(a, b);
27409 return nativeResponseValue;
27411 // struct LDKCVec_u8Z RouteHop_write(const struct LDKRouteHop *NONNULL_PTR obj);
27413 export function RouteHop_write(obj: number): number {
27414 if(!isWasmInitialized) {
27415 throw new Error("initializeWasm() must be awaited first!");
27417 const nativeResponseValue = wasm.TS_RouteHop_write(obj);
27418 return nativeResponseValue;
27420 // struct LDKCResult_RouteHopDecodeErrorZ RouteHop_read(struct LDKu8slice ser);
27422 export function RouteHop_read(ser: number): number {
27423 if(!isWasmInitialized) {
27424 throw new Error("initializeWasm() must be awaited first!");
27426 const nativeResponseValue = wasm.TS_RouteHop_read(ser);
27427 return nativeResponseValue;
27429 // void Route_free(struct LDKRoute this_obj);
27431 export function Route_free(this_obj: number): void {
27432 if(!isWasmInitialized) {
27433 throw new Error("initializeWasm() must be awaited first!");
27435 const nativeResponseValue = wasm.TS_Route_free(this_obj);
27436 // debug statements here
27438 // struct LDKCVec_CVec_RouteHopZZ Route_get_paths(const struct LDKRoute *NONNULL_PTR this_ptr);
27440 export function Route_get_paths(this_ptr: number): number {
27441 if(!isWasmInitialized) {
27442 throw new Error("initializeWasm() must be awaited first!");
27444 const nativeResponseValue = wasm.TS_Route_get_paths(this_ptr);
27445 return nativeResponseValue;
27447 // void Route_set_paths(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKCVec_CVec_RouteHopZZ val);
27449 export function Route_set_paths(this_ptr: number, val: number): void {
27450 if(!isWasmInitialized) {
27451 throw new Error("initializeWasm() must be awaited first!");
27453 const nativeResponseValue = wasm.TS_Route_set_paths(this_ptr, val);
27454 // debug statements here
27456 // struct LDKPaymentParameters Route_get_payment_params(const struct LDKRoute *NONNULL_PTR this_ptr);
27458 export function Route_get_payment_params(this_ptr: number): number {
27459 if(!isWasmInitialized) {
27460 throw new Error("initializeWasm() must be awaited first!");
27462 const nativeResponseValue = wasm.TS_Route_get_payment_params(this_ptr);
27463 return nativeResponseValue;
27465 // void Route_set_payment_params(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
27467 export function Route_set_payment_params(this_ptr: number, val: number): void {
27468 if(!isWasmInitialized) {
27469 throw new Error("initializeWasm() must be awaited first!");
27471 const nativeResponseValue = wasm.TS_Route_set_payment_params(this_ptr, val);
27472 // debug statements here
27474 // MUST_USE_RES struct LDKRoute Route_new(struct LDKCVec_CVec_RouteHopZZ paths_arg, struct LDKPaymentParameters payment_params_arg);
27476 export function Route_new(paths_arg: number, payment_params_arg: number): number {
27477 if(!isWasmInitialized) {
27478 throw new Error("initializeWasm() must be awaited first!");
27480 const nativeResponseValue = wasm.TS_Route_new(paths_arg, payment_params_arg);
27481 return nativeResponseValue;
27483 // uintptr_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg);
27485 export function Route_clone_ptr(arg: number): number {
27486 if(!isWasmInitialized) {
27487 throw new Error("initializeWasm() must be awaited first!");
27489 const nativeResponseValue = wasm.TS_Route_clone_ptr(arg);
27490 return nativeResponseValue;
27492 // struct LDKRoute Route_clone(const struct LDKRoute *NONNULL_PTR orig);
27494 export function Route_clone(orig: number): number {
27495 if(!isWasmInitialized) {
27496 throw new Error("initializeWasm() must be awaited first!");
27498 const nativeResponseValue = wasm.TS_Route_clone(orig);
27499 return nativeResponseValue;
27501 // uint64_t Route_hash(const struct LDKRoute *NONNULL_PTR o);
27503 export function Route_hash(o: number): bigint {
27504 if(!isWasmInitialized) {
27505 throw new Error("initializeWasm() must be awaited first!");
27507 const nativeResponseValue = wasm.TS_Route_hash(o);
27508 return nativeResponseValue;
27510 // bool Route_eq(const struct LDKRoute *NONNULL_PTR a, const struct LDKRoute *NONNULL_PTR b);
27512 export function Route_eq(a: number, b: number): boolean {
27513 if(!isWasmInitialized) {
27514 throw new Error("initializeWasm() must be awaited first!");
27516 const nativeResponseValue = wasm.TS_Route_eq(a, b);
27517 return nativeResponseValue;
27519 // MUST_USE_RES uint64_t Route_get_total_fees(const struct LDKRoute *NONNULL_PTR this_arg);
27521 export function Route_get_total_fees(this_arg: number): bigint {
27522 if(!isWasmInitialized) {
27523 throw new Error("initializeWasm() must be awaited first!");
27525 const nativeResponseValue = wasm.TS_Route_get_total_fees(this_arg);
27526 return nativeResponseValue;
27528 // MUST_USE_RES uint64_t Route_get_total_amount(const struct LDKRoute *NONNULL_PTR this_arg);
27530 export function Route_get_total_amount(this_arg: number): bigint {
27531 if(!isWasmInitialized) {
27532 throw new Error("initializeWasm() must be awaited first!");
27534 const nativeResponseValue = wasm.TS_Route_get_total_amount(this_arg);
27535 return nativeResponseValue;
27537 // struct LDKCVec_u8Z Route_write(const struct LDKRoute *NONNULL_PTR obj);
27539 export function Route_write(obj: number): number {
27540 if(!isWasmInitialized) {
27541 throw new Error("initializeWasm() must be awaited first!");
27543 const nativeResponseValue = wasm.TS_Route_write(obj);
27544 return nativeResponseValue;
27546 // struct LDKCResult_RouteDecodeErrorZ Route_read(struct LDKu8slice ser);
27548 export function Route_read(ser: number): number {
27549 if(!isWasmInitialized) {
27550 throw new Error("initializeWasm() must be awaited first!");
27552 const nativeResponseValue = wasm.TS_Route_read(ser);
27553 return nativeResponseValue;
27555 // void RouteParameters_free(struct LDKRouteParameters this_obj);
27557 export function RouteParameters_free(this_obj: number): void {
27558 if(!isWasmInitialized) {
27559 throw new Error("initializeWasm() must be awaited first!");
27561 const nativeResponseValue = wasm.TS_RouteParameters_free(this_obj);
27562 // debug statements here
27564 // struct LDKPaymentParameters RouteParameters_get_payment_params(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
27566 export function RouteParameters_get_payment_params(this_ptr: number): number {
27567 if(!isWasmInitialized) {
27568 throw new Error("initializeWasm() must be awaited first!");
27570 const nativeResponseValue = wasm.TS_RouteParameters_get_payment_params(this_ptr);
27571 return nativeResponseValue;
27573 // void RouteParameters_set_payment_params(struct LDKRouteParameters *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
27575 export function RouteParameters_set_payment_params(this_ptr: number, val: number): void {
27576 if(!isWasmInitialized) {
27577 throw new Error("initializeWasm() must be awaited first!");
27579 const nativeResponseValue = wasm.TS_RouteParameters_set_payment_params(this_ptr, val);
27580 // debug statements here
27582 // uint64_t RouteParameters_get_final_value_msat(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
27584 export function RouteParameters_get_final_value_msat(this_ptr: number): bigint {
27585 if(!isWasmInitialized) {
27586 throw new Error("initializeWasm() must be awaited first!");
27588 const nativeResponseValue = wasm.TS_RouteParameters_get_final_value_msat(this_ptr);
27589 return nativeResponseValue;
27591 // void RouteParameters_set_final_value_msat(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint64_t val);
27593 export function RouteParameters_set_final_value_msat(this_ptr: number, val: bigint): void {
27594 if(!isWasmInitialized) {
27595 throw new Error("initializeWasm() must be awaited first!");
27597 const nativeResponseValue = wasm.TS_RouteParameters_set_final_value_msat(this_ptr, val);
27598 // debug statements here
27600 // uint32_t RouteParameters_get_final_cltv_expiry_delta(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
27602 export function RouteParameters_get_final_cltv_expiry_delta(this_ptr: number): number {
27603 if(!isWasmInitialized) {
27604 throw new Error("initializeWasm() must be awaited first!");
27606 const nativeResponseValue = wasm.TS_RouteParameters_get_final_cltv_expiry_delta(this_ptr);
27607 return nativeResponseValue;
27609 // void RouteParameters_set_final_cltv_expiry_delta(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint32_t val);
27611 export function RouteParameters_set_final_cltv_expiry_delta(this_ptr: number, val: number): void {
27612 if(!isWasmInitialized) {
27613 throw new Error("initializeWasm() must be awaited first!");
27615 const nativeResponseValue = wasm.TS_RouteParameters_set_final_cltv_expiry_delta(this_ptr, val);
27616 // debug statements here
27618 // 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);
27620 export function RouteParameters_new(payment_params_arg: number, final_value_msat_arg: bigint, final_cltv_expiry_delta_arg: number): number {
27621 if(!isWasmInitialized) {
27622 throw new Error("initializeWasm() must be awaited first!");
27624 const nativeResponseValue = wasm.TS_RouteParameters_new(payment_params_arg, final_value_msat_arg, final_cltv_expiry_delta_arg);
27625 return nativeResponseValue;
27627 // uintptr_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg);
27629 export function RouteParameters_clone_ptr(arg: number): number {
27630 if(!isWasmInitialized) {
27631 throw new Error("initializeWasm() must be awaited first!");
27633 const nativeResponseValue = wasm.TS_RouteParameters_clone_ptr(arg);
27634 return nativeResponseValue;
27636 // struct LDKRouteParameters RouteParameters_clone(const struct LDKRouteParameters *NONNULL_PTR orig);
27638 export function RouteParameters_clone(orig: number): number {
27639 if(!isWasmInitialized) {
27640 throw new Error("initializeWasm() must be awaited first!");
27642 const nativeResponseValue = wasm.TS_RouteParameters_clone(orig);
27643 return nativeResponseValue;
27645 // struct LDKCVec_u8Z RouteParameters_write(const struct LDKRouteParameters *NONNULL_PTR obj);
27647 export function RouteParameters_write(obj: number): number {
27648 if(!isWasmInitialized) {
27649 throw new Error("initializeWasm() must be awaited first!");
27651 const nativeResponseValue = wasm.TS_RouteParameters_write(obj);
27652 return nativeResponseValue;
27654 // struct LDKCResult_RouteParametersDecodeErrorZ RouteParameters_read(struct LDKu8slice ser);
27656 export function RouteParameters_read(ser: number): number {
27657 if(!isWasmInitialized) {
27658 throw new Error("initializeWasm() must be awaited first!");
27660 const nativeResponseValue = wasm.TS_RouteParameters_read(ser);
27661 return nativeResponseValue;
27663 // void PaymentParameters_free(struct LDKPaymentParameters this_obj);
27665 export function PaymentParameters_free(this_obj: number): void {
27666 if(!isWasmInitialized) {
27667 throw new Error("initializeWasm() must be awaited first!");
27669 const nativeResponseValue = wasm.TS_PaymentParameters_free(this_obj);
27670 // debug statements here
27672 // struct LDKPublicKey PaymentParameters_get_payee_pubkey(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
27674 export function PaymentParameters_get_payee_pubkey(this_ptr: number): number {
27675 if(!isWasmInitialized) {
27676 throw new Error("initializeWasm() must be awaited first!");
27678 const nativeResponseValue = wasm.TS_PaymentParameters_get_payee_pubkey(this_ptr);
27679 return nativeResponseValue;
27681 // void PaymentParameters_set_payee_pubkey(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKPublicKey val);
27683 export function PaymentParameters_set_payee_pubkey(this_ptr: number, val: number): void {
27684 if(!isWasmInitialized) {
27685 throw new Error("initializeWasm() must be awaited first!");
27687 const nativeResponseValue = wasm.TS_PaymentParameters_set_payee_pubkey(this_ptr, val);
27688 // debug statements here
27690 // struct LDKInvoiceFeatures PaymentParameters_get_features(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
27692 export function PaymentParameters_get_features(this_ptr: number): number {
27693 if(!isWasmInitialized) {
27694 throw new Error("initializeWasm() must be awaited first!");
27696 const nativeResponseValue = wasm.TS_PaymentParameters_get_features(this_ptr);
27697 return nativeResponseValue;
27699 // void PaymentParameters_set_features(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKInvoiceFeatures val);
27701 export function PaymentParameters_set_features(this_ptr: number, val: number): void {
27702 if(!isWasmInitialized) {
27703 throw new Error("initializeWasm() must be awaited first!");
27705 const nativeResponseValue = wasm.TS_PaymentParameters_set_features(this_ptr, val);
27706 // debug statements here
27708 // struct LDKCVec_RouteHintZ PaymentParameters_get_route_hints(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
27710 export function PaymentParameters_get_route_hints(this_ptr: number): number {
27711 if(!isWasmInitialized) {
27712 throw new Error("initializeWasm() must be awaited first!");
27714 const nativeResponseValue = wasm.TS_PaymentParameters_get_route_hints(this_ptr);
27715 return nativeResponseValue;
27717 // void PaymentParameters_set_route_hints(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintZ val);
27719 export function PaymentParameters_set_route_hints(this_ptr: number, val: number): void {
27720 if(!isWasmInitialized) {
27721 throw new Error("initializeWasm() must be awaited first!");
27723 const nativeResponseValue = wasm.TS_PaymentParameters_set_route_hints(this_ptr, val);
27724 // debug statements here
27726 // struct LDKCOption_u64Z PaymentParameters_get_expiry_time(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
27728 export function PaymentParameters_get_expiry_time(this_ptr: number): number {
27729 if(!isWasmInitialized) {
27730 throw new Error("initializeWasm() must be awaited first!");
27732 const nativeResponseValue = wasm.TS_PaymentParameters_get_expiry_time(this_ptr);
27733 return nativeResponseValue;
27735 // void PaymentParameters_set_expiry_time(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
27737 export function PaymentParameters_set_expiry_time(this_ptr: number, val: number): void {
27738 if(!isWasmInitialized) {
27739 throw new Error("initializeWasm() must be awaited first!");
27741 const nativeResponseValue = wasm.TS_PaymentParameters_set_expiry_time(this_ptr, val);
27742 // debug statements here
27744 // uint32_t PaymentParameters_get_max_total_cltv_expiry_delta(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
27746 export function PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr: number): number {
27747 if(!isWasmInitialized) {
27748 throw new Error("initializeWasm() must be awaited first!");
27750 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr);
27751 return nativeResponseValue;
27753 // void PaymentParameters_set_max_total_cltv_expiry_delta(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint32_t val);
27755 export function PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr: number, val: number): void {
27756 if(!isWasmInitialized) {
27757 throw new Error("initializeWasm() must be awaited first!");
27759 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr, val);
27760 // debug statements here
27762 // 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);
27764 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 {
27765 if(!isWasmInitialized) {
27766 throw new Error("initializeWasm() must be awaited first!");
27768 const nativeResponseValue = wasm.TS_PaymentParameters_new(payee_pubkey_arg, features_arg, route_hints_arg, expiry_time_arg, max_total_cltv_expiry_delta_arg);
27769 return nativeResponseValue;
27771 // uintptr_t PaymentParameters_clone_ptr(LDKPaymentParameters *NONNULL_PTR arg);
27773 export function PaymentParameters_clone_ptr(arg: number): number {
27774 if(!isWasmInitialized) {
27775 throw new Error("initializeWasm() must be awaited first!");
27777 const nativeResponseValue = wasm.TS_PaymentParameters_clone_ptr(arg);
27778 return nativeResponseValue;
27780 // struct LDKPaymentParameters PaymentParameters_clone(const struct LDKPaymentParameters *NONNULL_PTR orig);
27782 export function PaymentParameters_clone(orig: number): number {
27783 if(!isWasmInitialized) {
27784 throw new Error("initializeWasm() must be awaited first!");
27786 const nativeResponseValue = wasm.TS_PaymentParameters_clone(orig);
27787 return nativeResponseValue;
27789 // uint64_t PaymentParameters_hash(const struct LDKPaymentParameters *NONNULL_PTR o);
27791 export function PaymentParameters_hash(o: number): bigint {
27792 if(!isWasmInitialized) {
27793 throw new Error("initializeWasm() must be awaited first!");
27795 const nativeResponseValue = wasm.TS_PaymentParameters_hash(o);
27796 return nativeResponseValue;
27798 // bool PaymentParameters_eq(const struct LDKPaymentParameters *NONNULL_PTR a, const struct LDKPaymentParameters *NONNULL_PTR b);
27800 export function PaymentParameters_eq(a: number, b: number): boolean {
27801 if(!isWasmInitialized) {
27802 throw new Error("initializeWasm() must be awaited first!");
27804 const nativeResponseValue = wasm.TS_PaymentParameters_eq(a, b);
27805 return nativeResponseValue;
27807 // struct LDKCVec_u8Z PaymentParameters_write(const struct LDKPaymentParameters *NONNULL_PTR obj);
27809 export function PaymentParameters_write(obj: number): number {
27810 if(!isWasmInitialized) {
27811 throw new Error("initializeWasm() must be awaited first!");
27813 const nativeResponseValue = wasm.TS_PaymentParameters_write(obj);
27814 return nativeResponseValue;
27816 // struct LDKCResult_PaymentParametersDecodeErrorZ PaymentParameters_read(struct LDKu8slice ser);
27818 export function PaymentParameters_read(ser: number): number {
27819 if(!isWasmInitialized) {
27820 throw new Error("initializeWasm() must be awaited first!");
27822 const nativeResponseValue = wasm.TS_PaymentParameters_read(ser);
27823 return nativeResponseValue;
27825 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_from_node_id(struct LDKPublicKey payee_pubkey);
27827 export function PaymentParameters_from_node_id(payee_pubkey: number): number {
27828 if(!isWasmInitialized) {
27829 throw new Error("initializeWasm() must be awaited first!");
27831 const nativeResponseValue = wasm.TS_PaymentParameters_from_node_id(payee_pubkey);
27832 return nativeResponseValue;
27834 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_for_keysend(struct LDKPublicKey payee_pubkey);
27836 export function PaymentParameters_for_keysend(payee_pubkey: number): number {
27837 if(!isWasmInitialized) {
27838 throw new Error("initializeWasm() must be awaited first!");
27840 const nativeResponseValue = wasm.TS_PaymentParameters_for_keysend(payee_pubkey);
27841 return nativeResponseValue;
27843 // void RouteHint_free(struct LDKRouteHint this_obj);
27845 export function RouteHint_free(this_obj: number): void {
27846 if(!isWasmInitialized) {
27847 throw new Error("initializeWasm() must be awaited first!");
27849 const nativeResponseValue = wasm.TS_RouteHint_free(this_obj);
27850 // debug statements here
27852 // struct LDKCVec_RouteHintHopZ RouteHint_get_a(const struct LDKRouteHint *NONNULL_PTR this_ptr);
27854 export function RouteHint_get_a(this_ptr: number): number {
27855 if(!isWasmInitialized) {
27856 throw new Error("initializeWasm() must be awaited first!");
27858 const nativeResponseValue = wasm.TS_RouteHint_get_a(this_ptr);
27859 return nativeResponseValue;
27861 // void RouteHint_set_a(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintHopZ val);
27863 export function RouteHint_set_a(this_ptr: number, val: number): void {
27864 if(!isWasmInitialized) {
27865 throw new Error("initializeWasm() must be awaited first!");
27867 const nativeResponseValue = wasm.TS_RouteHint_set_a(this_ptr, val);
27868 // debug statements here
27870 // MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKCVec_RouteHintHopZ a_arg);
27872 export function RouteHint_new(a_arg: number): number {
27873 if(!isWasmInitialized) {
27874 throw new Error("initializeWasm() must be awaited first!");
27876 const nativeResponseValue = wasm.TS_RouteHint_new(a_arg);
27877 return nativeResponseValue;
27879 // uintptr_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg);
27881 export function RouteHint_clone_ptr(arg: number): number {
27882 if(!isWasmInitialized) {
27883 throw new Error("initializeWasm() must be awaited first!");
27885 const nativeResponseValue = wasm.TS_RouteHint_clone_ptr(arg);
27886 return nativeResponseValue;
27888 // struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
27890 export function RouteHint_clone(orig: number): number {
27891 if(!isWasmInitialized) {
27892 throw new Error("initializeWasm() must be awaited first!");
27894 const nativeResponseValue = wasm.TS_RouteHint_clone(orig);
27895 return nativeResponseValue;
27897 // uint64_t RouteHint_hash(const struct LDKRouteHint *NONNULL_PTR o);
27899 export function RouteHint_hash(o: number): bigint {
27900 if(!isWasmInitialized) {
27901 throw new Error("initializeWasm() must be awaited first!");
27903 const nativeResponseValue = wasm.TS_RouteHint_hash(o);
27904 return nativeResponseValue;
27906 // bool RouteHint_eq(const struct LDKRouteHint *NONNULL_PTR a, const struct LDKRouteHint *NONNULL_PTR b);
27908 export function RouteHint_eq(a: number, b: number): boolean {
27909 if(!isWasmInitialized) {
27910 throw new Error("initializeWasm() must be awaited first!");
27912 const nativeResponseValue = wasm.TS_RouteHint_eq(a, b);
27913 return nativeResponseValue;
27915 // struct LDKCVec_u8Z RouteHint_write(const struct LDKRouteHint *NONNULL_PTR obj);
27917 export function RouteHint_write(obj: number): number {
27918 if(!isWasmInitialized) {
27919 throw new Error("initializeWasm() must be awaited first!");
27921 const nativeResponseValue = wasm.TS_RouteHint_write(obj);
27922 return nativeResponseValue;
27924 // struct LDKCResult_RouteHintDecodeErrorZ RouteHint_read(struct LDKu8slice ser);
27926 export function RouteHint_read(ser: number): number {
27927 if(!isWasmInitialized) {
27928 throw new Error("initializeWasm() must be awaited first!");
27930 const nativeResponseValue = wasm.TS_RouteHint_read(ser);
27931 return nativeResponseValue;
27933 // void RouteHintHop_free(struct LDKRouteHintHop this_obj);
27935 export function RouteHintHop_free(this_obj: number): void {
27936 if(!isWasmInitialized) {
27937 throw new Error("initializeWasm() must be awaited first!");
27939 const nativeResponseValue = wasm.TS_RouteHintHop_free(this_obj);
27940 // debug statements here
27942 // struct LDKPublicKey RouteHintHop_get_src_node_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
27944 export function RouteHintHop_get_src_node_id(this_ptr: number): number {
27945 if(!isWasmInitialized) {
27946 throw new Error("initializeWasm() must be awaited first!");
27948 const nativeResponseValue = wasm.TS_RouteHintHop_get_src_node_id(this_ptr);
27949 return nativeResponseValue;
27951 // void RouteHintHop_set_src_node_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
27953 export function RouteHintHop_set_src_node_id(this_ptr: number, val: number): void {
27954 if(!isWasmInitialized) {
27955 throw new Error("initializeWasm() must be awaited first!");
27957 const nativeResponseValue = wasm.TS_RouteHintHop_set_src_node_id(this_ptr, val);
27958 // debug statements here
27960 // uint64_t RouteHintHop_get_short_channel_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
27962 export function RouteHintHop_get_short_channel_id(this_ptr: number): bigint {
27963 if(!isWasmInitialized) {
27964 throw new Error("initializeWasm() must be awaited first!");
27966 const nativeResponseValue = wasm.TS_RouteHintHop_get_short_channel_id(this_ptr);
27967 return nativeResponseValue;
27969 // void RouteHintHop_set_short_channel_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint64_t val);
27971 export function RouteHintHop_set_short_channel_id(this_ptr: number, val: bigint): void {
27972 if(!isWasmInitialized) {
27973 throw new Error("initializeWasm() must be awaited first!");
27975 const nativeResponseValue = wasm.TS_RouteHintHop_set_short_channel_id(this_ptr, val);
27976 // debug statements here
27978 // struct LDKRoutingFees RouteHintHop_get_fees(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
27980 export function RouteHintHop_get_fees(this_ptr: number): number {
27981 if(!isWasmInitialized) {
27982 throw new Error("initializeWasm() must be awaited first!");
27984 const nativeResponseValue = wasm.TS_RouteHintHop_get_fees(this_ptr);
27985 return nativeResponseValue;
27987 // void RouteHintHop_set_fees(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
27989 export function RouteHintHop_set_fees(this_ptr: number, val: number): void {
27990 if(!isWasmInitialized) {
27991 throw new Error("initializeWasm() must be awaited first!");
27993 const nativeResponseValue = wasm.TS_RouteHintHop_set_fees(this_ptr, val);
27994 // debug statements here
27996 // uint16_t RouteHintHop_get_cltv_expiry_delta(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
27998 export function RouteHintHop_get_cltv_expiry_delta(this_ptr: number): number {
27999 if(!isWasmInitialized) {
28000 throw new Error("initializeWasm() must be awaited first!");
28002 const nativeResponseValue = wasm.TS_RouteHintHop_get_cltv_expiry_delta(this_ptr);
28003 return nativeResponseValue;
28005 // void RouteHintHop_set_cltv_expiry_delta(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint16_t val);
28007 export function RouteHintHop_set_cltv_expiry_delta(this_ptr: number, val: number): void {
28008 if(!isWasmInitialized) {
28009 throw new Error("initializeWasm() must be awaited first!");
28011 const nativeResponseValue = wasm.TS_RouteHintHop_set_cltv_expiry_delta(this_ptr, val);
28012 // debug statements here
28014 // struct LDKCOption_u64Z RouteHintHop_get_htlc_minimum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
28016 export function RouteHintHop_get_htlc_minimum_msat(this_ptr: number): number {
28017 if(!isWasmInitialized) {
28018 throw new Error("initializeWasm() must be awaited first!");
28020 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_minimum_msat(this_ptr);
28021 return nativeResponseValue;
28023 // void RouteHintHop_set_htlc_minimum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
28025 export function RouteHintHop_set_htlc_minimum_msat(this_ptr: number, val: number): void {
28026 if(!isWasmInitialized) {
28027 throw new Error("initializeWasm() must be awaited first!");
28029 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_minimum_msat(this_ptr, val);
28030 // debug statements here
28032 // struct LDKCOption_u64Z RouteHintHop_get_htlc_maximum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
28034 export function RouteHintHop_get_htlc_maximum_msat(this_ptr: number): number {
28035 if(!isWasmInitialized) {
28036 throw new Error("initializeWasm() must be awaited first!");
28038 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_maximum_msat(this_ptr);
28039 return nativeResponseValue;
28041 // void RouteHintHop_set_htlc_maximum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
28043 export function RouteHintHop_set_htlc_maximum_msat(this_ptr: number, val: number): void {
28044 if(!isWasmInitialized) {
28045 throw new Error("initializeWasm() must be awaited first!");
28047 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_maximum_msat(this_ptr, val);
28048 // debug statements here
28050 // 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);
28052 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 {
28053 if(!isWasmInitialized) {
28054 throw new Error("initializeWasm() must be awaited first!");
28056 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);
28057 return nativeResponseValue;
28059 // uintptr_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg);
28061 export function RouteHintHop_clone_ptr(arg: number): number {
28062 if(!isWasmInitialized) {
28063 throw new Error("initializeWasm() must be awaited first!");
28065 const nativeResponseValue = wasm.TS_RouteHintHop_clone_ptr(arg);
28066 return nativeResponseValue;
28068 // struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
28070 export function RouteHintHop_clone(orig: number): number {
28071 if(!isWasmInitialized) {
28072 throw new Error("initializeWasm() must be awaited first!");
28074 const nativeResponseValue = wasm.TS_RouteHintHop_clone(orig);
28075 return nativeResponseValue;
28077 // uint64_t RouteHintHop_hash(const struct LDKRouteHintHop *NONNULL_PTR o);
28079 export function RouteHintHop_hash(o: number): bigint {
28080 if(!isWasmInitialized) {
28081 throw new Error("initializeWasm() must be awaited first!");
28083 const nativeResponseValue = wasm.TS_RouteHintHop_hash(o);
28084 return nativeResponseValue;
28086 // bool RouteHintHop_eq(const struct LDKRouteHintHop *NONNULL_PTR a, const struct LDKRouteHintHop *NONNULL_PTR b);
28088 export function RouteHintHop_eq(a: number, b: number): boolean {
28089 if(!isWasmInitialized) {
28090 throw new Error("initializeWasm() must be awaited first!");
28092 const nativeResponseValue = wasm.TS_RouteHintHop_eq(a, b);
28093 return nativeResponseValue;
28095 // struct LDKCVec_u8Z RouteHintHop_write(const struct LDKRouteHintHop *NONNULL_PTR obj);
28097 export function RouteHintHop_write(obj: number): number {
28098 if(!isWasmInitialized) {
28099 throw new Error("initializeWasm() must be awaited first!");
28101 const nativeResponseValue = wasm.TS_RouteHintHop_write(obj);
28102 return nativeResponseValue;
28104 // struct LDKCResult_RouteHintHopDecodeErrorZ RouteHintHop_read(struct LDKu8slice ser);
28106 export function RouteHintHop_read(ser: number): number {
28107 if(!isWasmInitialized) {
28108 throw new Error("initializeWasm() must be awaited first!");
28110 const nativeResponseValue = wasm.TS_RouteHintHop_read(ser);
28111 return nativeResponseValue;
28113 // 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);
28115 export function find_route(our_node_pubkey: number, route_params: number, network: number, first_hops: number, logger: number, scorer: number): number {
28116 if(!isWasmInitialized) {
28117 throw new Error("initializeWasm() must be awaited first!");
28119 const nativeResponseValue = wasm.TS_find_route(our_node_pubkey, route_params, network, first_hops, logger, scorer);
28120 return nativeResponseValue;
28122 // void Score_free(struct LDKScore this_ptr);
28124 export function Score_free(this_ptr: number): void {
28125 if(!isWasmInitialized) {
28126 throw new Error("initializeWasm() must be awaited first!");
28128 const nativeResponseValue = wasm.TS_Score_free(this_ptr);
28129 // debug statements here
28131 // void LockableScore_free(struct LDKLockableScore this_ptr);
28133 export function LockableScore_free(this_ptr: number): void {
28134 if(!isWasmInitialized) {
28135 throw new Error("initializeWasm() must be awaited first!");
28137 const nativeResponseValue = wasm.TS_LockableScore_free(this_ptr);
28138 // debug statements here
28140 // void MultiThreadedLockableScore_free(struct LDKMultiThreadedLockableScore this_obj);
28142 export function MultiThreadedLockableScore_free(this_obj: number): void {
28143 if(!isWasmInitialized) {
28144 throw new Error("initializeWasm() must be awaited first!");
28146 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_free(this_obj);
28147 // debug statements here
28149 // MUST_USE_RES struct LDKMultiThreadedLockableScore MultiThreadedLockableScore_new(struct LDKScore score);
28151 export function MultiThreadedLockableScore_new(score: number): number {
28152 if(!isWasmInitialized) {
28153 throw new Error("initializeWasm() must be awaited first!");
28155 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_new(score);
28156 return nativeResponseValue;
28158 // void FixedPenaltyScorer_free(struct LDKFixedPenaltyScorer this_obj);
28160 export function FixedPenaltyScorer_free(this_obj: number): void {
28161 if(!isWasmInitialized) {
28162 throw new Error("initializeWasm() must be awaited first!");
28164 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_free(this_obj);
28165 // debug statements here
28167 // uintptr_t FixedPenaltyScorer_clone_ptr(LDKFixedPenaltyScorer *NONNULL_PTR arg);
28169 export function FixedPenaltyScorer_clone_ptr(arg: number): number {
28170 if(!isWasmInitialized) {
28171 throw new Error("initializeWasm() must be awaited first!");
28173 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone_ptr(arg);
28174 return nativeResponseValue;
28176 // struct LDKFixedPenaltyScorer FixedPenaltyScorer_clone(const struct LDKFixedPenaltyScorer *NONNULL_PTR orig);
28178 export function FixedPenaltyScorer_clone(orig: number): number {
28179 if(!isWasmInitialized) {
28180 throw new Error("initializeWasm() must be awaited first!");
28182 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone(orig);
28183 return nativeResponseValue;
28185 // struct LDKCVec_u8Z FixedPenaltyScorer_write(const struct LDKFixedPenaltyScorer *NONNULL_PTR obj);
28187 export function FixedPenaltyScorer_write(obj: number): number {
28188 if(!isWasmInitialized) {
28189 throw new Error("initializeWasm() must be awaited first!");
28191 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_write(obj);
28192 return nativeResponseValue;
28194 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ FixedPenaltyScorer_read(struct LDKu8slice ser);
28196 export function FixedPenaltyScorer_read(ser: number): number {
28197 if(!isWasmInitialized) {
28198 throw new Error("initializeWasm() must be awaited first!");
28200 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_read(ser);
28201 return nativeResponseValue;
28203 // MUST_USE_RES struct LDKFixedPenaltyScorer FixedPenaltyScorer_with_penalty(uint64_t penalty_msat);
28205 export function FixedPenaltyScorer_with_penalty(penalty_msat: bigint): number {
28206 if(!isWasmInitialized) {
28207 throw new Error("initializeWasm() must be awaited first!");
28209 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_with_penalty(penalty_msat);
28210 return nativeResponseValue;
28212 // struct LDKScore FixedPenaltyScorer_as_Score(const struct LDKFixedPenaltyScorer *NONNULL_PTR this_arg);
28214 export function FixedPenaltyScorer_as_Score(this_arg: number): number {
28215 if(!isWasmInitialized) {
28216 throw new Error("initializeWasm() must be awaited first!");
28218 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_as_Score(this_arg);
28219 return nativeResponseValue;
28221 // void Scorer_free(struct LDKScorer this_obj);
28223 export function Scorer_free(this_obj: number): void {
28224 if(!isWasmInitialized) {
28225 throw new Error("initializeWasm() must be awaited first!");
28227 const nativeResponseValue = wasm.TS_Scorer_free(this_obj);
28228 // debug statements here
28230 // void ScoringParameters_free(struct LDKScoringParameters this_obj);
28232 export function ScoringParameters_free(this_obj: number): void {
28233 if(!isWasmInitialized) {
28234 throw new Error("initializeWasm() must be awaited first!");
28236 const nativeResponseValue = wasm.TS_ScoringParameters_free(this_obj);
28237 // debug statements here
28239 // uint64_t ScoringParameters_get_base_penalty_msat(const struct LDKScoringParameters *NONNULL_PTR this_ptr);
28241 export function ScoringParameters_get_base_penalty_msat(this_ptr: number): bigint {
28242 if(!isWasmInitialized) {
28243 throw new Error("initializeWasm() must be awaited first!");
28245 const nativeResponseValue = wasm.TS_ScoringParameters_get_base_penalty_msat(this_ptr);
28246 return nativeResponseValue;
28248 // void ScoringParameters_set_base_penalty_msat(struct LDKScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
28250 export function ScoringParameters_set_base_penalty_msat(this_ptr: number, val: bigint): void {
28251 if(!isWasmInitialized) {
28252 throw new Error("initializeWasm() must be awaited first!");
28254 const nativeResponseValue = wasm.TS_ScoringParameters_set_base_penalty_msat(this_ptr, val);
28255 // debug statements here
28257 // uint64_t ScoringParameters_get_failure_penalty_msat(const struct LDKScoringParameters *NONNULL_PTR this_ptr);
28259 export function ScoringParameters_get_failure_penalty_msat(this_ptr: number): bigint {
28260 if(!isWasmInitialized) {
28261 throw new Error("initializeWasm() must be awaited first!");
28263 const nativeResponseValue = wasm.TS_ScoringParameters_get_failure_penalty_msat(this_ptr);
28264 return nativeResponseValue;
28266 // void ScoringParameters_set_failure_penalty_msat(struct LDKScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
28268 export function ScoringParameters_set_failure_penalty_msat(this_ptr: number, val: bigint): void {
28269 if(!isWasmInitialized) {
28270 throw new Error("initializeWasm() must be awaited first!");
28272 const nativeResponseValue = wasm.TS_ScoringParameters_set_failure_penalty_msat(this_ptr, val);
28273 // debug statements here
28275 // uint16_t ScoringParameters_get_overuse_penalty_start_1024th(const struct LDKScoringParameters *NONNULL_PTR this_ptr);
28277 export function ScoringParameters_get_overuse_penalty_start_1024th(this_ptr: number): number {
28278 if(!isWasmInitialized) {
28279 throw new Error("initializeWasm() must be awaited first!");
28281 const nativeResponseValue = wasm.TS_ScoringParameters_get_overuse_penalty_start_1024th(this_ptr);
28282 return nativeResponseValue;
28284 // void ScoringParameters_set_overuse_penalty_start_1024th(struct LDKScoringParameters *NONNULL_PTR this_ptr, uint16_t val);
28286 export function ScoringParameters_set_overuse_penalty_start_1024th(this_ptr: number, val: number): void {
28287 if(!isWasmInitialized) {
28288 throw new Error("initializeWasm() must be awaited first!");
28290 const nativeResponseValue = wasm.TS_ScoringParameters_set_overuse_penalty_start_1024th(this_ptr, val);
28291 // debug statements here
28293 // uint64_t ScoringParameters_get_overuse_penalty_msat_per_1024th(const struct LDKScoringParameters *NONNULL_PTR this_ptr);
28295 export function ScoringParameters_get_overuse_penalty_msat_per_1024th(this_ptr: number): bigint {
28296 if(!isWasmInitialized) {
28297 throw new Error("initializeWasm() must be awaited first!");
28299 const nativeResponseValue = wasm.TS_ScoringParameters_get_overuse_penalty_msat_per_1024th(this_ptr);
28300 return nativeResponseValue;
28302 // void ScoringParameters_set_overuse_penalty_msat_per_1024th(struct LDKScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
28304 export function ScoringParameters_set_overuse_penalty_msat_per_1024th(this_ptr: number, val: bigint): void {
28305 if(!isWasmInitialized) {
28306 throw new Error("initializeWasm() must be awaited first!");
28308 const nativeResponseValue = wasm.TS_ScoringParameters_set_overuse_penalty_msat_per_1024th(this_ptr, val);
28309 // debug statements here
28311 // uint64_t ScoringParameters_get_failure_penalty_half_life(const struct LDKScoringParameters *NONNULL_PTR this_ptr);
28313 export function ScoringParameters_get_failure_penalty_half_life(this_ptr: number): bigint {
28314 if(!isWasmInitialized) {
28315 throw new Error("initializeWasm() must be awaited first!");
28317 const nativeResponseValue = wasm.TS_ScoringParameters_get_failure_penalty_half_life(this_ptr);
28318 return nativeResponseValue;
28320 // void ScoringParameters_set_failure_penalty_half_life(struct LDKScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
28322 export function ScoringParameters_set_failure_penalty_half_life(this_ptr: number, val: bigint): void {
28323 if(!isWasmInitialized) {
28324 throw new Error("initializeWasm() must be awaited first!");
28326 const nativeResponseValue = wasm.TS_ScoringParameters_set_failure_penalty_half_life(this_ptr, val);
28327 // debug statements here
28329 // 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);
28331 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 {
28332 if(!isWasmInitialized) {
28333 throw new Error("initializeWasm() must be awaited first!");
28335 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);
28336 return nativeResponseValue;
28338 // uintptr_t ScoringParameters_clone_ptr(LDKScoringParameters *NONNULL_PTR arg);
28340 export function ScoringParameters_clone_ptr(arg: number): number {
28341 if(!isWasmInitialized) {
28342 throw new Error("initializeWasm() must be awaited first!");
28344 const nativeResponseValue = wasm.TS_ScoringParameters_clone_ptr(arg);
28345 return nativeResponseValue;
28347 // struct LDKScoringParameters ScoringParameters_clone(const struct LDKScoringParameters *NONNULL_PTR orig);
28349 export function ScoringParameters_clone(orig: number): number {
28350 if(!isWasmInitialized) {
28351 throw new Error("initializeWasm() must be awaited first!");
28353 const nativeResponseValue = wasm.TS_ScoringParameters_clone(orig);
28354 return nativeResponseValue;
28356 // struct LDKCVec_u8Z ScoringParameters_write(const struct LDKScoringParameters *NONNULL_PTR obj);
28358 export function ScoringParameters_write(obj: number): number {
28359 if(!isWasmInitialized) {
28360 throw new Error("initializeWasm() must be awaited first!");
28362 const nativeResponseValue = wasm.TS_ScoringParameters_write(obj);
28363 return nativeResponseValue;
28365 // struct LDKCResult_ScoringParametersDecodeErrorZ ScoringParameters_read(struct LDKu8slice ser);
28367 export function ScoringParameters_read(ser: number): number {
28368 if(!isWasmInitialized) {
28369 throw new Error("initializeWasm() must be awaited first!");
28371 const nativeResponseValue = wasm.TS_ScoringParameters_read(ser);
28372 return nativeResponseValue;
28374 // MUST_USE_RES struct LDKScorer Scorer_new(struct LDKScoringParameters params);
28376 export function Scorer_new(params: number): number {
28377 if(!isWasmInitialized) {
28378 throw new Error("initializeWasm() must be awaited first!");
28380 const nativeResponseValue = wasm.TS_Scorer_new(params);
28381 return nativeResponseValue;
28383 // MUST_USE_RES struct LDKScorer Scorer_default(void);
28385 export function Scorer_default(): number {
28386 if(!isWasmInitialized) {
28387 throw new Error("initializeWasm() must be awaited first!");
28389 const nativeResponseValue = wasm.TS_Scorer_default();
28390 return nativeResponseValue;
28392 // MUST_USE_RES struct LDKScoringParameters ScoringParameters_default(void);
28394 export function ScoringParameters_default(): number {
28395 if(!isWasmInitialized) {
28396 throw new Error("initializeWasm() must be awaited first!");
28398 const nativeResponseValue = wasm.TS_ScoringParameters_default();
28399 return nativeResponseValue;
28401 // struct LDKScore Scorer_as_Score(const struct LDKScorer *NONNULL_PTR this_arg);
28403 export function Scorer_as_Score(this_arg: number): number {
28404 if(!isWasmInitialized) {
28405 throw new Error("initializeWasm() must be awaited first!");
28407 const nativeResponseValue = wasm.TS_Scorer_as_Score(this_arg);
28408 return nativeResponseValue;
28410 // struct LDKCVec_u8Z Scorer_write(const struct LDKScorer *NONNULL_PTR obj);
28412 export function Scorer_write(obj: number): number {
28413 if(!isWasmInitialized) {
28414 throw new Error("initializeWasm() must be awaited first!");
28416 const nativeResponseValue = wasm.TS_Scorer_write(obj);
28417 return nativeResponseValue;
28419 // struct LDKCResult_ScorerDecodeErrorZ Scorer_read(struct LDKu8slice ser);
28421 export function Scorer_read(ser: number): number {
28422 if(!isWasmInitialized) {
28423 throw new Error("initializeWasm() must be awaited first!");
28425 const nativeResponseValue = wasm.TS_Scorer_read(ser);
28426 return nativeResponseValue;
28428 // void ProbabilisticScoringParameters_free(struct LDKProbabilisticScoringParameters this_obj);
28430 export function ProbabilisticScoringParameters_free(this_obj: number): void {
28431 if(!isWasmInitialized) {
28432 throw new Error("initializeWasm() must be awaited first!");
28434 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_free(this_obj);
28435 // debug statements here
28437 // uint64_t ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
28439 export function ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr: number): bigint {
28440 if(!isWasmInitialized) {
28441 throw new Error("initializeWasm() must be awaited first!");
28443 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr);
28444 return nativeResponseValue;
28446 // void ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
28448 export function ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr: number, val: bigint): void {
28449 if(!isWasmInitialized) {
28450 throw new Error("initializeWasm() must be awaited first!");
28452 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr, val);
28453 // debug statements here
28455 // uint64_t ProbabilisticScoringParameters_get_liquidity_offset_half_life(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
28457 export function ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr: number): bigint {
28458 if(!isWasmInitialized) {
28459 throw new Error("initializeWasm() must be awaited first!");
28461 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr);
28462 return nativeResponseValue;
28464 // void ProbabilisticScoringParameters_set_liquidity_offset_half_life(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
28466 export function ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr: number, val: bigint): void {
28467 if(!isWasmInitialized) {
28468 throw new Error("initializeWasm() must be awaited first!");
28470 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr, val);
28471 // debug statements here
28473 // MUST_USE_RES struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_new(uint64_t liquidity_penalty_multiplier_msat_arg, uint64_t liquidity_offset_half_life_arg);
28475 export function ProbabilisticScoringParameters_new(liquidity_penalty_multiplier_msat_arg: bigint, liquidity_offset_half_life_arg: bigint): number {
28476 if(!isWasmInitialized) {
28477 throw new Error("initializeWasm() must be awaited first!");
28479 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_new(liquidity_penalty_multiplier_msat_arg, liquidity_offset_half_life_arg);
28480 return nativeResponseValue;
28482 // uintptr_t ProbabilisticScoringParameters_clone_ptr(LDKProbabilisticScoringParameters *NONNULL_PTR arg);
28484 export function ProbabilisticScoringParameters_clone_ptr(arg: number): number {
28485 if(!isWasmInitialized) {
28486 throw new Error("initializeWasm() must be awaited first!");
28488 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone_ptr(arg);
28489 return nativeResponseValue;
28491 // struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_clone(const struct LDKProbabilisticScoringParameters *NONNULL_PTR orig);
28493 export function ProbabilisticScoringParameters_clone(orig: number): number {
28494 if(!isWasmInitialized) {
28495 throw new Error("initializeWasm() must be awaited first!");
28497 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone(orig);
28498 return nativeResponseValue;
28500 // struct LDKCVec_u8Z ProbabilisticScoringParameters_write(const struct LDKProbabilisticScoringParameters *NONNULL_PTR obj);
28502 export function ProbabilisticScoringParameters_write(obj: number): number {
28503 if(!isWasmInitialized) {
28504 throw new Error("initializeWasm() must be awaited first!");
28506 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_write(obj);
28507 return nativeResponseValue;
28509 // struct LDKCResult_ProbabilisticScoringParametersDecodeErrorZ ProbabilisticScoringParameters_read(struct LDKu8slice ser);
28511 export function ProbabilisticScoringParameters_read(ser: number): number {
28512 if(!isWasmInitialized) {
28513 throw new Error("initializeWasm() must be awaited first!");
28515 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_read(ser);
28516 return nativeResponseValue;
28518 // MUST_USE_RES struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_default(void);
28520 export function ProbabilisticScoringParameters_default(): number {
28521 if(!isWasmInitialized) {
28522 throw new Error("initializeWasm() must be awaited first!");
28524 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_default();
28525 return nativeResponseValue;
28527 // void Invoice_free(struct LDKInvoice this_obj);
28529 export function Invoice_free(this_obj: number): void {
28530 if(!isWasmInitialized) {
28531 throw new Error("initializeWasm() must be awaited first!");
28533 const nativeResponseValue = wasm.TS_Invoice_free(this_obj);
28534 // debug statements here
28536 // bool Invoice_eq(const struct LDKInvoice *NONNULL_PTR a, const struct LDKInvoice *NONNULL_PTR b);
28538 export function Invoice_eq(a: number, b: number): boolean {
28539 if(!isWasmInitialized) {
28540 throw new Error("initializeWasm() must be awaited first!");
28542 const nativeResponseValue = wasm.TS_Invoice_eq(a, b);
28543 return nativeResponseValue;
28545 // uintptr_t Invoice_clone_ptr(LDKInvoice *NONNULL_PTR arg);
28547 export function Invoice_clone_ptr(arg: number): number {
28548 if(!isWasmInitialized) {
28549 throw new Error("initializeWasm() must be awaited first!");
28551 const nativeResponseValue = wasm.TS_Invoice_clone_ptr(arg);
28552 return nativeResponseValue;
28554 // struct LDKInvoice Invoice_clone(const struct LDKInvoice *NONNULL_PTR orig);
28556 export function Invoice_clone(orig: number): number {
28557 if(!isWasmInitialized) {
28558 throw new Error("initializeWasm() must be awaited first!");
28560 const nativeResponseValue = wasm.TS_Invoice_clone(orig);
28561 return nativeResponseValue;
28563 // void SignedRawInvoice_free(struct LDKSignedRawInvoice this_obj);
28565 export function SignedRawInvoice_free(this_obj: number): void {
28566 if(!isWasmInitialized) {
28567 throw new Error("initializeWasm() must be awaited first!");
28569 const nativeResponseValue = wasm.TS_SignedRawInvoice_free(this_obj);
28570 // debug statements here
28572 // bool SignedRawInvoice_eq(const struct LDKSignedRawInvoice *NONNULL_PTR a, const struct LDKSignedRawInvoice *NONNULL_PTR b);
28574 export function SignedRawInvoice_eq(a: number, b: number): boolean {
28575 if(!isWasmInitialized) {
28576 throw new Error("initializeWasm() must be awaited first!");
28578 const nativeResponseValue = wasm.TS_SignedRawInvoice_eq(a, b);
28579 return nativeResponseValue;
28581 // uintptr_t SignedRawInvoice_clone_ptr(LDKSignedRawInvoice *NONNULL_PTR arg);
28583 export function SignedRawInvoice_clone_ptr(arg: number): number {
28584 if(!isWasmInitialized) {
28585 throw new Error("initializeWasm() must be awaited first!");
28587 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone_ptr(arg);
28588 return nativeResponseValue;
28590 // struct LDKSignedRawInvoice SignedRawInvoice_clone(const struct LDKSignedRawInvoice *NONNULL_PTR orig);
28592 export function SignedRawInvoice_clone(orig: number): number {
28593 if(!isWasmInitialized) {
28594 throw new Error("initializeWasm() must be awaited first!");
28596 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone(orig);
28597 return nativeResponseValue;
28599 // void RawInvoice_free(struct LDKRawInvoice this_obj);
28601 export function RawInvoice_free(this_obj: number): void {
28602 if(!isWasmInitialized) {
28603 throw new Error("initializeWasm() must be awaited first!");
28605 const nativeResponseValue = wasm.TS_RawInvoice_free(this_obj);
28606 // debug statements here
28608 // struct LDKRawDataPart RawInvoice_get_data(const struct LDKRawInvoice *NONNULL_PTR this_ptr);
28610 export function RawInvoice_get_data(this_ptr: number): number {
28611 if(!isWasmInitialized) {
28612 throw new Error("initializeWasm() must be awaited first!");
28614 const nativeResponseValue = wasm.TS_RawInvoice_get_data(this_ptr);
28615 return nativeResponseValue;
28617 // void RawInvoice_set_data(struct LDKRawInvoice *NONNULL_PTR this_ptr, struct LDKRawDataPart val);
28619 export function RawInvoice_set_data(this_ptr: number, val: number): void {
28620 if(!isWasmInitialized) {
28621 throw new Error("initializeWasm() must be awaited first!");
28623 const nativeResponseValue = wasm.TS_RawInvoice_set_data(this_ptr, val);
28624 // debug statements here
28626 // bool RawInvoice_eq(const struct LDKRawInvoice *NONNULL_PTR a, const struct LDKRawInvoice *NONNULL_PTR b);
28628 export function RawInvoice_eq(a: number, b: number): boolean {
28629 if(!isWasmInitialized) {
28630 throw new Error("initializeWasm() must be awaited first!");
28632 const nativeResponseValue = wasm.TS_RawInvoice_eq(a, b);
28633 return nativeResponseValue;
28635 // uintptr_t RawInvoice_clone_ptr(LDKRawInvoice *NONNULL_PTR arg);
28637 export function RawInvoice_clone_ptr(arg: number): number {
28638 if(!isWasmInitialized) {
28639 throw new Error("initializeWasm() must be awaited first!");
28641 const nativeResponseValue = wasm.TS_RawInvoice_clone_ptr(arg);
28642 return nativeResponseValue;
28644 // struct LDKRawInvoice RawInvoice_clone(const struct LDKRawInvoice *NONNULL_PTR orig);
28646 export function RawInvoice_clone(orig: number): number {
28647 if(!isWasmInitialized) {
28648 throw new Error("initializeWasm() must be awaited first!");
28650 const nativeResponseValue = wasm.TS_RawInvoice_clone(orig);
28651 return nativeResponseValue;
28653 // void RawDataPart_free(struct LDKRawDataPart this_obj);
28655 export function RawDataPart_free(this_obj: number): void {
28656 if(!isWasmInitialized) {
28657 throw new Error("initializeWasm() must be awaited first!");
28659 const nativeResponseValue = wasm.TS_RawDataPart_free(this_obj);
28660 // debug statements here
28662 // struct LDKPositiveTimestamp RawDataPart_get_timestamp(const struct LDKRawDataPart *NONNULL_PTR this_ptr);
28664 export function RawDataPart_get_timestamp(this_ptr: number): number {
28665 if(!isWasmInitialized) {
28666 throw new Error("initializeWasm() must be awaited first!");
28668 const nativeResponseValue = wasm.TS_RawDataPart_get_timestamp(this_ptr);
28669 return nativeResponseValue;
28671 // void RawDataPart_set_timestamp(struct LDKRawDataPart *NONNULL_PTR this_ptr, struct LDKPositiveTimestamp val);
28673 export function RawDataPart_set_timestamp(this_ptr: number, val: number): void {
28674 if(!isWasmInitialized) {
28675 throw new Error("initializeWasm() must be awaited first!");
28677 const nativeResponseValue = wasm.TS_RawDataPart_set_timestamp(this_ptr, val);
28678 // debug statements here
28680 // bool RawDataPart_eq(const struct LDKRawDataPart *NONNULL_PTR a, const struct LDKRawDataPart *NONNULL_PTR b);
28682 export function RawDataPart_eq(a: number, b: number): boolean {
28683 if(!isWasmInitialized) {
28684 throw new Error("initializeWasm() must be awaited first!");
28686 const nativeResponseValue = wasm.TS_RawDataPart_eq(a, b);
28687 return nativeResponseValue;
28689 // uintptr_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg);
28691 export function RawDataPart_clone_ptr(arg: number): number {
28692 if(!isWasmInitialized) {
28693 throw new Error("initializeWasm() must be awaited first!");
28695 const nativeResponseValue = wasm.TS_RawDataPart_clone_ptr(arg);
28696 return nativeResponseValue;
28698 // struct LDKRawDataPart RawDataPart_clone(const struct LDKRawDataPart *NONNULL_PTR orig);
28700 export function RawDataPart_clone(orig: number): number {
28701 if(!isWasmInitialized) {
28702 throw new Error("initializeWasm() must be awaited first!");
28704 const nativeResponseValue = wasm.TS_RawDataPart_clone(orig);
28705 return nativeResponseValue;
28707 // void PositiveTimestamp_free(struct LDKPositiveTimestamp this_obj);
28709 export function PositiveTimestamp_free(this_obj: number): void {
28710 if(!isWasmInitialized) {
28711 throw new Error("initializeWasm() must be awaited first!");
28713 const nativeResponseValue = wasm.TS_PositiveTimestamp_free(this_obj);
28714 // debug statements here
28716 // bool PositiveTimestamp_eq(const struct LDKPositiveTimestamp *NONNULL_PTR a, const struct LDKPositiveTimestamp *NONNULL_PTR b);
28718 export function PositiveTimestamp_eq(a: number, b: number): boolean {
28719 if(!isWasmInitialized) {
28720 throw new Error("initializeWasm() must be awaited first!");
28722 const nativeResponseValue = wasm.TS_PositiveTimestamp_eq(a, b);
28723 return nativeResponseValue;
28725 // uintptr_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg);
28727 export function PositiveTimestamp_clone_ptr(arg: number): number {
28728 if(!isWasmInitialized) {
28729 throw new Error("initializeWasm() must be awaited first!");
28731 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone_ptr(arg);
28732 return nativeResponseValue;
28734 // struct LDKPositiveTimestamp PositiveTimestamp_clone(const struct LDKPositiveTimestamp *NONNULL_PTR orig);
28736 export function PositiveTimestamp_clone(orig: number): number {
28737 if(!isWasmInitialized) {
28738 throw new Error("initializeWasm() must be awaited first!");
28740 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone(orig);
28741 return nativeResponseValue;
28743 // enum LDKSiPrefix SiPrefix_clone(const enum LDKSiPrefix *NONNULL_PTR orig);
28745 export function SiPrefix_clone(orig: number): SiPrefix {
28746 if(!isWasmInitialized) {
28747 throw new Error("initializeWasm() must be awaited first!");
28749 const nativeResponseValue = wasm.TS_SiPrefix_clone(orig);
28750 return nativeResponseValue;
28752 // enum LDKSiPrefix SiPrefix_milli(void);
28754 export function SiPrefix_milli(): SiPrefix {
28755 if(!isWasmInitialized) {
28756 throw new Error("initializeWasm() must be awaited first!");
28758 const nativeResponseValue = wasm.TS_SiPrefix_milli();
28759 return nativeResponseValue;
28761 // enum LDKSiPrefix SiPrefix_micro(void);
28763 export function SiPrefix_micro(): SiPrefix {
28764 if(!isWasmInitialized) {
28765 throw new Error("initializeWasm() must be awaited first!");
28767 const nativeResponseValue = wasm.TS_SiPrefix_micro();
28768 return nativeResponseValue;
28770 // enum LDKSiPrefix SiPrefix_nano(void);
28772 export function SiPrefix_nano(): SiPrefix {
28773 if(!isWasmInitialized) {
28774 throw new Error("initializeWasm() must be awaited first!");
28776 const nativeResponseValue = wasm.TS_SiPrefix_nano();
28777 return nativeResponseValue;
28779 // enum LDKSiPrefix SiPrefix_pico(void);
28781 export function SiPrefix_pico(): SiPrefix {
28782 if(!isWasmInitialized) {
28783 throw new Error("initializeWasm() must be awaited first!");
28785 const nativeResponseValue = wasm.TS_SiPrefix_pico();
28786 return nativeResponseValue;
28788 // bool SiPrefix_eq(const enum LDKSiPrefix *NONNULL_PTR a, const enum LDKSiPrefix *NONNULL_PTR b);
28790 export function SiPrefix_eq(a: number, b: number): boolean {
28791 if(!isWasmInitialized) {
28792 throw new Error("initializeWasm() must be awaited first!");
28794 const nativeResponseValue = wasm.TS_SiPrefix_eq(a, b);
28795 return nativeResponseValue;
28797 // MUST_USE_RES uint64_t SiPrefix_multiplier(const enum LDKSiPrefix *NONNULL_PTR this_arg);
28799 export function SiPrefix_multiplier(this_arg: number): bigint {
28800 if(!isWasmInitialized) {
28801 throw new Error("initializeWasm() must be awaited first!");
28803 const nativeResponseValue = wasm.TS_SiPrefix_multiplier(this_arg);
28804 return nativeResponseValue;
28806 // enum LDKCurrency Currency_clone(const enum LDKCurrency *NONNULL_PTR orig);
28808 export function Currency_clone(orig: number): Currency {
28809 if(!isWasmInitialized) {
28810 throw new Error("initializeWasm() must be awaited first!");
28812 const nativeResponseValue = wasm.TS_Currency_clone(orig);
28813 return nativeResponseValue;
28815 // enum LDKCurrency Currency_bitcoin(void);
28817 export function Currency_bitcoin(): Currency {
28818 if(!isWasmInitialized) {
28819 throw new Error("initializeWasm() must be awaited first!");
28821 const nativeResponseValue = wasm.TS_Currency_bitcoin();
28822 return nativeResponseValue;
28824 // enum LDKCurrency Currency_bitcoin_testnet(void);
28826 export function Currency_bitcoin_testnet(): Currency {
28827 if(!isWasmInitialized) {
28828 throw new Error("initializeWasm() must be awaited first!");
28830 const nativeResponseValue = wasm.TS_Currency_bitcoin_testnet();
28831 return nativeResponseValue;
28833 // enum LDKCurrency Currency_regtest(void);
28835 export function Currency_regtest(): Currency {
28836 if(!isWasmInitialized) {
28837 throw new Error("initializeWasm() must be awaited first!");
28839 const nativeResponseValue = wasm.TS_Currency_regtest();
28840 return nativeResponseValue;
28842 // enum LDKCurrency Currency_simnet(void);
28844 export function Currency_simnet(): Currency {
28845 if(!isWasmInitialized) {
28846 throw new Error("initializeWasm() must be awaited first!");
28848 const nativeResponseValue = wasm.TS_Currency_simnet();
28849 return nativeResponseValue;
28851 // enum LDKCurrency Currency_signet(void);
28853 export function Currency_signet(): Currency {
28854 if(!isWasmInitialized) {
28855 throw new Error("initializeWasm() must be awaited first!");
28857 const nativeResponseValue = wasm.TS_Currency_signet();
28858 return nativeResponseValue;
28860 // uint64_t Currency_hash(const enum LDKCurrency *NONNULL_PTR o);
28862 export function Currency_hash(o: number): bigint {
28863 if(!isWasmInitialized) {
28864 throw new Error("initializeWasm() must be awaited first!");
28866 const nativeResponseValue = wasm.TS_Currency_hash(o);
28867 return nativeResponseValue;
28869 // bool Currency_eq(const enum LDKCurrency *NONNULL_PTR a, const enum LDKCurrency *NONNULL_PTR b);
28871 export function Currency_eq(a: number, b: number): boolean {
28872 if(!isWasmInitialized) {
28873 throw new Error("initializeWasm() must be awaited first!");
28875 const nativeResponseValue = wasm.TS_Currency_eq(a, b);
28876 return nativeResponseValue;
28878 // void Sha256_free(struct LDKSha256 this_obj);
28880 export function Sha256_free(this_obj: number): void {
28881 if(!isWasmInitialized) {
28882 throw new Error("initializeWasm() must be awaited first!");
28884 const nativeResponseValue = wasm.TS_Sha256_free(this_obj);
28885 // debug statements here
28887 // uintptr_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg);
28889 export function Sha256_clone_ptr(arg: number): number {
28890 if(!isWasmInitialized) {
28891 throw new Error("initializeWasm() must be awaited first!");
28893 const nativeResponseValue = wasm.TS_Sha256_clone_ptr(arg);
28894 return nativeResponseValue;
28896 // struct LDKSha256 Sha256_clone(const struct LDKSha256 *NONNULL_PTR orig);
28898 export function Sha256_clone(orig: number): number {
28899 if(!isWasmInitialized) {
28900 throw new Error("initializeWasm() must be awaited first!");
28902 const nativeResponseValue = wasm.TS_Sha256_clone(orig);
28903 return nativeResponseValue;
28905 // uint64_t Sha256_hash(const struct LDKSha256 *NONNULL_PTR o);
28907 export function Sha256_hash(o: number): bigint {
28908 if(!isWasmInitialized) {
28909 throw new Error("initializeWasm() must be awaited first!");
28911 const nativeResponseValue = wasm.TS_Sha256_hash(o);
28912 return nativeResponseValue;
28914 // bool Sha256_eq(const struct LDKSha256 *NONNULL_PTR a, const struct LDKSha256 *NONNULL_PTR b);
28916 export function Sha256_eq(a: number, b: number): boolean {
28917 if(!isWasmInitialized) {
28918 throw new Error("initializeWasm() must be awaited first!");
28920 const nativeResponseValue = wasm.TS_Sha256_eq(a, b);
28921 return nativeResponseValue;
28923 // void Description_free(struct LDKDescription this_obj);
28925 export function Description_free(this_obj: number): void {
28926 if(!isWasmInitialized) {
28927 throw new Error("initializeWasm() must be awaited first!");
28929 const nativeResponseValue = wasm.TS_Description_free(this_obj);
28930 // debug statements here
28932 // uintptr_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg);
28934 export function Description_clone_ptr(arg: number): number {
28935 if(!isWasmInitialized) {
28936 throw new Error("initializeWasm() must be awaited first!");
28938 const nativeResponseValue = wasm.TS_Description_clone_ptr(arg);
28939 return nativeResponseValue;
28941 // struct LDKDescription Description_clone(const struct LDKDescription *NONNULL_PTR orig);
28943 export function Description_clone(orig: number): number {
28944 if(!isWasmInitialized) {
28945 throw new Error("initializeWasm() must be awaited first!");
28947 const nativeResponseValue = wasm.TS_Description_clone(orig);
28948 return nativeResponseValue;
28950 // uint64_t Description_hash(const struct LDKDescription *NONNULL_PTR o);
28952 export function Description_hash(o: number): bigint {
28953 if(!isWasmInitialized) {
28954 throw new Error("initializeWasm() must be awaited first!");
28956 const nativeResponseValue = wasm.TS_Description_hash(o);
28957 return nativeResponseValue;
28959 // bool Description_eq(const struct LDKDescription *NONNULL_PTR a, const struct LDKDescription *NONNULL_PTR b);
28961 export function Description_eq(a: number, b: number): boolean {
28962 if(!isWasmInitialized) {
28963 throw new Error("initializeWasm() must be awaited first!");
28965 const nativeResponseValue = wasm.TS_Description_eq(a, b);
28966 return nativeResponseValue;
28968 // void PayeePubKey_free(struct LDKPayeePubKey this_obj);
28970 export function PayeePubKey_free(this_obj: number): void {
28971 if(!isWasmInitialized) {
28972 throw new Error("initializeWasm() must be awaited first!");
28974 const nativeResponseValue = wasm.TS_PayeePubKey_free(this_obj);
28975 // debug statements here
28977 // struct LDKPublicKey PayeePubKey_get_a(const struct LDKPayeePubKey *NONNULL_PTR this_ptr);
28979 export function PayeePubKey_get_a(this_ptr: number): number {
28980 if(!isWasmInitialized) {
28981 throw new Error("initializeWasm() must be awaited first!");
28983 const nativeResponseValue = wasm.TS_PayeePubKey_get_a(this_ptr);
28984 return nativeResponseValue;
28986 // void PayeePubKey_set_a(struct LDKPayeePubKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28988 export function PayeePubKey_set_a(this_ptr: number, val: number): void {
28989 if(!isWasmInitialized) {
28990 throw new Error("initializeWasm() must be awaited first!");
28992 const nativeResponseValue = wasm.TS_PayeePubKey_set_a(this_ptr, val);
28993 // debug statements here
28995 // MUST_USE_RES struct LDKPayeePubKey PayeePubKey_new(struct LDKPublicKey a_arg);
28997 export function PayeePubKey_new(a_arg: number): number {
28998 if(!isWasmInitialized) {
28999 throw new Error("initializeWasm() must be awaited first!");
29001 const nativeResponseValue = wasm.TS_PayeePubKey_new(a_arg);
29002 return nativeResponseValue;
29004 // uintptr_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg);
29006 export function PayeePubKey_clone_ptr(arg: number): number {
29007 if(!isWasmInitialized) {
29008 throw new Error("initializeWasm() must be awaited first!");
29010 const nativeResponseValue = wasm.TS_PayeePubKey_clone_ptr(arg);
29011 return nativeResponseValue;
29013 // struct LDKPayeePubKey PayeePubKey_clone(const struct LDKPayeePubKey *NONNULL_PTR orig);
29015 export function PayeePubKey_clone(orig: number): number {
29016 if(!isWasmInitialized) {
29017 throw new Error("initializeWasm() must be awaited first!");
29019 const nativeResponseValue = wasm.TS_PayeePubKey_clone(orig);
29020 return nativeResponseValue;
29022 // uint64_t PayeePubKey_hash(const struct LDKPayeePubKey *NONNULL_PTR o);
29024 export function PayeePubKey_hash(o: number): bigint {
29025 if(!isWasmInitialized) {
29026 throw new Error("initializeWasm() must be awaited first!");
29028 const nativeResponseValue = wasm.TS_PayeePubKey_hash(o);
29029 return nativeResponseValue;
29031 // bool PayeePubKey_eq(const struct LDKPayeePubKey *NONNULL_PTR a, const struct LDKPayeePubKey *NONNULL_PTR b);
29033 export function PayeePubKey_eq(a: number, b: number): boolean {
29034 if(!isWasmInitialized) {
29035 throw new Error("initializeWasm() must be awaited first!");
29037 const nativeResponseValue = wasm.TS_PayeePubKey_eq(a, b);
29038 return nativeResponseValue;
29040 // void ExpiryTime_free(struct LDKExpiryTime this_obj);
29042 export function ExpiryTime_free(this_obj: number): void {
29043 if(!isWasmInitialized) {
29044 throw new Error("initializeWasm() must be awaited first!");
29046 const nativeResponseValue = wasm.TS_ExpiryTime_free(this_obj);
29047 // debug statements here
29049 // uintptr_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg);
29051 export function ExpiryTime_clone_ptr(arg: number): number {
29052 if(!isWasmInitialized) {
29053 throw new Error("initializeWasm() must be awaited first!");
29055 const nativeResponseValue = wasm.TS_ExpiryTime_clone_ptr(arg);
29056 return nativeResponseValue;
29058 // struct LDKExpiryTime ExpiryTime_clone(const struct LDKExpiryTime *NONNULL_PTR orig);
29060 export function ExpiryTime_clone(orig: number): number {
29061 if(!isWasmInitialized) {
29062 throw new Error("initializeWasm() must be awaited first!");
29064 const nativeResponseValue = wasm.TS_ExpiryTime_clone(orig);
29065 return nativeResponseValue;
29067 // uint64_t ExpiryTime_hash(const struct LDKExpiryTime *NONNULL_PTR o);
29069 export function ExpiryTime_hash(o: number): bigint {
29070 if(!isWasmInitialized) {
29071 throw new Error("initializeWasm() must be awaited first!");
29073 const nativeResponseValue = wasm.TS_ExpiryTime_hash(o);
29074 return nativeResponseValue;
29076 // bool ExpiryTime_eq(const struct LDKExpiryTime *NONNULL_PTR a, const struct LDKExpiryTime *NONNULL_PTR b);
29078 export function ExpiryTime_eq(a: number, b: number): boolean {
29079 if(!isWasmInitialized) {
29080 throw new Error("initializeWasm() must be awaited first!");
29082 const nativeResponseValue = wasm.TS_ExpiryTime_eq(a, b);
29083 return nativeResponseValue;
29085 // void MinFinalCltvExpiry_free(struct LDKMinFinalCltvExpiry this_obj);
29087 export function MinFinalCltvExpiry_free(this_obj: number): void {
29088 if(!isWasmInitialized) {
29089 throw new Error("initializeWasm() must be awaited first!");
29091 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_free(this_obj);
29092 // debug statements here
29094 // uint64_t MinFinalCltvExpiry_get_a(const struct LDKMinFinalCltvExpiry *NONNULL_PTR this_ptr);
29096 export function MinFinalCltvExpiry_get_a(this_ptr: number): bigint {
29097 if(!isWasmInitialized) {
29098 throw new Error("initializeWasm() must be awaited first!");
29100 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_get_a(this_ptr);
29101 return nativeResponseValue;
29103 // void MinFinalCltvExpiry_set_a(struct LDKMinFinalCltvExpiry *NONNULL_PTR this_ptr, uint64_t val);
29105 export function MinFinalCltvExpiry_set_a(this_ptr: number, val: bigint): void {
29106 if(!isWasmInitialized) {
29107 throw new Error("initializeWasm() must be awaited first!");
29109 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_set_a(this_ptr, val);
29110 // debug statements here
29112 // MUST_USE_RES struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_new(uint64_t a_arg);
29114 export function MinFinalCltvExpiry_new(a_arg: bigint): number {
29115 if(!isWasmInitialized) {
29116 throw new Error("initializeWasm() must be awaited first!");
29118 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_new(a_arg);
29119 return nativeResponseValue;
29121 // uintptr_t MinFinalCltvExpiry_clone_ptr(LDKMinFinalCltvExpiry *NONNULL_PTR arg);
29123 export function MinFinalCltvExpiry_clone_ptr(arg: number): number {
29124 if(!isWasmInitialized) {
29125 throw new Error("initializeWasm() must be awaited first!");
29127 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_clone_ptr(arg);
29128 return nativeResponseValue;
29130 // struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_clone(const struct LDKMinFinalCltvExpiry *NONNULL_PTR orig);
29132 export function MinFinalCltvExpiry_clone(orig: number): number {
29133 if(!isWasmInitialized) {
29134 throw new Error("initializeWasm() must be awaited first!");
29136 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_clone(orig);
29137 return nativeResponseValue;
29139 // uint64_t MinFinalCltvExpiry_hash(const struct LDKMinFinalCltvExpiry *NONNULL_PTR o);
29141 export function MinFinalCltvExpiry_hash(o: number): bigint {
29142 if(!isWasmInitialized) {
29143 throw new Error("initializeWasm() must be awaited first!");
29145 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_hash(o);
29146 return nativeResponseValue;
29148 // bool MinFinalCltvExpiry_eq(const struct LDKMinFinalCltvExpiry *NONNULL_PTR a, const struct LDKMinFinalCltvExpiry *NONNULL_PTR b);
29150 export function MinFinalCltvExpiry_eq(a: number, b: number): boolean {
29151 if(!isWasmInitialized) {
29152 throw new Error("initializeWasm() must be awaited first!");
29154 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_eq(a, b);
29155 return nativeResponseValue;
29157 // void Fallback_free(struct LDKFallback this_ptr);
29159 export function Fallback_free(this_ptr: number): void {
29160 if(!isWasmInitialized) {
29161 throw new Error("initializeWasm() must be awaited first!");
29163 const nativeResponseValue = wasm.TS_Fallback_free(this_ptr);
29164 // debug statements here
29166 // uintptr_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg);
29168 export function Fallback_clone_ptr(arg: number): number {
29169 if(!isWasmInitialized) {
29170 throw new Error("initializeWasm() must be awaited first!");
29172 const nativeResponseValue = wasm.TS_Fallback_clone_ptr(arg);
29173 return nativeResponseValue;
29175 // struct LDKFallback Fallback_clone(const struct LDKFallback *NONNULL_PTR orig);
29177 export function Fallback_clone(orig: number): number {
29178 if(!isWasmInitialized) {
29179 throw new Error("initializeWasm() must be awaited first!");
29181 const nativeResponseValue = wasm.TS_Fallback_clone(orig);
29182 return nativeResponseValue;
29184 // struct LDKFallback Fallback_seg_wit_program(struct LDKu5 version, struct LDKCVec_u8Z program);
29186 export function Fallback_seg_wit_program(version: number, program: number): number {
29187 if(!isWasmInitialized) {
29188 throw new Error("initializeWasm() must be awaited first!");
29190 const nativeResponseValue = wasm.TS_Fallback_seg_wit_program(version, program);
29191 return nativeResponseValue;
29193 // struct LDKFallback Fallback_pub_key_hash(struct LDKTwentyBytes a);
29195 export function Fallback_pub_key_hash(a: number): number {
29196 if(!isWasmInitialized) {
29197 throw new Error("initializeWasm() must be awaited first!");
29199 const nativeResponseValue = wasm.TS_Fallback_pub_key_hash(a);
29200 return nativeResponseValue;
29202 // struct LDKFallback Fallback_script_hash(struct LDKTwentyBytes a);
29204 export function Fallback_script_hash(a: number): number {
29205 if(!isWasmInitialized) {
29206 throw new Error("initializeWasm() must be awaited first!");
29208 const nativeResponseValue = wasm.TS_Fallback_script_hash(a);
29209 return nativeResponseValue;
29211 // uint64_t Fallback_hash(const struct LDKFallback *NONNULL_PTR o);
29213 export function Fallback_hash(o: number): bigint {
29214 if(!isWasmInitialized) {
29215 throw new Error("initializeWasm() must be awaited first!");
29217 const nativeResponseValue = wasm.TS_Fallback_hash(o);
29218 return nativeResponseValue;
29220 // bool Fallback_eq(const struct LDKFallback *NONNULL_PTR a, const struct LDKFallback *NONNULL_PTR b);
29222 export function Fallback_eq(a: number, b: number): boolean {
29223 if(!isWasmInitialized) {
29224 throw new Error("initializeWasm() must be awaited first!");
29226 const nativeResponseValue = wasm.TS_Fallback_eq(a, b);
29227 return nativeResponseValue;
29229 // void InvoiceSignature_free(struct LDKInvoiceSignature this_obj);
29231 export function InvoiceSignature_free(this_obj: number): void {
29232 if(!isWasmInitialized) {
29233 throw new Error("initializeWasm() must be awaited first!");
29235 const nativeResponseValue = wasm.TS_InvoiceSignature_free(this_obj);
29236 // debug statements here
29238 // uintptr_t InvoiceSignature_clone_ptr(LDKInvoiceSignature *NONNULL_PTR arg);
29240 export function InvoiceSignature_clone_ptr(arg: number): number {
29241 if(!isWasmInitialized) {
29242 throw new Error("initializeWasm() must be awaited first!");
29244 const nativeResponseValue = wasm.TS_InvoiceSignature_clone_ptr(arg);
29245 return nativeResponseValue;
29247 // struct LDKInvoiceSignature InvoiceSignature_clone(const struct LDKInvoiceSignature *NONNULL_PTR orig);
29249 export function InvoiceSignature_clone(orig: number): number {
29250 if(!isWasmInitialized) {
29251 throw new Error("initializeWasm() must be awaited first!");
29253 const nativeResponseValue = wasm.TS_InvoiceSignature_clone(orig);
29254 return nativeResponseValue;
29256 // bool InvoiceSignature_eq(const struct LDKInvoiceSignature *NONNULL_PTR a, const struct LDKInvoiceSignature *NONNULL_PTR b);
29258 export function InvoiceSignature_eq(a: number, b: number): boolean {
29259 if(!isWasmInitialized) {
29260 throw new Error("initializeWasm() must be awaited first!");
29262 const nativeResponseValue = wasm.TS_InvoiceSignature_eq(a, b);
29263 return nativeResponseValue;
29265 // void PrivateRoute_free(struct LDKPrivateRoute this_obj);
29267 export function PrivateRoute_free(this_obj: number): void {
29268 if(!isWasmInitialized) {
29269 throw new Error("initializeWasm() must be awaited first!");
29271 const nativeResponseValue = wasm.TS_PrivateRoute_free(this_obj);
29272 // debug statements here
29274 // uintptr_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg);
29276 export function PrivateRoute_clone_ptr(arg: number): number {
29277 if(!isWasmInitialized) {
29278 throw new Error("initializeWasm() must be awaited first!");
29280 const nativeResponseValue = wasm.TS_PrivateRoute_clone_ptr(arg);
29281 return nativeResponseValue;
29283 // struct LDKPrivateRoute PrivateRoute_clone(const struct LDKPrivateRoute *NONNULL_PTR orig);
29285 export function PrivateRoute_clone(orig: number): number {
29286 if(!isWasmInitialized) {
29287 throw new Error("initializeWasm() must be awaited first!");
29289 const nativeResponseValue = wasm.TS_PrivateRoute_clone(orig);
29290 return nativeResponseValue;
29292 // uint64_t PrivateRoute_hash(const struct LDKPrivateRoute *NONNULL_PTR o);
29294 export function PrivateRoute_hash(o: number): bigint {
29295 if(!isWasmInitialized) {
29296 throw new Error("initializeWasm() must be awaited first!");
29298 const nativeResponseValue = wasm.TS_PrivateRoute_hash(o);
29299 return nativeResponseValue;
29301 // bool PrivateRoute_eq(const struct LDKPrivateRoute *NONNULL_PTR a, const struct LDKPrivateRoute *NONNULL_PTR b);
29303 export function PrivateRoute_eq(a: number, b: number): boolean {
29304 if(!isWasmInitialized) {
29305 throw new Error("initializeWasm() must be awaited first!");
29307 const nativeResponseValue = wasm.TS_PrivateRoute_eq(a, b);
29308 return nativeResponseValue;
29310 // MUST_USE_RES struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ SignedRawInvoice_into_parts(struct LDKSignedRawInvoice this_arg);
29312 export function SignedRawInvoice_into_parts(this_arg: number): number {
29313 if(!isWasmInitialized) {
29314 throw new Error("initializeWasm() must be awaited first!");
29316 const nativeResponseValue = wasm.TS_SignedRawInvoice_into_parts(this_arg);
29317 return nativeResponseValue;
29319 // MUST_USE_RES struct LDKRawInvoice SignedRawInvoice_raw_invoice(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
29321 export function SignedRawInvoice_raw_invoice(this_arg: number): number {
29322 if(!isWasmInitialized) {
29323 throw new Error("initializeWasm() must be awaited first!");
29325 const nativeResponseValue = wasm.TS_SignedRawInvoice_raw_invoice(this_arg);
29326 return nativeResponseValue;
29328 // MUST_USE_RES const uint8_t (*SignedRawInvoice_hash(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg))[32];
29330 export function SignedRawInvoice_hash(this_arg: number): number {
29331 if(!isWasmInitialized) {
29332 throw new Error("initializeWasm() must be awaited first!");
29334 const nativeResponseValue = wasm.TS_SignedRawInvoice_hash(this_arg);
29335 return nativeResponseValue;
29337 // MUST_USE_RES struct LDKInvoiceSignature SignedRawInvoice_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
29339 export function SignedRawInvoice_signature(this_arg: number): number {
29340 if(!isWasmInitialized) {
29341 throw new Error("initializeWasm() must be awaited first!");
29343 const nativeResponseValue = wasm.TS_SignedRawInvoice_signature(this_arg);
29344 return nativeResponseValue;
29346 // MUST_USE_RES struct LDKCResult_PayeePubKeyErrorZ SignedRawInvoice_recover_payee_pub_key(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
29348 export function SignedRawInvoice_recover_payee_pub_key(this_arg: number): number {
29349 if(!isWasmInitialized) {
29350 throw new Error("initializeWasm() must be awaited first!");
29352 const nativeResponseValue = wasm.TS_SignedRawInvoice_recover_payee_pub_key(this_arg);
29353 return nativeResponseValue;
29355 // MUST_USE_RES bool SignedRawInvoice_check_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
29357 export function SignedRawInvoice_check_signature(this_arg: number): boolean {
29358 if(!isWasmInitialized) {
29359 throw new Error("initializeWasm() must be awaited first!");
29361 const nativeResponseValue = wasm.TS_SignedRawInvoice_check_signature(this_arg);
29362 return nativeResponseValue;
29364 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
29366 export function RawInvoice_hash(this_arg: number): number {
29367 if(!isWasmInitialized) {
29368 throw new Error("initializeWasm() must be awaited first!");
29370 const nativeResponseValue = wasm.TS_RawInvoice_hash(this_arg);
29371 return nativeResponseValue;
29373 // MUST_USE_RES struct LDKSha256 RawInvoice_payment_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
29375 export function RawInvoice_payment_hash(this_arg: number): number {
29376 if(!isWasmInitialized) {
29377 throw new Error("initializeWasm() must be awaited first!");
29379 const nativeResponseValue = wasm.TS_RawInvoice_payment_hash(this_arg);
29380 return nativeResponseValue;
29382 // MUST_USE_RES struct LDKDescription RawInvoice_description(const struct LDKRawInvoice *NONNULL_PTR this_arg);
29384 export function RawInvoice_description(this_arg: number): number {
29385 if(!isWasmInitialized) {
29386 throw new Error("initializeWasm() must be awaited first!");
29388 const nativeResponseValue = wasm.TS_RawInvoice_description(this_arg);
29389 return nativeResponseValue;
29391 // MUST_USE_RES struct LDKPayeePubKey RawInvoice_payee_pub_key(const struct LDKRawInvoice *NONNULL_PTR this_arg);
29393 export function RawInvoice_payee_pub_key(this_arg: number): number {
29394 if(!isWasmInitialized) {
29395 throw new Error("initializeWasm() must be awaited first!");
29397 const nativeResponseValue = wasm.TS_RawInvoice_payee_pub_key(this_arg);
29398 return nativeResponseValue;
29400 // MUST_USE_RES struct LDKSha256 RawInvoice_description_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
29402 export function RawInvoice_description_hash(this_arg: number): number {
29403 if(!isWasmInitialized) {
29404 throw new Error("initializeWasm() must be awaited first!");
29406 const nativeResponseValue = wasm.TS_RawInvoice_description_hash(this_arg);
29407 return nativeResponseValue;
29409 // MUST_USE_RES struct LDKExpiryTime RawInvoice_expiry_time(const struct LDKRawInvoice *NONNULL_PTR this_arg);
29411 export function RawInvoice_expiry_time(this_arg: number): number {
29412 if(!isWasmInitialized) {
29413 throw new Error("initializeWasm() must be awaited first!");
29415 const nativeResponseValue = wasm.TS_RawInvoice_expiry_time(this_arg);
29416 return nativeResponseValue;
29418 // MUST_USE_RES struct LDKMinFinalCltvExpiry RawInvoice_min_final_cltv_expiry(const struct LDKRawInvoice *NONNULL_PTR this_arg);
29420 export function RawInvoice_min_final_cltv_expiry(this_arg: number): number {
29421 if(!isWasmInitialized) {
29422 throw new Error("initializeWasm() must be awaited first!");
29424 const nativeResponseValue = wasm.TS_RawInvoice_min_final_cltv_expiry(this_arg);
29425 return nativeResponseValue;
29427 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_payment_secret(const struct LDKRawInvoice *NONNULL_PTR this_arg);
29429 export function RawInvoice_payment_secret(this_arg: number): number {
29430 if(!isWasmInitialized) {
29431 throw new Error("initializeWasm() must be awaited first!");
29433 const nativeResponseValue = wasm.TS_RawInvoice_payment_secret(this_arg);
29434 return nativeResponseValue;
29436 // MUST_USE_RES struct LDKInvoiceFeatures RawInvoice_features(const struct LDKRawInvoice *NONNULL_PTR this_arg);
29438 export function RawInvoice_features(this_arg: number): number {
29439 if(!isWasmInitialized) {
29440 throw new Error("initializeWasm() must be awaited first!");
29442 const nativeResponseValue = wasm.TS_RawInvoice_features(this_arg);
29443 return nativeResponseValue;
29445 // MUST_USE_RES struct LDKCVec_PrivateRouteZ RawInvoice_private_routes(const struct LDKRawInvoice *NONNULL_PTR this_arg);
29447 export function RawInvoice_private_routes(this_arg: number): number {
29448 if(!isWasmInitialized) {
29449 throw new Error("initializeWasm() must be awaited first!");
29451 const nativeResponseValue = wasm.TS_RawInvoice_private_routes(this_arg);
29452 return nativeResponseValue;
29454 // MUST_USE_RES struct LDKCOption_u64Z RawInvoice_amount_pico_btc(const struct LDKRawInvoice *NONNULL_PTR this_arg);
29456 export function RawInvoice_amount_pico_btc(this_arg: number): number {
29457 if(!isWasmInitialized) {
29458 throw new Error("initializeWasm() must be awaited first!");
29460 const nativeResponseValue = wasm.TS_RawInvoice_amount_pico_btc(this_arg);
29461 return nativeResponseValue;
29463 // MUST_USE_RES enum LDKCurrency RawInvoice_currency(const struct LDKRawInvoice *NONNULL_PTR this_arg);
29465 export function RawInvoice_currency(this_arg: number): Currency {
29466 if(!isWasmInitialized) {
29467 throw new Error("initializeWasm() must be awaited first!");
29469 const nativeResponseValue = wasm.TS_RawInvoice_currency(this_arg);
29470 return nativeResponseValue;
29472 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_unix_timestamp(uint64_t unix_seconds);
29474 export function PositiveTimestamp_from_unix_timestamp(unix_seconds: bigint): number {
29475 if(!isWasmInitialized) {
29476 throw new Error("initializeWasm() must be awaited first!");
29478 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_unix_timestamp(unix_seconds);
29479 return nativeResponseValue;
29481 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_duration_since_epoch(uint64_t duration);
29483 export function PositiveTimestamp_from_duration_since_epoch(duration: bigint): number {
29484 if(!isWasmInitialized) {
29485 throw new Error("initializeWasm() must be awaited first!");
29487 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_duration_since_epoch(duration);
29488 return nativeResponseValue;
29490 // MUST_USE_RES uint64_t PositiveTimestamp_as_unix_timestamp(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
29492 export function PositiveTimestamp_as_unix_timestamp(this_arg: number): bigint {
29493 if(!isWasmInitialized) {
29494 throw new Error("initializeWasm() must be awaited first!");
29496 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_unix_timestamp(this_arg);
29497 return nativeResponseValue;
29499 // MUST_USE_RES uint64_t PositiveTimestamp_as_duration_since_epoch(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
29501 export function PositiveTimestamp_as_duration_since_epoch(this_arg: number): bigint {
29502 if(!isWasmInitialized) {
29503 throw new Error("initializeWasm() must be awaited first!");
29505 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_duration_since_epoch(this_arg);
29506 return nativeResponseValue;
29508 // MUST_USE_RES struct LDKSignedRawInvoice Invoice_into_signed_raw(struct LDKInvoice this_arg);
29510 export function Invoice_into_signed_raw(this_arg: number): number {
29511 if(!isWasmInitialized) {
29512 throw new Error("initializeWasm() must be awaited first!");
29514 const nativeResponseValue = wasm.TS_Invoice_into_signed_raw(this_arg);
29515 return nativeResponseValue;
29517 // MUST_USE_RES struct LDKCResult_NoneSemanticErrorZ Invoice_check_signature(const struct LDKInvoice *NONNULL_PTR this_arg);
29519 export function Invoice_check_signature(this_arg: number): number {
29520 if(!isWasmInitialized) {
29521 throw new Error("initializeWasm() must be awaited first!");
29523 const nativeResponseValue = wasm.TS_Invoice_check_signature(this_arg);
29524 return nativeResponseValue;
29526 // MUST_USE_RES struct LDKCResult_InvoiceSemanticErrorZ Invoice_from_signed(struct LDKSignedRawInvoice signed_invoice);
29528 export function Invoice_from_signed(signed_invoice: number): number {
29529 if(!isWasmInitialized) {
29530 throw new Error("initializeWasm() must be awaited first!");
29532 const nativeResponseValue = wasm.TS_Invoice_from_signed(signed_invoice);
29533 return nativeResponseValue;
29535 // MUST_USE_RES uint64_t Invoice_duration_since_epoch(const struct LDKInvoice *NONNULL_PTR this_arg);
29537 export function Invoice_duration_since_epoch(this_arg: number): bigint {
29538 if(!isWasmInitialized) {
29539 throw new Error("initializeWasm() must be awaited first!");
29541 const nativeResponseValue = wasm.TS_Invoice_duration_since_epoch(this_arg);
29542 return nativeResponseValue;
29544 // MUST_USE_RES const uint8_t (*Invoice_payment_hash(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
29546 export function Invoice_payment_hash(this_arg: number): number {
29547 if(!isWasmInitialized) {
29548 throw new Error("initializeWasm() must be awaited first!");
29550 const nativeResponseValue = wasm.TS_Invoice_payment_hash(this_arg);
29551 return nativeResponseValue;
29553 // MUST_USE_RES struct LDKPublicKey Invoice_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
29555 export function Invoice_payee_pub_key(this_arg: number): number {
29556 if(!isWasmInitialized) {
29557 throw new Error("initializeWasm() must be awaited first!");
29559 const nativeResponseValue = wasm.TS_Invoice_payee_pub_key(this_arg);
29560 return nativeResponseValue;
29562 // MUST_USE_RES const uint8_t (*Invoice_payment_secret(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
29564 export function Invoice_payment_secret(this_arg: number): number {
29565 if(!isWasmInitialized) {
29566 throw new Error("initializeWasm() must be awaited first!");
29568 const nativeResponseValue = wasm.TS_Invoice_payment_secret(this_arg);
29569 return nativeResponseValue;
29571 // MUST_USE_RES struct LDKInvoiceFeatures Invoice_features(const struct LDKInvoice *NONNULL_PTR this_arg);
29573 export function Invoice_features(this_arg: number): number {
29574 if(!isWasmInitialized) {
29575 throw new Error("initializeWasm() must be awaited first!");
29577 const nativeResponseValue = wasm.TS_Invoice_features(this_arg);
29578 return nativeResponseValue;
29580 // MUST_USE_RES struct LDKPublicKey Invoice_recover_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
29582 export function Invoice_recover_payee_pub_key(this_arg: number): number {
29583 if(!isWasmInitialized) {
29584 throw new Error("initializeWasm() must be awaited first!");
29586 const nativeResponseValue = wasm.TS_Invoice_recover_payee_pub_key(this_arg);
29587 return nativeResponseValue;
29589 // MUST_USE_RES uint64_t Invoice_expiry_time(const struct LDKInvoice *NONNULL_PTR this_arg);
29591 export function Invoice_expiry_time(this_arg: number): bigint {
29592 if(!isWasmInitialized) {
29593 throw new Error("initializeWasm() must be awaited first!");
29595 const nativeResponseValue = wasm.TS_Invoice_expiry_time(this_arg);
29596 return nativeResponseValue;
29598 // MUST_USE_RES bool Invoice_would_expire(const struct LDKInvoice *NONNULL_PTR this_arg, uint64_t at_time);
29600 export function Invoice_would_expire(this_arg: number, at_time: bigint): boolean {
29601 if(!isWasmInitialized) {
29602 throw new Error("initializeWasm() must be awaited first!");
29604 const nativeResponseValue = wasm.TS_Invoice_would_expire(this_arg, at_time);
29605 return nativeResponseValue;
29607 // MUST_USE_RES uint64_t Invoice_min_final_cltv_expiry(const struct LDKInvoice *NONNULL_PTR this_arg);
29609 export function Invoice_min_final_cltv_expiry(this_arg: number): bigint {
29610 if(!isWasmInitialized) {
29611 throw new Error("initializeWasm() must be awaited first!");
29613 const nativeResponseValue = wasm.TS_Invoice_min_final_cltv_expiry(this_arg);
29614 return nativeResponseValue;
29616 // MUST_USE_RES struct LDKCVec_PrivateRouteZ Invoice_private_routes(const struct LDKInvoice *NONNULL_PTR this_arg);
29618 export function Invoice_private_routes(this_arg: number): number {
29619 if(!isWasmInitialized) {
29620 throw new Error("initializeWasm() must be awaited first!");
29622 const nativeResponseValue = wasm.TS_Invoice_private_routes(this_arg);
29623 return nativeResponseValue;
29625 // MUST_USE_RES struct LDKCVec_RouteHintZ Invoice_route_hints(const struct LDKInvoice *NONNULL_PTR this_arg);
29627 export function Invoice_route_hints(this_arg: number): number {
29628 if(!isWasmInitialized) {
29629 throw new Error("initializeWasm() must be awaited first!");
29631 const nativeResponseValue = wasm.TS_Invoice_route_hints(this_arg);
29632 return nativeResponseValue;
29634 // MUST_USE_RES enum LDKCurrency Invoice_currency(const struct LDKInvoice *NONNULL_PTR this_arg);
29636 export function Invoice_currency(this_arg: number): Currency {
29637 if(!isWasmInitialized) {
29638 throw new Error("initializeWasm() must be awaited first!");
29640 const nativeResponseValue = wasm.TS_Invoice_currency(this_arg);
29641 return nativeResponseValue;
29643 // MUST_USE_RES struct LDKCOption_u64Z Invoice_amount_milli_satoshis(const struct LDKInvoice *NONNULL_PTR this_arg);
29645 export function Invoice_amount_milli_satoshis(this_arg: number): number {
29646 if(!isWasmInitialized) {
29647 throw new Error("initializeWasm() must be awaited first!");
29649 const nativeResponseValue = wasm.TS_Invoice_amount_milli_satoshis(this_arg);
29650 return nativeResponseValue;
29652 // MUST_USE_RES struct LDKCResult_DescriptionCreationErrorZ Description_new(struct LDKStr description);
29654 export function Description_new(description: number): number {
29655 if(!isWasmInitialized) {
29656 throw new Error("initializeWasm() must be awaited first!");
29658 const nativeResponseValue = wasm.TS_Description_new(description);
29659 return nativeResponseValue;
29661 // MUST_USE_RES struct LDKStr Description_into_inner(struct LDKDescription this_arg);
29663 export function Description_into_inner(this_arg: number): number {
29664 if(!isWasmInitialized) {
29665 throw new Error("initializeWasm() must be awaited first!");
29667 const nativeResponseValue = wasm.TS_Description_into_inner(this_arg);
29668 return nativeResponseValue;
29670 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_seconds(uint64_t seconds);
29672 export function ExpiryTime_from_seconds(seconds: bigint): number {
29673 if(!isWasmInitialized) {
29674 throw new Error("initializeWasm() must be awaited first!");
29676 const nativeResponseValue = wasm.TS_ExpiryTime_from_seconds(seconds);
29677 return nativeResponseValue;
29679 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_duration(uint64_t duration);
29681 export function ExpiryTime_from_duration(duration: bigint): number {
29682 if(!isWasmInitialized) {
29683 throw new Error("initializeWasm() must be awaited first!");
29685 const nativeResponseValue = wasm.TS_ExpiryTime_from_duration(duration);
29686 return nativeResponseValue;
29688 // MUST_USE_RES uint64_t ExpiryTime_as_seconds(const struct LDKExpiryTime *NONNULL_PTR this_arg);
29690 export function ExpiryTime_as_seconds(this_arg: number): bigint {
29691 if(!isWasmInitialized) {
29692 throw new Error("initializeWasm() must be awaited first!");
29694 const nativeResponseValue = wasm.TS_ExpiryTime_as_seconds(this_arg);
29695 return nativeResponseValue;
29697 // MUST_USE_RES uint64_t ExpiryTime_as_duration(const struct LDKExpiryTime *NONNULL_PTR this_arg);
29699 export function ExpiryTime_as_duration(this_arg: number): bigint {
29700 if(!isWasmInitialized) {
29701 throw new Error("initializeWasm() must be awaited first!");
29703 const nativeResponseValue = wasm.TS_ExpiryTime_as_duration(this_arg);
29704 return nativeResponseValue;
29706 // MUST_USE_RES struct LDKCResult_PrivateRouteCreationErrorZ PrivateRoute_new(struct LDKRouteHint hops);
29708 export function PrivateRoute_new(hops: number): number {
29709 if(!isWasmInitialized) {
29710 throw new Error("initializeWasm() must be awaited first!");
29712 const nativeResponseValue = wasm.TS_PrivateRoute_new(hops);
29713 return nativeResponseValue;
29715 // MUST_USE_RES struct LDKRouteHint PrivateRoute_into_inner(struct LDKPrivateRoute this_arg);
29717 export function PrivateRoute_into_inner(this_arg: number): number {
29718 if(!isWasmInitialized) {
29719 throw new Error("initializeWasm() must be awaited first!");
29721 const nativeResponseValue = wasm.TS_PrivateRoute_into_inner(this_arg);
29722 return nativeResponseValue;
29724 // enum LDKCreationError CreationError_clone(const enum LDKCreationError *NONNULL_PTR orig);
29726 export function CreationError_clone(orig: number): CreationError {
29727 if(!isWasmInitialized) {
29728 throw new Error("initializeWasm() must be awaited first!");
29730 const nativeResponseValue = wasm.TS_CreationError_clone(orig);
29731 return nativeResponseValue;
29733 // enum LDKCreationError CreationError_description_too_long(void);
29735 export function CreationError_description_too_long(): CreationError {
29736 if(!isWasmInitialized) {
29737 throw new Error("initializeWasm() must be awaited first!");
29739 const nativeResponseValue = wasm.TS_CreationError_description_too_long();
29740 return nativeResponseValue;
29742 // enum LDKCreationError CreationError_route_too_long(void);
29744 export function CreationError_route_too_long(): CreationError {
29745 if(!isWasmInitialized) {
29746 throw new Error("initializeWasm() must be awaited first!");
29748 const nativeResponseValue = wasm.TS_CreationError_route_too_long();
29749 return nativeResponseValue;
29751 // enum LDKCreationError CreationError_timestamp_out_of_bounds(void);
29753 export function CreationError_timestamp_out_of_bounds(): CreationError {
29754 if(!isWasmInitialized) {
29755 throw new Error("initializeWasm() must be awaited first!");
29757 const nativeResponseValue = wasm.TS_CreationError_timestamp_out_of_bounds();
29758 return nativeResponseValue;
29760 // enum LDKCreationError CreationError_invalid_amount(void);
29762 export function CreationError_invalid_amount(): CreationError {
29763 if(!isWasmInitialized) {
29764 throw new Error("initializeWasm() must be awaited first!");
29766 const nativeResponseValue = wasm.TS_CreationError_invalid_amount();
29767 return nativeResponseValue;
29769 // enum LDKCreationError CreationError_missing_route_hints(void);
29771 export function CreationError_missing_route_hints(): CreationError {
29772 if(!isWasmInitialized) {
29773 throw new Error("initializeWasm() must be awaited first!");
29775 const nativeResponseValue = wasm.TS_CreationError_missing_route_hints();
29776 return nativeResponseValue;
29778 // bool CreationError_eq(const enum LDKCreationError *NONNULL_PTR a, const enum LDKCreationError *NONNULL_PTR b);
29780 export function CreationError_eq(a: number, b: number): boolean {
29781 if(!isWasmInitialized) {
29782 throw new Error("initializeWasm() must be awaited first!");
29784 const nativeResponseValue = wasm.TS_CreationError_eq(a, b);
29785 return nativeResponseValue;
29787 // struct LDKStr CreationError_to_str(const enum LDKCreationError *NONNULL_PTR o);
29789 export function CreationError_to_str(o: number): number {
29790 if(!isWasmInitialized) {
29791 throw new Error("initializeWasm() must be awaited first!");
29793 const nativeResponseValue = wasm.TS_CreationError_to_str(o);
29794 return nativeResponseValue;
29796 // enum LDKSemanticError SemanticError_clone(const enum LDKSemanticError *NONNULL_PTR orig);
29798 export function SemanticError_clone(orig: number): SemanticError {
29799 if(!isWasmInitialized) {
29800 throw new Error("initializeWasm() must be awaited first!");
29802 const nativeResponseValue = wasm.TS_SemanticError_clone(orig);
29803 return nativeResponseValue;
29805 // enum LDKSemanticError SemanticError_no_payment_hash(void);
29807 export function SemanticError_no_payment_hash(): SemanticError {
29808 if(!isWasmInitialized) {
29809 throw new Error("initializeWasm() must be awaited first!");
29811 const nativeResponseValue = wasm.TS_SemanticError_no_payment_hash();
29812 return nativeResponseValue;
29814 // enum LDKSemanticError SemanticError_multiple_payment_hashes(void);
29816 export function SemanticError_multiple_payment_hashes(): SemanticError {
29817 if(!isWasmInitialized) {
29818 throw new Error("initializeWasm() must be awaited first!");
29820 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_hashes();
29821 return nativeResponseValue;
29823 // enum LDKSemanticError SemanticError_no_description(void);
29825 export function SemanticError_no_description(): SemanticError {
29826 if(!isWasmInitialized) {
29827 throw new Error("initializeWasm() must be awaited first!");
29829 const nativeResponseValue = wasm.TS_SemanticError_no_description();
29830 return nativeResponseValue;
29832 // enum LDKSemanticError SemanticError_multiple_descriptions(void);
29834 export function SemanticError_multiple_descriptions(): SemanticError {
29835 if(!isWasmInitialized) {
29836 throw new Error("initializeWasm() must be awaited first!");
29838 const nativeResponseValue = wasm.TS_SemanticError_multiple_descriptions();
29839 return nativeResponseValue;
29841 // enum LDKSemanticError SemanticError_no_payment_secret(void);
29843 export function SemanticError_no_payment_secret(): SemanticError {
29844 if(!isWasmInitialized) {
29845 throw new Error("initializeWasm() must be awaited first!");
29847 const nativeResponseValue = wasm.TS_SemanticError_no_payment_secret();
29848 return nativeResponseValue;
29850 // enum LDKSemanticError SemanticError_multiple_payment_secrets(void);
29852 export function SemanticError_multiple_payment_secrets(): SemanticError {
29853 if(!isWasmInitialized) {
29854 throw new Error("initializeWasm() must be awaited first!");
29856 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_secrets();
29857 return nativeResponseValue;
29859 // enum LDKSemanticError SemanticError_invalid_features(void);
29861 export function SemanticError_invalid_features(): SemanticError {
29862 if(!isWasmInitialized) {
29863 throw new Error("initializeWasm() must be awaited first!");
29865 const nativeResponseValue = wasm.TS_SemanticError_invalid_features();
29866 return nativeResponseValue;
29868 // enum LDKSemanticError SemanticError_invalid_recovery_id(void);
29870 export function SemanticError_invalid_recovery_id(): SemanticError {
29871 if(!isWasmInitialized) {
29872 throw new Error("initializeWasm() must be awaited first!");
29874 const nativeResponseValue = wasm.TS_SemanticError_invalid_recovery_id();
29875 return nativeResponseValue;
29877 // enum LDKSemanticError SemanticError_invalid_signature(void);
29879 export function SemanticError_invalid_signature(): SemanticError {
29880 if(!isWasmInitialized) {
29881 throw new Error("initializeWasm() must be awaited first!");
29883 const nativeResponseValue = wasm.TS_SemanticError_invalid_signature();
29884 return nativeResponseValue;
29886 // enum LDKSemanticError SemanticError_imprecise_amount(void);
29888 export function SemanticError_imprecise_amount(): SemanticError {
29889 if(!isWasmInitialized) {
29890 throw new Error("initializeWasm() must be awaited first!");
29892 const nativeResponseValue = wasm.TS_SemanticError_imprecise_amount();
29893 return nativeResponseValue;
29895 // bool SemanticError_eq(const enum LDKSemanticError *NONNULL_PTR a, const enum LDKSemanticError *NONNULL_PTR b);
29897 export function SemanticError_eq(a: number, b: number): boolean {
29898 if(!isWasmInitialized) {
29899 throw new Error("initializeWasm() must be awaited first!");
29901 const nativeResponseValue = wasm.TS_SemanticError_eq(a, b);
29902 return nativeResponseValue;
29904 // struct LDKStr SemanticError_to_str(const enum LDKSemanticError *NONNULL_PTR o);
29906 export function SemanticError_to_str(o: number): number {
29907 if(!isWasmInitialized) {
29908 throw new Error("initializeWasm() must be awaited first!");
29910 const nativeResponseValue = wasm.TS_SemanticError_to_str(o);
29911 return nativeResponseValue;
29913 // void SignOrCreationError_free(struct LDKSignOrCreationError this_ptr);
29915 export function SignOrCreationError_free(this_ptr: number): void {
29916 if(!isWasmInitialized) {
29917 throw new Error("initializeWasm() must be awaited first!");
29919 const nativeResponseValue = wasm.TS_SignOrCreationError_free(this_ptr);
29920 // debug statements here
29922 // uintptr_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg);
29924 export function SignOrCreationError_clone_ptr(arg: number): number {
29925 if(!isWasmInitialized) {
29926 throw new Error("initializeWasm() must be awaited first!");
29928 const nativeResponseValue = wasm.TS_SignOrCreationError_clone_ptr(arg);
29929 return nativeResponseValue;
29931 // struct LDKSignOrCreationError SignOrCreationError_clone(const struct LDKSignOrCreationError *NONNULL_PTR orig);
29933 export function SignOrCreationError_clone(orig: number): number {
29934 if(!isWasmInitialized) {
29935 throw new Error("initializeWasm() must be awaited first!");
29937 const nativeResponseValue = wasm.TS_SignOrCreationError_clone(orig);
29938 return nativeResponseValue;
29940 // struct LDKSignOrCreationError SignOrCreationError_sign_error(void);
29942 export function SignOrCreationError_sign_error(): number {
29943 if(!isWasmInitialized) {
29944 throw new Error("initializeWasm() must be awaited first!");
29946 const nativeResponseValue = wasm.TS_SignOrCreationError_sign_error();
29947 return nativeResponseValue;
29949 // struct LDKSignOrCreationError SignOrCreationError_creation_error(enum LDKCreationError a);
29951 export function SignOrCreationError_creation_error(a: CreationError): number {
29952 if(!isWasmInitialized) {
29953 throw new Error("initializeWasm() must be awaited first!");
29955 const nativeResponseValue = wasm.TS_SignOrCreationError_creation_error(a);
29956 return nativeResponseValue;
29958 // bool SignOrCreationError_eq(const struct LDKSignOrCreationError *NONNULL_PTR a, const struct LDKSignOrCreationError *NONNULL_PTR b);
29960 export function SignOrCreationError_eq(a: number, b: number): boolean {
29961 if(!isWasmInitialized) {
29962 throw new Error("initializeWasm() must be awaited first!");
29964 const nativeResponseValue = wasm.TS_SignOrCreationError_eq(a, b);
29965 return nativeResponseValue;
29967 // struct LDKStr SignOrCreationError_to_str(const struct LDKSignOrCreationError *NONNULL_PTR o);
29969 export function SignOrCreationError_to_str(o: number): number {
29970 if(!isWasmInitialized) {
29971 throw new Error("initializeWasm() must be awaited first!");
29973 const nativeResponseValue = wasm.TS_SignOrCreationError_to_str(o);
29974 return nativeResponseValue;
29976 // void InvoicePayer_free(struct LDKInvoicePayer this_obj);
29978 export function InvoicePayer_free(this_obj: number): void {
29979 if(!isWasmInitialized) {
29980 throw new Error("initializeWasm() must be awaited first!");
29982 const nativeResponseValue = wasm.TS_InvoicePayer_free(this_obj);
29983 // debug statements here
29985 // void Payer_free(struct LDKPayer this_ptr);
29987 export function Payer_free(this_ptr: number): void {
29988 if(!isWasmInitialized) {
29989 throw new Error("initializeWasm() must be awaited first!");
29991 const nativeResponseValue = wasm.TS_Payer_free(this_ptr);
29992 // debug statements here
29994 // void Router_free(struct LDKRouter this_ptr);
29996 export function Router_free(this_ptr: number): void {
29997 if(!isWasmInitialized) {
29998 throw new Error("initializeWasm() must be awaited first!");
30000 const nativeResponseValue = wasm.TS_Router_free(this_ptr);
30001 // debug statements here
30003 // void RetryAttempts_free(struct LDKRetryAttempts this_obj);
30005 export function RetryAttempts_free(this_obj: number): void {
30006 if(!isWasmInitialized) {
30007 throw new Error("initializeWasm() must be awaited first!");
30009 const nativeResponseValue = wasm.TS_RetryAttempts_free(this_obj);
30010 // debug statements here
30012 // uintptr_t RetryAttempts_get_a(const struct LDKRetryAttempts *NONNULL_PTR this_ptr);
30014 export function RetryAttempts_get_a(this_ptr: number): number {
30015 if(!isWasmInitialized) {
30016 throw new Error("initializeWasm() must be awaited first!");
30018 const nativeResponseValue = wasm.TS_RetryAttempts_get_a(this_ptr);
30019 return nativeResponseValue;
30021 // void RetryAttempts_set_a(struct LDKRetryAttempts *NONNULL_PTR this_ptr, uintptr_t val);
30023 export function RetryAttempts_set_a(this_ptr: number, val: number): void {
30024 if(!isWasmInitialized) {
30025 throw new Error("initializeWasm() must be awaited first!");
30027 const nativeResponseValue = wasm.TS_RetryAttempts_set_a(this_ptr, val);
30028 // debug statements here
30030 // MUST_USE_RES struct LDKRetryAttempts RetryAttempts_new(uintptr_t a_arg);
30032 export function RetryAttempts_new(a_arg: number): number {
30033 if(!isWasmInitialized) {
30034 throw new Error("initializeWasm() must be awaited first!");
30036 const nativeResponseValue = wasm.TS_RetryAttempts_new(a_arg);
30037 return nativeResponseValue;
30039 // uintptr_t RetryAttempts_clone_ptr(LDKRetryAttempts *NONNULL_PTR arg);
30041 export function RetryAttempts_clone_ptr(arg: number): number {
30042 if(!isWasmInitialized) {
30043 throw new Error("initializeWasm() must be awaited first!");
30045 const nativeResponseValue = wasm.TS_RetryAttempts_clone_ptr(arg);
30046 return nativeResponseValue;
30048 // struct LDKRetryAttempts RetryAttempts_clone(const struct LDKRetryAttempts *NONNULL_PTR orig);
30050 export function RetryAttempts_clone(orig: number): number {
30051 if(!isWasmInitialized) {
30052 throw new Error("initializeWasm() must be awaited first!");
30054 const nativeResponseValue = wasm.TS_RetryAttempts_clone(orig);
30055 return nativeResponseValue;
30057 // bool RetryAttempts_eq(const struct LDKRetryAttempts *NONNULL_PTR a, const struct LDKRetryAttempts *NONNULL_PTR b);
30059 export function RetryAttempts_eq(a: number, b: number): boolean {
30060 if(!isWasmInitialized) {
30061 throw new Error("initializeWasm() must be awaited first!");
30063 const nativeResponseValue = wasm.TS_RetryAttempts_eq(a, b);
30064 return nativeResponseValue;
30066 // uint64_t RetryAttempts_hash(const struct LDKRetryAttempts *NONNULL_PTR o);
30068 export function RetryAttempts_hash(o: number): bigint {
30069 if(!isWasmInitialized) {
30070 throw new Error("initializeWasm() must be awaited first!");
30072 const nativeResponseValue = wasm.TS_RetryAttempts_hash(o);
30073 return nativeResponseValue;
30075 // void PaymentError_free(struct LDKPaymentError this_ptr);
30077 export function PaymentError_free(this_ptr: number): void {
30078 if(!isWasmInitialized) {
30079 throw new Error("initializeWasm() must be awaited first!");
30081 const nativeResponseValue = wasm.TS_PaymentError_free(this_ptr);
30082 // debug statements here
30084 // uintptr_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg);
30086 export function PaymentError_clone_ptr(arg: number): number {
30087 if(!isWasmInitialized) {
30088 throw new Error("initializeWasm() must be awaited first!");
30090 const nativeResponseValue = wasm.TS_PaymentError_clone_ptr(arg);
30091 return nativeResponseValue;
30093 // struct LDKPaymentError PaymentError_clone(const struct LDKPaymentError *NONNULL_PTR orig);
30095 export function PaymentError_clone(orig: number): number {
30096 if(!isWasmInitialized) {
30097 throw new Error("initializeWasm() must be awaited first!");
30099 const nativeResponseValue = wasm.TS_PaymentError_clone(orig);
30100 return nativeResponseValue;
30102 // struct LDKPaymentError PaymentError_invoice(struct LDKStr a);
30104 export function PaymentError_invoice(a: number): number {
30105 if(!isWasmInitialized) {
30106 throw new Error("initializeWasm() must be awaited first!");
30108 const nativeResponseValue = wasm.TS_PaymentError_invoice(a);
30109 return nativeResponseValue;
30111 // struct LDKPaymentError PaymentError_routing(struct LDKLightningError a);
30113 export function PaymentError_routing(a: number): number {
30114 if(!isWasmInitialized) {
30115 throw new Error("initializeWasm() must be awaited first!");
30117 const nativeResponseValue = wasm.TS_PaymentError_routing(a);
30118 return nativeResponseValue;
30120 // struct LDKPaymentError PaymentError_sending(struct LDKPaymentSendFailure a);
30122 export function PaymentError_sending(a: number): number {
30123 if(!isWasmInitialized) {
30124 throw new Error("initializeWasm() must be awaited first!");
30126 const nativeResponseValue = wasm.TS_PaymentError_sending(a);
30127 return nativeResponseValue;
30129 // 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);
30131 export function InvoicePayer_new(payer: number, router: number, scorer: number, logger: number, event_handler: number, retry_attempts: number): number {
30132 if(!isWasmInitialized) {
30133 throw new Error("initializeWasm() must be awaited first!");
30135 const nativeResponseValue = wasm.TS_InvoicePayer_new(payer, router, scorer, logger, event_handler, retry_attempts);
30136 return nativeResponseValue;
30138 // MUST_USE_RES struct LDKCResult_PaymentIdPaymentErrorZ InvoicePayer_pay_invoice(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const struct LDKInvoice *NONNULL_PTR invoice);
30140 export function InvoicePayer_pay_invoice(this_arg: number, invoice: number): number {
30141 if(!isWasmInitialized) {
30142 throw new Error("initializeWasm() must be awaited first!");
30144 const nativeResponseValue = wasm.TS_InvoicePayer_pay_invoice(this_arg, invoice);
30145 return nativeResponseValue;
30147 // 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);
30149 export function InvoicePayer_pay_zero_value_invoice(this_arg: number, invoice: number, amount_msats: bigint): number {
30150 if(!isWasmInitialized) {
30151 throw new Error("initializeWasm() must be awaited first!");
30153 const nativeResponseValue = wasm.TS_InvoicePayer_pay_zero_value_invoice(this_arg, invoice, amount_msats);
30154 return nativeResponseValue;
30156 // 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);
30158 export function InvoicePayer_pay_pubkey(this_arg: number, pubkey: number, payment_preimage: number, amount_msats: bigint, final_cltv_expiry_delta: number): number {
30159 if(!isWasmInitialized) {
30160 throw new Error("initializeWasm() must be awaited first!");
30162 const nativeResponseValue = wasm.TS_InvoicePayer_pay_pubkey(this_arg, pubkey, payment_preimage, amount_msats, final_cltv_expiry_delta);
30163 return nativeResponseValue;
30165 // void InvoicePayer_remove_cached_payment(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
30167 export function InvoicePayer_remove_cached_payment(this_arg: number, payment_hash: number): void {
30168 if(!isWasmInitialized) {
30169 throw new Error("initializeWasm() must be awaited first!");
30171 const nativeResponseValue = wasm.TS_InvoicePayer_remove_cached_payment(this_arg, payment_hash);
30172 // debug statements here
30174 // struct LDKEventHandler InvoicePayer_as_EventHandler(const struct LDKInvoicePayer *NONNULL_PTR this_arg);
30176 export function InvoicePayer_as_EventHandler(this_arg: number): number {
30177 if(!isWasmInitialized) {
30178 throw new Error("initializeWasm() must be awaited first!");
30180 const nativeResponseValue = wasm.TS_InvoicePayer_as_EventHandler(this_arg);
30181 return nativeResponseValue;
30183 // 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);
30185 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 {
30186 if(!isWasmInitialized) {
30187 throw new Error("initializeWasm() must be awaited first!");
30189 const nativeResponseValue = wasm.TS_create_invoice_from_channelmanager_and_duration_since_epoch(channelmanager, keys_manager, network, amt_msat, description, duration_since_epoch);
30190 return nativeResponseValue;
30192 // void DefaultRouter_free(struct LDKDefaultRouter this_obj);
30194 export function DefaultRouter_free(this_obj: number): void {
30195 if(!isWasmInitialized) {
30196 throw new Error("initializeWasm() must be awaited first!");
30198 const nativeResponseValue = wasm.TS_DefaultRouter_free(this_obj);
30199 // debug statements here
30201 // MUST_USE_RES struct LDKDefaultRouter DefaultRouter_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger);
30203 export function DefaultRouter_new(network_graph: number, logger: number): number {
30204 if(!isWasmInitialized) {
30205 throw new Error("initializeWasm() must be awaited first!");
30207 const nativeResponseValue = wasm.TS_DefaultRouter_new(network_graph, logger);
30208 return nativeResponseValue;
30210 // struct LDKRouter DefaultRouter_as_Router(const struct LDKDefaultRouter *NONNULL_PTR this_arg);
30212 export function DefaultRouter_as_Router(this_arg: number): number {
30213 if(!isWasmInitialized) {
30214 throw new Error("initializeWasm() must be awaited first!");
30216 const nativeResponseValue = wasm.TS_DefaultRouter_as_Router(this_arg);
30217 return nativeResponseValue;
30219 // struct LDKPayer ChannelManager_as_Payer(const struct LDKChannelManager *NONNULL_PTR this_arg);
30221 export function ChannelManager_as_Payer(this_arg: number): number {
30222 if(!isWasmInitialized) {
30223 throw new Error("initializeWasm() must be awaited first!");
30225 const nativeResponseValue = wasm.TS_ChannelManager_as_Payer(this_arg);
30226 return nativeResponseValue;
30228 // struct LDKCResult_SiPrefixNoneZ SiPrefix_from_str(struct LDKStr s);
30230 export function SiPrefix_from_str(s: number): number {
30231 if(!isWasmInitialized) {
30232 throw new Error("initializeWasm() must be awaited first!");
30234 const nativeResponseValue = wasm.TS_SiPrefix_from_str(s);
30235 return nativeResponseValue;
30237 // struct LDKCResult_InvoiceNoneZ Invoice_from_str(struct LDKStr s);
30239 export function Invoice_from_str(s: number): number {
30240 if(!isWasmInitialized) {
30241 throw new Error("initializeWasm() must be awaited first!");
30243 const nativeResponseValue = wasm.TS_Invoice_from_str(s);
30244 return nativeResponseValue;
30246 // struct LDKCResult_SignedRawInvoiceNoneZ SignedRawInvoice_from_str(struct LDKStr s);
30248 export function SignedRawInvoice_from_str(s: number): number {
30249 if(!isWasmInitialized) {
30250 throw new Error("initializeWasm() must be awaited first!");
30252 const nativeResponseValue = wasm.TS_SignedRawInvoice_from_str(s);
30253 return nativeResponseValue;
30255 // struct LDKStr Invoice_to_str(const struct LDKInvoice *NONNULL_PTR o);
30257 export function Invoice_to_str(o: number): number {
30258 if(!isWasmInitialized) {
30259 throw new Error("initializeWasm() must be awaited first!");
30261 const nativeResponseValue = wasm.TS_Invoice_to_str(o);
30262 return nativeResponseValue;
30264 // struct LDKStr SignedRawInvoice_to_str(const struct LDKSignedRawInvoice *NONNULL_PTR o);
30266 export function SignedRawInvoice_to_str(o: number): number {
30267 if(!isWasmInitialized) {
30268 throw new Error("initializeWasm() must be awaited first!");
30270 const nativeResponseValue = wasm.TS_SignedRawInvoice_to_str(o);
30271 return nativeResponseValue;
30273 // struct LDKStr Currency_to_str(const enum LDKCurrency *NONNULL_PTR o);
30275 export function Currency_to_str(o: number): number {
30276 if(!isWasmInitialized) {
30277 throw new Error("initializeWasm() must be awaited first!");
30279 const nativeResponseValue = wasm.TS_Currency_to_str(o);
30280 return nativeResponseValue;
30282 // struct LDKStr SiPrefix_to_str(const enum LDKSiPrefix *NONNULL_PTR o);
30284 export function SiPrefix_to_str(o: number): number {
30285 if(!isWasmInitialized) {
30286 throw new Error("initializeWasm() must be awaited first!");
30288 const nativeResponseValue = wasm.TS_SiPrefix_to_str(o);
30289 return nativeResponseValue;
30293 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) {
30294 const weak: WeakRef<object> = js_objs[obj_ptr];
30295 if (weak == null || weak == undefined) {
30296 console.error("Got function call on unknown/free'd JS object!");
30297 throw new Error("Got function call on unknown/free'd JS object!");
30299 const obj: object = weak.deref();
30300 if (obj == null || obj == undefined) {
30301 console.error("Got function call on GC'd JS object!");
30302 throw new Error("Got function call on GC'd JS object!");
30306 case 0: fn = Object.getOwnPropertyDescriptor(obj, "get_per_commitment_point"); break;
30307 case 1: fn = Object.getOwnPropertyDescriptor(obj, "release_commitment_secret"); break;
30308 case 2: fn = Object.getOwnPropertyDescriptor(obj, "validate_holder_commitment"); break;
30309 case 3: fn = Object.getOwnPropertyDescriptor(obj, "channel_keys_id"); break;
30310 case 4: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_commitment"); break;
30311 case 5: fn = Object.getOwnPropertyDescriptor(obj, "validate_counterparty_revocation"); break;
30312 case 6: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_commitment_and_htlcs"); break;
30313 case 7: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_output"); break;
30314 case 8: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_htlc"); break;
30315 case 9: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_htlc_transaction"); break;
30316 case 10: fn = Object.getOwnPropertyDescriptor(obj, "sign_closing_transaction"); break;
30317 case 11: fn = Object.getOwnPropertyDescriptor(obj, "sign_channel_announcement"); break;
30318 case 12: fn = Object.getOwnPropertyDescriptor(obj, "ready_channel"); break;
30319 case 13: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
30320 case 14: fn = Object.getOwnPropertyDescriptor(obj, "watch_channel"); break;
30321 case 15: fn = Object.getOwnPropertyDescriptor(obj, "update_channel"); break;
30322 case 16: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_monitor_events"); break;
30323 case 17: fn = Object.getOwnPropertyDescriptor(obj, "broadcast_transaction"); break;
30324 case 18: fn = Object.getOwnPropertyDescriptor(obj, "get_node_secret"); break;
30325 case 19: fn = Object.getOwnPropertyDescriptor(obj, "get_destination_script"); break;
30326 case 20: fn = Object.getOwnPropertyDescriptor(obj, "get_shutdown_scriptpubkey"); break;
30327 case 21: fn = Object.getOwnPropertyDescriptor(obj, "get_channel_signer"); break;
30328 case 22: fn = Object.getOwnPropertyDescriptor(obj, "get_secure_random_bytes"); break;
30329 case 23: fn = Object.getOwnPropertyDescriptor(obj, "read_chan_signer"); break;
30330 case 24: fn = Object.getOwnPropertyDescriptor(obj, "sign_invoice"); break;
30331 case 25: fn = Object.getOwnPropertyDescriptor(obj, "get_inbound_payment_key_material"); break;
30332 case 26: fn = Object.getOwnPropertyDescriptor(obj, "get_est_sat_per_1000_weight"); break;
30333 case 27: fn = Object.getOwnPropertyDescriptor(obj, "log"); break;
30334 case 28: fn = Object.getOwnPropertyDescriptor(obj, "type_id"); break;
30335 case 29: fn = Object.getOwnPropertyDescriptor(obj, "debug_str"); break;
30336 case 30: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
30337 case 31: fn = Object.getOwnPropertyDescriptor(obj, "get_utxo"); break;
30338 case 32: fn = Object.getOwnPropertyDescriptor(obj, "register_tx"); break;
30339 case 33: fn = Object.getOwnPropertyDescriptor(obj, "register_output"); break;
30340 case 34: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg_events"); break;
30341 case 35: fn = Object.getOwnPropertyDescriptor(obj, "handle_event"); break;
30342 case 36: fn = Object.getOwnPropertyDescriptor(obj, "process_pending_events"); break;
30343 case 37: fn = Object.getOwnPropertyDescriptor(obj, "block_connected"); break;
30344 case 38: fn = Object.getOwnPropertyDescriptor(obj, "block_disconnected"); break;
30345 case 39: fn = Object.getOwnPropertyDescriptor(obj, "transactions_confirmed"); break;
30346 case 40: fn = Object.getOwnPropertyDescriptor(obj, "transaction_unconfirmed"); break;
30347 case 41: fn = Object.getOwnPropertyDescriptor(obj, "best_block_updated"); break;
30348 case 42: fn = Object.getOwnPropertyDescriptor(obj, "get_relevant_txids"); break;
30349 case 43: fn = Object.getOwnPropertyDescriptor(obj, "persist_new_channel"); break;
30350 case 44: fn = Object.getOwnPropertyDescriptor(obj, "update_persisted_channel"); break;
30351 case 45: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel"); break;
30352 case 46: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel"); break;
30353 case 47: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_created"); break;
30354 case 48: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_signed"); break;
30355 case 49: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_locked"); break;
30356 case 50: fn = Object.getOwnPropertyDescriptor(obj, "handle_shutdown"); break;
30357 case 51: fn = Object.getOwnPropertyDescriptor(obj, "handle_closing_signed"); break;
30358 case 52: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_add_htlc"); break;
30359 case 53: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fulfill_htlc"); break;
30360 case 54: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_htlc"); break;
30361 case 55: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_malformed_htlc"); break;
30362 case 56: fn = Object.getOwnPropertyDescriptor(obj, "handle_commitment_signed"); break;
30363 case 57: fn = Object.getOwnPropertyDescriptor(obj, "handle_revoke_and_ack"); break;
30364 case 58: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fee"); break;
30365 case 59: fn = Object.getOwnPropertyDescriptor(obj, "handle_announcement_signatures"); break;
30366 case 60: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
30367 case 61: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
30368 case 62: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_reestablish"); break;
30369 case 63: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
30370 case 64: fn = Object.getOwnPropertyDescriptor(obj, "handle_error"); break;
30371 case 65: fn = Object.getOwnPropertyDescriptor(obj, "handle_node_announcement"); break;
30372 case 66: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_announcement"); break;
30373 case 67: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
30374 case 68: fn = Object.getOwnPropertyDescriptor(obj, "get_next_channel_announcements"); break;
30375 case 69: fn = Object.getOwnPropertyDescriptor(obj, "get_next_node_announcements"); break;
30376 case 70: fn = Object.getOwnPropertyDescriptor(obj, "sync_routing_table"); break;
30377 case 71: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_channel_range"); break;
30378 case 72: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_short_channel_ids_end"); break;
30379 case 73: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_channel_range"); break;
30380 case 74: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_short_channel_ids"); break;
30381 case 75: fn = Object.getOwnPropertyDescriptor(obj, "read"); break;
30382 case 76: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
30383 case 77: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg"); break;
30384 case 78: fn = Object.getOwnPropertyDescriptor(obj, "send_data"); break;
30385 case 79: fn = Object.getOwnPropertyDescriptor(obj, "disconnect_socket"); break;
30386 case 80: fn = Object.getOwnPropertyDescriptor(obj, "eq"); break;
30387 case 81: fn = Object.getOwnPropertyDescriptor(obj, "hash"); break;
30388 case 82: fn = Object.getOwnPropertyDescriptor(obj, "channel_penalty_msat"); break;
30389 case 83: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_failed"); break;
30390 case 84: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_successful"); break;
30391 case 85: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
30392 case 86: fn = Object.getOwnPropertyDescriptor(obj, "lock"); break;
30393 case 87: fn = Object.getOwnPropertyDescriptor(obj, "node_id"); break;
30394 case 88: fn = Object.getOwnPropertyDescriptor(obj, "first_hops"); break;
30395 case 89: fn = Object.getOwnPropertyDescriptor(obj, "send_payment"); break;
30396 case 90: fn = Object.getOwnPropertyDescriptor(obj, "send_spontaneous_payment"); break;
30397 case 91: fn = Object.getOwnPropertyDescriptor(obj, "retry_payment"); break;
30398 case 92: fn = Object.getOwnPropertyDescriptor(obj, "abandon_payment"); break;
30399 case 93: fn = Object.getOwnPropertyDescriptor(obj, "find_route"); break;
30401 console.error("Got unknown function call from C!");
30402 throw new Error("Got unknown function call from C!");
30404 if (fn == null || fn == undefined) {
30405 console.error("Got function call on incorrect JS object!");
30406 throw new Error("Got function call on incorrect JS object!");
30408 return fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);