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 LDKProbabilisticScoringParameters C2Tuple_ProbabilisticScoringParametersNetworkGraphZ_get_a(LDKC2Tuple_ProbabilisticScoringParametersNetworkGraphZ *NONNULL_PTR owner);
2181 export function C2Tuple_ProbabilisticScoringParametersNetworkGraphZ_get_a(owner: number): number {
2182 if(!isWasmInitialized) {
2183 throw new Error("initializeWasm() must be awaited first!");
2185 const nativeResponseValue = wasm.TS_C2Tuple_ProbabilisticScoringParametersNetworkGraphZ_get_a(owner);
2186 return nativeResponseValue;
2188 // struct LDKNetworkGraph C2Tuple_ProbabilisticScoringParametersNetworkGraphZ_get_b(LDKC2Tuple_ProbabilisticScoringParametersNetworkGraphZ *NONNULL_PTR owner);
2190 export function C2Tuple_ProbabilisticScoringParametersNetworkGraphZ_get_b(owner: number): number {
2191 if(!isWasmInitialized) {
2192 throw new Error("initializeWasm() must be awaited first!");
2194 const nativeResponseValue = wasm.TS_C2Tuple_ProbabilisticScoringParametersNetworkGraphZ_get_b(owner);
2195 return nativeResponseValue;
2197 // struct LDKProbabilisticScorer *CResult_ProbabilisticScorerDecodeErrorZ_get_ok(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2199 export function CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner: number): number {
2200 if(!isWasmInitialized) {
2201 throw new Error("initializeWasm() must be awaited first!");
2203 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner);
2204 return nativeResponseValue;
2206 // struct LDKDecodeError CResult_ProbabilisticScorerDecodeErrorZ_get_err(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2208 export function CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner: number): number {
2209 if(!isWasmInitialized) {
2210 throw new Error("initializeWasm() must be awaited first!");
2212 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner);
2213 return nativeResponseValue;
2215 // struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2217 export function CResult_InitFeaturesDecodeErrorZ_get_ok(owner: number): number {
2218 if(!isWasmInitialized) {
2219 throw new Error("initializeWasm() must be awaited first!");
2221 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_ok(owner);
2222 return nativeResponseValue;
2224 // struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2226 export function CResult_InitFeaturesDecodeErrorZ_get_err(owner: number): number {
2227 if(!isWasmInitialized) {
2228 throw new Error("initializeWasm() must be awaited first!");
2230 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_err(owner);
2231 return nativeResponseValue;
2233 // struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2235 export function CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner: number): number {
2236 if(!isWasmInitialized) {
2237 throw new Error("initializeWasm() must be awaited first!");
2239 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner);
2240 return nativeResponseValue;
2242 // struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2244 export function CResult_ChannelFeaturesDecodeErrorZ_get_err(owner: number): number {
2245 if(!isWasmInitialized) {
2246 throw new Error("initializeWasm() must be awaited first!");
2248 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(owner);
2249 return nativeResponseValue;
2251 // struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2253 export function CResult_NodeFeaturesDecodeErrorZ_get_ok(owner: number): number {
2254 if(!isWasmInitialized) {
2255 throw new Error("initializeWasm() must be awaited first!");
2257 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(owner);
2258 return nativeResponseValue;
2260 // struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2262 export function CResult_NodeFeaturesDecodeErrorZ_get_err(owner: number): number {
2263 if(!isWasmInitialized) {
2264 throw new Error("initializeWasm() must be awaited first!");
2266 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_err(owner);
2267 return nativeResponseValue;
2269 // struct LDKInvoiceFeatures CResult_InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2271 export function CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner: number): number {
2272 if(!isWasmInitialized) {
2273 throw new Error("initializeWasm() must be awaited first!");
2275 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner);
2276 return nativeResponseValue;
2278 // struct LDKDecodeError CResult_InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2280 export function CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner: number): number {
2281 if(!isWasmInitialized) {
2282 throw new Error("initializeWasm() must be awaited first!");
2284 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner);
2285 return nativeResponseValue;
2287 // struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2289 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner: number): number {
2290 if(!isWasmInitialized) {
2291 throw new Error("initializeWasm() must be awaited first!");
2293 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner);
2294 return nativeResponseValue;
2296 // struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2298 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner: number): number {
2299 if(!isWasmInitialized) {
2300 throw new Error("initializeWasm() must be awaited first!");
2302 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner);
2303 return nativeResponseValue;
2305 // struct LDKDelayedPaymentOutputDescriptor CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2307 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
2308 if(!isWasmInitialized) {
2309 throw new Error("initializeWasm() must be awaited first!");
2311 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
2312 return nativeResponseValue;
2314 // struct LDKDecodeError CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2316 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
2317 if(!isWasmInitialized) {
2318 throw new Error("initializeWasm() must be awaited first!");
2320 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
2321 return nativeResponseValue;
2323 // struct LDKStaticPaymentOutputDescriptor CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2325 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
2326 if(!isWasmInitialized) {
2327 throw new Error("initializeWasm() must be awaited first!");
2329 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
2330 return nativeResponseValue;
2332 // struct LDKDecodeError CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2334 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
2335 if(!isWasmInitialized) {
2336 throw new Error("initializeWasm() must be awaited first!");
2338 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
2339 return nativeResponseValue;
2341 // struct LDKSpendableOutputDescriptor CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2343 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
2344 if(!isWasmInitialized) {
2345 throw new Error("initializeWasm() must be awaited first!");
2347 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner);
2348 return nativeResponseValue;
2350 // struct LDKDecodeError CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2352 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
2353 if(!isWasmInitialized) {
2354 throw new Error("initializeWasm() must be awaited first!");
2356 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner);
2357 return nativeResponseValue;
2359 // struct LDKSignature C2Tuple_SignatureCVec_SignatureZZ_get_a(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
2361 export function C2Tuple_SignatureCVec_SignatureZZ_get_a(owner: number): number {
2362 if(!isWasmInitialized) {
2363 throw new Error("initializeWasm() must be awaited first!");
2365 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_a(owner);
2366 return nativeResponseValue;
2368 // struct LDKCVec_SignatureZ C2Tuple_SignatureCVec_SignatureZZ_get_b(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
2370 export function C2Tuple_SignatureCVec_SignatureZZ_get_b(owner: number): number {
2371 if(!isWasmInitialized) {
2372 throw new Error("initializeWasm() must be awaited first!");
2374 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_b(owner);
2375 return nativeResponseValue;
2377 // struct LDKC2Tuple_SignatureCVec_SignatureZZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
2379 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner: number): number {
2380 if(!isWasmInitialized) {
2381 throw new Error("initializeWasm() must be awaited first!");
2383 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner);
2384 return nativeResponseValue;
2386 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
2388 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner: number): void {
2389 if(!isWasmInitialized) {
2390 throw new Error("initializeWasm() must be awaited first!");
2392 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner);
2393 // debug statements here
2395 // struct LDKSignature CResult_SignatureNoneZ_get_ok(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
2397 export function CResult_SignatureNoneZ_get_ok(owner: number): number {
2398 if(!isWasmInitialized) {
2399 throw new Error("initializeWasm() must be awaited first!");
2401 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_ok(owner);
2402 return nativeResponseValue;
2404 // void CResult_SignatureNoneZ_get_err(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
2406 export function CResult_SignatureNoneZ_get_err(owner: number): void {
2407 if(!isWasmInitialized) {
2408 throw new Error("initializeWasm() must be awaited first!");
2410 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_err(owner);
2411 // debug statements here
2413 // struct LDKSignature C2Tuple_SignatureSignatureZ_get_a(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner);
2415 export function C2Tuple_SignatureSignatureZ_get_a(owner: number): number {
2416 if(!isWasmInitialized) {
2417 throw new Error("initializeWasm() must be awaited first!");
2419 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_get_a(owner);
2420 return nativeResponseValue;
2422 // struct LDKSignature C2Tuple_SignatureSignatureZ_get_b(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner);
2424 export function C2Tuple_SignatureSignatureZ_get_b(owner: number): number {
2425 if(!isWasmInitialized) {
2426 throw new Error("initializeWasm() must be awaited first!");
2428 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_get_b(owner);
2429 return nativeResponseValue;
2431 // struct LDKC2Tuple_SignatureSignatureZ CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner);
2433 export function CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner: number): number {
2434 if(!isWasmInitialized) {
2435 throw new Error("initializeWasm() must be awaited first!");
2437 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner);
2438 return nativeResponseValue;
2440 // void CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner);
2442 export function CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner: number): void {
2443 if(!isWasmInitialized) {
2444 throw new Error("initializeWasm() must be awaited first!");
2446 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner);
2447 // debug statements here
2449 // struct LDKSecretKey CResult_SecretKeyNoneZ_get_ok(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner);
2451 export function CResult_SecretKeyNoneZ_get_ok(owner: number): number {
2452 if(!isWasmInitialized) {
2453 throw new Error("initializeWasm() must be awaited first!");
2455 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_get_ok(owner);
2456 return nativeResponseValue;
2458 // void CResult_SecretKeyNoneZ_get_err(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner);
2460 export function CResult_SecretKeyNoneZ_get_err(owner: number): void {
2461 if(!isWasmInitialized) {
2462 throw new Error("initializeWasm() must be awaited first!");
2464 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_get_err(owner);
2465 // debug statements here
2468 export interface LDKBaseSign {
2469 get_per_commitment_point (idx: bigint): number;
2470 release_commitment_secret (idx: bigint): number;
2471 validate_holder_commitment (holder_tx: number, preimages: number): number;
2472 channel_keys_id (): number;
2473 sign_counterparty_commitment (commitment_tx: number, preimages: number): number;
2474 validate_counterparty_revocation (idx: bigint, secret: number): number;
2475 sign_holder_commitment_and_htlcs (commitment_tx: number): number;
2476 sign_justice_revoked_output (justice_tx: number, input: number, amount: bigint, per_commitment_key: number): number;
2477 sign_justice_revoked_htlc (justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: number): number;
2478 sign_counterparty_htlc_transaction (htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: number): number;
2479 sign_closing_transaction (closing_tx: number): number;
2480 sign_channel_announcement (msg: number): number;
2481 ready_channel (channel_parameters: number): void;
2485 export function LDKBaseSign_new(impl: LDKBaseSign, pubkeys: number): number {
2486 if(!isWasmInitialized) {
2487 throw new Error("initializeWasm() must be awaited first!");
2489 var new_obj_idx = js_objs.length;
2490 for (var i = 0; i < js_objs.length; i++) {
2491 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2493 js_objs[i] = new WeakRef(impl);
2494 return wasm.TS_LDKBaseSign_new(i);
2496 // LDKPublicKey BaseSign_get_per_commitment_point LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
2498 export function BaseSign_get_per_commitment_point(this_arg: number, idx: bigint): number {
2499 if(!isWasmInitialized) {
2500 throw new Error("initializeWasm() must be awaited first!");
2502 const nativeResponseValue = wasm.TS_BaseSign_get_per_commitment_point(this_arg, idx);
2503 return nativeResponseValue;
2505 // LDKThirtyTwoBytes BaseSign_release_commitment_secret LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
2507 export function BaseSign_release_commitment_secret(this_arg: number, idx: bigint): number {
2508 if(!isWasmInitialized) {
2509 throw new Error("initializeWasm() must be awaited first!");
2511 const nativeResponseValue = wasm.TS_BaseSign_release_commitment_secret(this_arg, idx);
2512 return nativeResponseValue;
2514 // LDKCResult_NoneNoneZ BaseSign_validate_holder_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_PaymentPreimageZ preimages
2516 export function BaseSign_validate_holder_commitment(this_arg: number, holder_tx: number, preimages: number): number {
2517 if(!isWasmInitialized) {
2518 throw new Error("initializeWasm() must be awaited first!");
2520 const nativeResponseValue = wasm.TS_BaseSign_validate_holder_commitment(this_arg, holder_tx, preimages);
2521 return nativeResponseValue;
2523 // LDKThirtyTwoBytes BaseSign_channel_keys_id LDKBaseSign *NONNULL_PTR this_arg
2525 export function BaseSign_channel_keys_id(this_arg: number): number {
2526 if(!isWasmInitialized) {
2527 throw new Error("initializeWasm() must be awaited first!");
2529 const nativeResponseValue = wasm.TS_BaseSign_channel_keys_id(this_arg);
2530 return nativeResponseValue;
2532 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_counterparty_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_PaymentPreimageZ preimages
2534 export function BaseSign_sign_counterparty_commitment(this_arg: number, commitment_tx: number, preimages: number): number {
2535 if(!isWasmInitialized) {
2536 throw new Error("initializeWasm() must be awaited first!");
2538 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_commitment(this_arg, commitment_tx, preimages);
2539 return nativeResponseValue;
2541 // LDKCResult_NoneNoneZ BaseSign_validate_counterparty_revocation LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx, const uint8_t (*secret)[32]
2543 export function BaseSign_validate_counterparty_revocation(this_arg: number, idx: bigint, secret: number): number {
2544 if(!isWasmInitialized) {
2545 throw new Error("initializeWasm() must be awaited first!");
2547 const nativeResponseValue = wasm.TS_BaseSign_validate_counterparty_revocation(this_arg, idx, secret);
2548 return nativeResponseValue;
2550 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_holder_commitment_and_htlcs LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx
2552 export function BaseSign_sign_holder_commitment_and_htlcs(this_arg: number, commitment_tx: number): number {
2553 if(!isWasmInitialized) {
2554 throw new Error("initializeWasm() must be awaited first!");
2556 const nativeResponseValue = wasm.TS_BaseSign_sign_holder_commitment_and_htlcs(this_arg, commitment_tx);
2557 return nativeResponseValue;
2559 // 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]
2561 export function BaseSign_sign_justice_revoked_output(this_arg: number, justice_tx: number, input: number, amount: bigint, per_commitment_key: number): number {
2562 if(!isWasmInitialized) {
2563 throw new Error("initializeWasm() must be awaited first!");
2565 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_output(this_arg, justice_tx, input, amount, per_commitment_key);
2566 return nativeResponseValue;
2568 // 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
2570 export function BaseSign_sign_justice_revoked_htlc(this_arg: number, justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: number): number {
2571 if(!isWasmInitialized) {
2572 throw new Error("initializeWasm() must be awaited first!");
2574 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_htlc(this_arg, justice_tx, input, amount, per_commitment_key, htlc);
2575 return nativeResponseValue;
2577 // 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
2579 export function BaseSign_sign_counterparty_htlc_transaction(this_arg: number, htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: number): number {
2580 if(!isWasmInitialized) {
2581 throw new Error("initializeWasm() must be awaited first!");
2583 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_htlc_transaction(this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
2584 return nativeResponseValue;
2586 // LDKCResult_SignatureNoneZ BaseSign_sign_closing_transaction LDKBaseSign *NONNULL_PTR this_arg, const struct LDKClosingTransaction *NONNULL_PTR closing_tx
2588 export function BaseSign_sign_closing_transaction(this_arg: number, closing_tx: number): number {
2589 if(!isWasmInitialized) {
2590 throw new Error("initializeWasm() must be awaited first!");
2592 const nativeResponseValue = wasm.TS_BaseSign_sign_closing_transaction(this_arg, closing_tx);
2593 return nativeResponseValue;
2595 // LDKCResult_C2Tuple_SignatureSignatureZNoneZ BaseSign_sign_channel_announcement LDKBaseSign *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg
2597 export function BaseSign_sign_channel_announcement(this_arg: number, msg: number): number {
2598 if(!isWasmInitialized) {
2599 throw new Error("initializeWasm() must be awaited first!");
2601 const nativeResponseValue = wasm.TS_BaseSign_sign_channel_announcement(this_arg, msg);
2602 return nativeResponseValue;
2604 // void BaseSign_ready_channel LDKBaseSign *NONNULL_PTR this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters
2606 export function BaseSign_ready_channel(this_arg: number, channel_parameters: number): void {
2607 if(!isWasmInitialized) {
2608 throw new Error("initializeWasm() must be awaited first!");
2610 const nativeResponseValue = wasm.TS_BaseSign_ready_channel(this_arg, channel_parameters);
2611 // debug statements here
2613 // LDKChannelPublicKeys BaseSign_get_pubkeys LDKBaseSign *NONNULL_PTR this_arg
2615 export function BaseSign_get_pubkeys(this_arg: number): number {
2616 if(!isWasmInitialized) {
2617 throw new Error("initializeWasm() must be awaited first!");
2619 const nativeResponseValue = wasm.TS_BaseSign_get_pubkeys(this_arg);
2620 return nativeResponseValue;
2623 export interface LDKSign {
2628 export function LDKSign_new(impl: LDKSign, BaseSign: LDKBaseSign, pubkeys: number): number {
2629 if(!isWasmInitialized) {
2630 throw new Error("initializeWasm() must be awaited first!");
2632 var new_obj_idx = js_objs.length;
2633 for (var i = 0; i < js_objs.length; i++) {
2634 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2636 js_objs[i] = new WeakRef(impl);
2637 return wasm.TS_LDKSign_new(i);
2639 // LDKCVec_u8Z Sign_write LDKSign *NONNULL_PTR this_arg
2641 export function Sign_write(this_arg: number): number {
2642 if(!isWasmInitialized) {
2643 throw new Error("initializeWasm() must be awaited first!");
2645 const nativeResponseValue = wasm.TS_Sign_write(this_arg);
2646 return nativeResponseValue;
2648 // struct LDKSign CResult_SignDecodeErrorZ_get_ok(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
2650 export function CResult_SignDecodeErrorZ_get_ok(owner: number): number {
2651 if(!isWasmInitialized) {
2652 throw new Error("initializeWasm() must be awaited first!");
2654 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_ok(owner);
2655 return nativeResponseValue;
2657 // struct LDKDecodeError CResult_SignDecodeErrorZ_get_err(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
2659 export function CResult_SignDecodeErrorZ_get_err(owner: number): number {
2660 if(!isWasmInitialized) {
2661 throw new Error("initializeWasm() must be awaited first!");
2663 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_err(owner);
2664 return nativeResponseValue;
2666 // struct LDKRecoverableSignature CResult_RecoverableSignatureNoneZ_get_ok(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
2668 export function CResult_RecoverableSignatureNoneZ_get_ok(owner: number): number {
2669 if(!isWasmInitialized) {
2670 throw new Error("initializeWasm() must be awaited first!");
2672 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_ok(owner);
2673 return nativeResponseValue;
2675 // void CResult_RecoverableSignatureNoneZ_get_err(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
2677 export function CResult_RecoverableSignatureNoneZ_get_err(owner: number): void {
2678 if(!isWasmInitialized) {
2679 throw new Error("initializeWasm() must be awaited first!");
2681 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_err(owner);
2682 // debug statements here
2684 // struct LDKCVec_CVec_u8ZZ CResult_CVec_CVec_u8ZZNoneZ_get_ok(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
2686 export function CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner: number): number {
2687 if(!isWasmInitialized) {
2688 throw new Error("initializeWasm() must be awaited first!");
2690 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner);
2691 return nativeResponseValue;
2693 // void CResult_CVec_CVec_u8ZZNoneZ_get_err(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
2695 export function CResult_CVec_CVec_u8ZZNoneZ_get_err(owner: number): void {
2696 if(!isWasmInitialized) {
2697 throw new Error("initializeWasm() must be awaited first!");
2699 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_err(owner);
2700 // debug statements here
2702 // struct LDKInMemorySigner CResult_InMemorySignerDecodeErrorZ_get_ok(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
2704 export function CResult_InMemorySignerDecodeErrorZ_get_ok(owner: number): number {
2705 if(!isWasmInitialized) {
2706 throw new Error("initializeWasm() must be awaited first!");
2708 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_ok(owner);
2709 return nativeResponseValue;
2711 // struct LDKDecodeError CResult_InMemorySignerDecodeErrorZ_get_err(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
2713 export function CResult_InMemorySignerDecodeErrorZ_get_err(owner: number): number {
2714 if(!isWasmInitialized) {
2715 throw new Error("initializeWasm() must be awaited first!");
2717 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_err(owner);
2718 return nativeResponseValue;
2720 // struct LDKTransaction CResult_TransactionNoneZ_get_ok(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
2722 export function CResult_TransactionNoneZ_get_ok(owner: number): number {
2723 if(!isWasmInitialized) {
2724 throw new Error("initializeWasm() must be awaited first!");
2726 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_ok(owner);
2727 return nativeResponseValue;
2729 // void CResult_TransactionNoneZ_get_err(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
2731 export function CResult_TransactionNoneZ_get_err(owner: number): void {
2732 if(!isWasmInitialized) {
2733 throw new Error("initializeWasm() must be awaited first!");
2735 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_err(owner);
2736 // debug statements here
2739 export class LDKCOption_u16Z {
2740 protected constructor() {}
2743 export function LDKCOption_u16Z_ty_from_ptr(ptr: number): number {
2744 if(!isWasmInitialized) {
2745 throw new Error("initializeWasm() must be awaited first!");
2747 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_ty_from_ptr(ptr);
2748 return nativeResponseValue;
2751 export function LDKCOption_u16Z_Some_get_some(ptr: number): number {
2752 if(!isWasmInitialized) {
2753 throw new Error("initializeWasm() must be awaited first!");
2755 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_Some_get_some(ptr);
2756 return nativeResponseValue;
2759 export class LDKAPIError {
2760 protected constructor() {}
2763 export function LDKAPIError_ty_from_ptr(ptr: number): number {
2764 if(!isWasmInitialized) {
2765 throw new Error("initializeWasm() must be awaited first!");
2767 const nativeResponseValue = wasm.TS_LDKAPIError_ty_from_ptr(ptr);
2768 return nativeResponseValue;
2771 export function LDKAPIError_APIMisuseError_get_err(ptr: number): number {
2772 if(!isWasmInitialized) {
2773 throw new Error("initializeWasm() must be awaited first!");
2775 const nativeResponseValue = wasm.TS_LDKAPIError_APIMisuseError_get_err(ptr);
2776 return nativeResponseValue;
2779 export function LDKAPIError_FeeRateTooHigh_get_err(ptr: number): number {
2780 if(!isWasmInitialized) {
2781 throw new Error("initializeWasm() must be awaited first!");
2783 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_err(ptr);
2784 return nativeResponseValue;
2787 export function LDKAPIError_FeeRateTooHigh_get_feerate(ptr: number): number {
2788 if(!isWasmInitialized) {
2789 throw new Error("initializeWasm() must be awaited first!");
2791 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_feerate(ptr);
2792 return nativeResponseValue;
2795 export function LDKAPIError_RouteError_get_err(ptr: number): number {
2796 if(!isWasmInitialized) {
2797 throw new Error("initializeWasm() must be awaited first!");
2799 const nativeResponseValue = wasm.TS_LDKAPIError_RouteError_get_err(ptr);
2800 return nativeResponseValue;
2803 export function LDKAPIError_ChannelUnavailable_get_err(ptr: number): number {
2804 if(!isWasmInitialized) {
2805 throw new Error("initializeWasm() must be awaited first!");
2807 const nativeResponseValue = wasm.TS_LDKAPIError_ChannelUnavailable_get_err(ptr);
2808 return nativeResponseValue;
2811 export function LDKAPIError_IncompatibleShutdownScript_get_script(ptr: number): number {
2812 if(!isWasmInitialized) {
2813 throw new Error("initializeWasm() must be awaited first!");
2815 const nativeResponseValue = wasm.TS_LDKAPIError_IncompatibleShutdownScript_get_script(ptr);
2816 return nativeResponseValue;
2818 // void CResult_NoneAPIErrorZ_get_ok(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
2820 export function CResult_NoneAPIErrorZ_get_ok(owner: number): void {
2821 if(!isWasmInitialized) {
2822 throw new Error("initializeWasm() must be awaited first!");
2824 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_ok(owner);
2825 // debug statements here
2827 // struct LDKAPIError CResult_NoneAPIErrorZ_get_err(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
2829 export function CResult_NoneAPIErrorZ_get_err(owner: number): number {
2830 if(!isWasmInitialized) {
2831 throw new Error("initializeWasm() must be awaited first!");
2833 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_err(owner);
2834 return nativeResponseValue;
2836 // struct LDKThirtyTwoBytes CResult__u832APIErrorZ_get_ok(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
2838 export function CResult__u832APIErrorZ_get_ok(owner: number): number {
2839 if(!isWasmInitialized) {
2840 throw new Error("initializeWasm() must be awaited first!");
2842 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_ok(owner);
2843 return nativeResponseValue;
2845 // struct LDKAPIError CResult__u832APIErrorZ_get_err(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
2847 export function CResult__u832APIErrorZ_get_err(owner: number): number {
2848 if(!isWasmInitialized) {
2849 throw new Error("initializeWasm() must be awaited first!");
2851 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_err(owner);
2852 return nativeResponseValue;
2855 export class LDKPaymentSendFailure {
2856 protected constructor() {}
2859 export function LDKPaymentSendFailure_ty_from_ptr(ptr: number): number {
2860 if(!isWasmInitialized) {
2861 throw new Error("initializeWasm() must be awaited first!");
2863 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ty_from_ptr(ptr);
2864 return nativeResponseValue;
2867 export function LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr: number): number {
2868 if(!isWasmInitialized) {
2869 throw new Error("initializeWasm() must be awaited first!");
2871 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr);
2872 return nativeResponseValue;
2875 export function LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr: number): number {
2876 if(!isWasmInitialized) {
2877 throw new Error("initializeWasm() must be awaited first!");
2879 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr);
2880 return nativeResponseValue;
2883 export function LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr: number): number {
2884 if(!isWasmInitialized) {
2885 throw new Error("initializeWasm() must be awaited first!");
2887 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr);
2888 return nativeResponseValue;
2891 export function LDKPaymentSendFailure_PartialFailure_get_results(ptr: number): number {
2892 if(!isWasmInitialized) {
2893 throw new Error("initializeWasm() must be awaited first!");
2895 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_results(ptr);
2896 return nativeResponseValue;
2899 export function LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr: number): number {
2900 if(!isWasmInitialized) {
2901 throw new Error("initializeWasm() must be awaited first!");
2903 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr);
2904 return nativeResponseValue;
2907 export function LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr: number): number {
2908 if(!isWasmInitialized) {
2909 throw new Error("initializeWasm() must be awaited first!");
2911 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr);
2912 return nativeResponseValue;
2914 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentSendFailureZ_get_ok(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
2916 export function CResult_PaymentIdPaymentSendFailureZ_get_ok(owner: number): number {
2917 if(!isWasmInitialized) {
2918 throw new Error("initializeWasm() must be awaited first!");
2920 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_ok(owner);
2921 return nativeResponseValue;
2923 // struct LDKPaymentSendFailure CResult_PaymentIdPaymentSendFailureZ_get_err(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
2925 export function CResult_PaymentIdPaymentSendFailureZ_get_err(owner: number): number {
2926 if(!isWasmInitialized) {
2927 throw new Error("initializeWasm() must be awaited first!");
2929 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_err(owner);
2930 return nativeResponseValue;
2932 // void CResult_NonePaymentSendFailureZ_get_ok(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
2934 export function CResult_NonePaymentSendFailureZ_get_ok(owner: number): void {
2935 if(!isWasmInitialized) {
2936 throw new Error("initializeWasm() must be awaited first!");
2938 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_ok(owner);
2939 // debug statements here
2941 // struct LDKPaymentSendFailure CResult_NonePaymentSendFailureZ_get_err(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
2943 export function CResult_NonePaymentSendFailureZ_get_err(owner: number): number {
2944 if(!isWasmInitialized) {
2945 throw new Error("initializeWasm() must be awaited first!");
2947 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_err(owner);
2948 return nativeResponseValue;
2950 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_a(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
2952 export function C2Tuple_PaymentHashPaymentIdZ_get_a(owner: number): number {
2953 if(!isWasmInitialized) {
2954 throw new Error("initializeWasm() must be awaited first!");
2956 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_a(owner);
2957 return nativeResponseValue;
2959 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_b(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
2961 export function C2Tuple_PaymentHashPaymentIdZ_get_b(owner: number): number {
2962 if(!isWasmInitialized) {
2963 throw new Error("initializeWasm() must be awaited first!");
2965 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_b(owner);
2966 return nativeResponseValue;
2968 // struct LDKC2Tuple_PaymentHashPaymentIdZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
2970 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner: number): number {
2971 if(!isWasmInitialized) {
2972 throw new Error("initializeWasm() must be awaited first!");
2974 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner);
2975 return nativeResponseValue;
2977 // struct LDKPaymentSendFailure CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
2979 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner: number): number {
2980 if(!isWasmInitialized) {
2981 throw new Error("initializeWasm() must be awaited first!");
2983 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner);
2984 return nativeResponseValue;
2987 export class LDKNetAddress {
2988 protected constructor() {}
2991 export function LDKNetAddress_ty_from_ptr(ptr: number): number {
2992 if(!isWasmInitialized) {
2993 throw new Error("initializeWasm() must be awaited first!");
2995 const nativeResponseValue = wasm.TS_LDKNetAddress_ty_from_ptr(ptr);
2996 return nativeResponseValue;
2999 export function LDKNetAddress_IPv4_get_addr(ptr: number): number {
3000 if(!isWasmInitialized) {
3001 throw new Error("initializeWasm() must be awaited first!");
3003 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_addr(ptr);
3004 return nativeResponseValue;
3007 export function LDKNetAddress_IPv4_get_port(ptr: number): number {
3008 if(!isWasmInitialized) {
3009 throw new Error("initializeWasm() must be awaited first!");
3011 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_port(ptr);
3012 return nativeResponseValue;
3015 export function LDKNetAddress_IPv6_get_addr(ptr: number): number {
3016 if(!isWasmInitialized) {
3017 throw new Error("initializeWasm() must be awaited first!");
3019 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_addr(ptr);
3020 return nativeResponseValue;
3023 export function LDKNetAddress_IPv6_get_port(ptr: number): number {
3024 if(!isWasmInitialized) {
3025 throw new Error("initializeWasm() must be awaited first!");
3027 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_port(ptr);
3028 return nativeResponseValue;
3031 export function LDKNetAddress_OnionV2_get_onion_v2(ptr: number): number {
3032 if(!isWasmInitialized) {
3033 throw new Error("initializeWasm() must be awaited first!");
3035 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV2_get_onion_v2(ptr);
3036 return nativeResponseValue;
3039 export function LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr: number): number {
3040 if(!isWasmInitialized) {
3041 throw new Error("initializeWasm() must be awaited first!");
3043 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr);
3044 return nativeResponseValue;
3047 export function LDKNetAddress_OnionV3_get_checksum(ptr: number): number {
3048 if(!isWasmInitialized) {
3049 throw new Error("initializeWasm() must be awaited first!");
3051 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_checksum(ptr);
3052 return nativeResponseValue;
3055 export function LDKNetAddress_OnionV3_get_version(ptr: number): number {
3056 if(!isWasmInitialized) {
3057 throw new Error("initializeWasm() must be awaited first!");
3059 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_version(ptr);
3060 return nativeResponseValue;
3063 export function LDKNetAddress_OnionV3_get_port(ptr: number): number {
3064 if(!isWasmInitialized) {
3065 throw new Error("initializeWasm() must be awaited first!");
3067 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_port(ptr);
3068 return nativeResponseValue;
3070 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_a(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
3072 export function C2Tuple_PaymentHashPaymentSecretZ_get_a(owner: number): number {
3073 if(!isWasmInitialized) {
3074 throw new Error("initializeWasm() must be awaited first!");
3076 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_a(owner);
3077 return nativeResponseValue;
3079 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_b(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
3081 export function C2Tuple_PaymentHashPaymentSecretZ_get_b(owner: number): number {
3082 if(!isWasmInitialized) {
3083 throw new Error("initializeWasm() must be awaited first!");
3085 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_b(owner);
3086 return nativeResponseValue;
3088 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
3090 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner: number): number {
3091 if(!isWasmInitialized) {
3092 throw new Error("initializeWasm() must be awaited first!");
3094 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner);
3095 return nativeResponseValue;
3097 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
3099 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner: number): void {
3100 if(!isWasmInitialized) {
3101 throw new Error("initializeWasm() must be awaited first!");
3103 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner);
3104 // debug statements here
3106 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
3108 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner: number): number {
3109 if(!isWasmInitialized) {
3110 throw new Error("initializeWasm() must be awaited first!");
3112 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner);
3113 return nativeResponseValue;
3115 // struct LDKAPIError CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
3117 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner: number): number {
3118 if(!isWasmInitialized) {
3119 throw new Error("initializeWasm() must be awaited first!");
3121 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner);
3122 return nativeResponseValue;
3124 // struct LDKThirtyTwoBytes CResult_PaymentSecretNoneZ_get_ok(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
3126 export function CResult_PaymentSecretNoneZ_get_ok(owner: number): number {
3127 if(!isWasmInitialized) {
3128 throw new Error("initializeWasm() must be awaited first!");
3130 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_ok(owner);
3131 return nativeResponseValue;
3133 // void CResult_PaymentSecretNoneZ_get_err(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
3135 export function CResult_PaymentSecretNoneZ_get_err(owner: number): void {
3136 if(!isWasmInitialized) {
3137 throw new Error("initializeWasm() must be awaited first!");
3139 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_err(owner);
3140 // debug statements here
3142 // struct LDKThirtyTwoBytes CResult_PaymentSecretAPIErrorZ_get_ok(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
3144 export function CResult_PaymentSecretAPIErrorZ_get_ok(owner: number): number {
3145 if(!isWasmInitialized) {
3146 throw new Error("initializeWasm() must be awaited first!");
3148 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_ok(owner);
3149 return nativeResponseValue;
3151 // struct LDKAPIError CResult_PaymentSecretAPIErrorZ_get_err(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
3153 export function CResult_PaymentSecretAPIErrorZ_get_err(owner: number): number {
3154 if(!isWasmInitialized) {
3155 throw new Error("initializeWasm() must be awaited first!");
3157 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_err(owner);
3158 return nativeResponseValue;
3160 // struct LDKThirtyTwoBytes CResult_PaymentPreimageAPIErrorZ_get_ok(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
3162 export function CResult_PaymentPreimageAPIErrorZ_get_ok(owner: number): number {
3163 if(!isWasmInitialized) {
3164 throw new Error("initializeWasm() must be awaited first!");
3166 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_ok(owner);
3167 return nativeResponseValue;
3169 // struct LDKAPIError CResult_PaymentPreimageAPIErrorZ_get_err(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
3171 export function CResult_PaymentPreimageAPIErrorZ_get_err(owner: number): number {
3172 if(!isWasmInitialized) {
3173 throw new Error("initializeWasm() must be awaited first!");
3175 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_err(owner);
3176 return nativeResponseValue;
3178 // struct LDKCounterpartyForwardingInfo CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
3180 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner: number): number {
3181 if(!isWasmInitialized) {
3182 throw new Error("initializeWasm() must be awaited first!");
3184 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner);
3185 return nativeResponseValue;
3187 // struct LDKDecodeError CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
3189 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner: number): number {
3190 if(!isWasmInitialized) {
3191 throw new Error("initializeWasm() must be awaited first!");
3193 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner);
3194 return nativeResponseValue;
3196 // struct LDKChannelCounterparty CResult_ChannelCounterpartyDecodeErrorZ_get_ok(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
3198 export function CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner: number): number {
3199 if(!isWasmInitialized) {
3200 throw new Error("initializeWasm() must be awaited first!");
3202 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner);
3203 return nativeResponseValue;
3205 // struct LDKDecodeError CResult_ChannelCounterpartyDecodeErrorZ_get_err(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
3207 export function CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner: number): number {
3208 if(!isWasmInitialized) {
3209 throw new Error("initializeWasm() must be awaited first!");
3211 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner);
3212 return nativeResponseValue;
3214 // struct LDKChannelDetails CResult_ChannelDetailsDecodeErrorZ_get_ok(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
3216 export function CResult_ChannelDetailsDecodeErrorZ_get_ok(owner: number): number {
3217 if(!isWasmInitialized) {
3218 throw new Error("initializeWasm() must be awaited first!");
3220 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_ok(owner);
3221 return nativeResponseValue;
3223 // struct LDKDecodeError CResult_ChannelDetailsDecodeErrorZ_get_err(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
3225 export function CResult_ChannelDetailsDecodeErrorZ_get_err(owner: number): number {
3226 if(!isWasmInitialized) {
3227 throw new Error("initializeWasm() must be awaited first!");
3229 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_err(owner);
3230 return nativeResponseValue;
3232 // struct LDKPhantomRouteHints CResult_PhantomRouteHintsDecodeErrorZ_get_ok(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
3234 export function CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner: number): number {
3235 if(!isWasmInitialized) {
3236 throw new Error("initializeWasm() must be awaited first!");
3238 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner);
3239 return nativeResponseValue;
3241 // struct LDKDecodeError CResult_PhantomRouteHintsDecodeErrorZ_get_err(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
3243 export function CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner: number): number {
3244 if(!isWasmInitialized) {
3245 throw new Error("initializeWasm() must be awaited first!");
3247 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner);
3248 return nativeResponseValue;
3251 export interface LDKWatch {
3252 watch_channel (funding_txo: number, monitor: number): number;
3253 update_channel (funding_txo: number, update: number): number;
3254 release_pending_monitor_events (): number;
3258 export function LDKWatch_new(impl: LDKWatch): number {
3259 if(!isWasmInitialized) {
3260 throw new Error("initializeWasm() must be awaited first!");
3262 var new_obj_idx = js_objs.length;
3263 for (var i = 0; i < js_objs.length; i++) {
3264 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3266 js_objs[i] = new WeakRef(impl);
3267 return wasm.TS_LDKWatch_new(i);
3269 // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_watch_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor
3271 export function Watch_watch_channel(this_arg: number, funding_txo: number, monitor: number): number {
3272 if(!isWasmInitialized) {
3273 throw new Error("initializeWasm() must be awaited first!");
3275 const nativeResponseValue = wasm.TS_Watch_watch_channel(this_arg, funding_txo, monitor);
3276 return nativeResponseValue;
3278 // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_update_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update
3280 export function Watch_update_channel(this_arg: number, funding_txo: number, update: number): number {
3281 if(!isWasmInitialized) {
3282 throw new Error("initializeWasm() must be awaited first!");
3284 const nativeResponseValue = wasm.TS_Watch_update_channel(this_arg, funding_txo, update);
3285 return nativeResponseValue;
3287 // LDKCVec_MonitorEventZ Watch_release_pending_monitor_events LDKWatch *NONNULL_PTR this_arg
3289 export function Watch_release_pending_monitor_events(this_arg: number): number {
3290 if(!isWasmInitialized) {
3291 throw new Error("initializeWasm() must be awaited first!");
3293 const nativeResponseValue = wasm.TS_Watch_release_pending_monitor_events(this_arg);
3294 return nativeResponseValue;
3297 export interface LDKBroadcasterInterface {
3298 broadcast_transaction (tx: number): void;
3302 export function LDKBroadcasterInterface_new(impl: LDKBroadcasterInterface): number {
3303 if(!isWasmInitialized) {
3304 throw new Error("initializeWasm() must be awaited first!");
3306 var new_obj_idx = js_objs.length;
3307 for (var i = 0; i < js_objs.length; i++) {
3308 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3310 js_objs[i] = new WeakRef(impl);
3311 return wasm.TS_LDKBroadcasterInterface_new(i);
3313 // void BroadcasterInterface_broadcast_transaction LDKBroadcasterInterface *NONNULL_PTR this_arg, struct LDKTransaction tx
3315 export function BroadcasterInterface_broadcast_transaction(this_arg: number, tx: number): void {
3316 if(!isWasmInitialized) {
3317 throw new Error("initializeWasm() must be awaited first!");
3319 const nativeResponseValue = wasm.TS_BroadcasterInterface_broadcast_transaction(this_arg, tx);
3320 // debug statements here
3323 export interface LDKKeysInterface {
3324 get_node_secret (recipient: Recipient): number;
3325 get_destination_script (): number;
3326 get_shutdown_scriptpubkey (): number;
3327 get_channel_signer (inbound: boolean, channel_value_satoshis: bigint): number;
3328 get_secure_random_bytes (): number;
3329 read_chan_signer (reader: number): number;
3330 sign_invoice (hrp_bytes: number, invoice_data: number, receipient: Recipient): number;
3331 get_inbound_payment_key_material (): number;
3335 export function LDKKeysInterface_new(impl: LDKKeysInterface): number {
3336 if(!isWasmInitialized) {
3337 throw new Error("initializeWasm() must be awaited first!");
3339 var new_obj_idx = js_objs.length;
3340 for (var i = 0; i < js_objs.length; i++) {
3341 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3343 js_objs[i] = new WeakRef(impl);
3344 return wasm.TS_LDKKeysInterface_new(i);
3346 // LDKCResult_SecretKeyNoneZ KeysInterface_get_node_secret LDKKeysInterface *NONNULL_PTR this_arg, enum LDKRecipient recipient
3348 export function KeysInterface_get_node_secret(this_arg: number, recipient: Recipient): number {
3349 if(!isWasmInitialized) {
3350 throw new Error("initializeWasm() must be awaited first!");
3352 const nativeResponseValue = wasm.TS_KeysInterface_get_node_secret(this_arg, recipient);
3353 return nativeResponseValue;
3355 // LDKCVec_u8Z KeysInterface_get_destination_script LDKKeysInterface *NONNULL_PTR this_arg
3357 export function KeysInterface_get_destination_script(this_arg: number): number {
3358 if(!isWasmInitialized) {
3359 throw new Error("initializeWasm() must be awaited first!");
3361 const nativeResponseValue = wasm.TS_KeysInterface_get_destination_script(this_arg);
3362 return nativeResponseValue;
3364 // LDKShutdownScript KeysInterface_get_shutdown_scriptpubkey LDKKeysInterface *NONNULL_PTR this_arg
3366 export function KeysInterface_get_shutdown_scriptpubkey(this_arg: number): number {
3367 if(!isWasmInitialized) {
3368 throw new Error("initializeWasm() must be awaited first!");
3370 const nativeResponseValue = wasm.TS_KeysInterface_get_shutdown_scriptpubkey(this_arg);
3371 return nativeResponseValue;
3373 // LDKSign KeysInterface_get_channel_signer LDKKeysInterface *NONNULL_PTR this_arg, bool inbound, uint64_t channel_value_satoshis
3375 export function KeysInterface_get_channel_signer(this_arg: number, inbound: boolean, channel_value_satoshis: bigint): number {
3376 if(!isWasmInitialized) {
3377 throw new Error("initializeWasm() must be awaited first!");
3379 const nativeResponseValue = wasm.TS_KeysInterface_get_channel_signer(this_arg, inbound, channel_value_satoshis);
3380 return nativeResponseValue;
3382 // LDKThirtyTwoBytes KeysInterface_get_secure_random_bytes LDKKeysInterface *NONNULL_PTR this_arg
3384 export function KeysInterface_get_secure_random_bytes(this_arg: number): number {
3385 if(!isWasmInitialized) {
3386 throw new Error("initializeWasm() must be awaited first!");
3388 const nativeResponseValue = wasm.TS_KeysInterface_get_secure_random_bytes(this_arg);
3389 return nativeResponseValue;
3391 // LDKCResult_SignDecodeErrorZ KeysInterface_read_chan_signer LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice reader
3393 export function KeysInterface_read_chan_signer(this_arg: number, reader: number): number {
3394 if(!isWasmInitialized) {
3395 throw new Error("initializeWasm() must be awaited first!");
3397 const nativeResponseValue = wasm.TS_KeysInterface_read_chan_signer(this_arg, reader);
3398 return nativeResponseValue;
3400 // LDKCResult_RecoverableSignatureNoneZ KeysInterface_sign_invoice LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z invoice_data, enum LDKRecipient receipient
3402 export function KeysInterface_sign_invoice(this_arg: number, hrp_bytes: number, invoice_data: number, receipient: Recipient): number {
3403 if(!isWasmInitialized) {
3404 throw new Error("initializeWasm() must be awaited first!");
3406 const nativeResponseValue = wasm.TS_KeysInterface_sign_invoice(this_arg, hrp_bytes, invoice_data, receipient);
3407 return nativeResponseValue;
3409 // LDKThirtyTwoBytes KeysInterface_get_inbound_payment_key_material LDKKeysInterface *NONNULL_PTR this_arg
3411 export function KeysInterface_get_inbound_payment_key_material(this_arg: number): number {
3412 if(!isWasmInitialized) {
3413 throw new Error("initializeWasm() must be awaited first!");
3415 const nativeResponseValue = wasm.TS_KeysInterface_get_inbound_payment_key_material(this_arg);
3416 return nativeResponseValue;
3419 export interface LDKFeeEstimator {
3420 get_est_sat_per_1000_weight (confirmation_target: ConfirmationTarget): number;
3424 export function LDKFeeEstimator_new(impl: LDKFeeEstimator): number {
3425 if(!isWasmInitialized) {
3426 throw new Error("initializeWasm() must be awaited first!");
3428 var new_obj_idx = js_objs.length;
3429 for (var i = 0; i < js_objs.length; i++) {
3430 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3432 js_objs[i] = new WeakRef(impl);
3433 return wasm.TS_LDKFeeEstimator_new(i);
3435 // uint32_t FeeEstimator_get_est_sat_per_1000_weight LDKFeeEstimator *NONNULL_PTR this_arg, enum LDKConfirmationTarget confirmation_target
3437 export function FeeEstimator_get_est_sat_per_1000_weight(this_arg: number, confirmation_target: ConfirmationTarget): number {
3438 if(!isWasmInitialized) {
3439 throw new Error("initializeWasm() must be awaited first!");
3441 const nativeResponseValue = wasm.TS_FeeEstimator_get_est_sat_per_1000_weight(this_arg, confirmation_target);
3442 return nativeResponseValue;
3445 export interface LDKLogger {
3446 log (record: number): void;
3450 export function LDKLogger_new(impl: LDKLogger): number {
3451 if(!isWasmInitialized) {
3452 throw new Error("initializeWasm() must be awaited first!");
3454 var new_obj_idx = js_objs.length;
3455 for (var i = 0; i < js_objs.length; i++) {
3456 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3458 js_objs[i] = new WeakRef(impl);
3459 return wasm.TS_LDKLogger_new(i);
3461 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelManagerZ_get_a(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
3463 export function C2Tuple_BlockHashChannelManagerZ_get_a(owner: number): number {
3464 if(!isWasmInitialized) {
3465 throw new Error("initializeWasm() must be awaited first!");
3467 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_a(owner);
3468 return nativeResponseValue;
3470 // struct LDKChannelManager *C2Tuple_BlockHashChannelManagerZ_get_b(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
3472 export function C2Tuple_BlockHashChannelManagerZ_get_b(owner: number): number {
3473 if(!isWasmInitialized) {
3474 throw new Error("initializeWasm() must be awaited first!");
3476 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_b(owner);
3477 return nativeResponseValue;
3479 // struct LDKC2Tuple_BlockHashChannelManagerZ *CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
3481 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner: number): number {
3482 if(!isWasmInitialized) {
3483 throw new Error("initializeWasm() must be awaited first!");
3485 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner);
3486 return nativeResponseValue;
3488 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
3490 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner: number): number {
3491 if(!isWasmInitialized) {
3492 throw new Error("initializeWasm() must be awaited first!");
3494 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner);
3495 return nativeResponseValue;
3497 // struct LDKChannelConfig CResult_ChannelConfigDecodeErrorZ_get_ok(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
3499 export function CResult_ChannelConfigDecodeErrorZ_get_ok(owner: number): number {
3500 if(!isWasmInitialized) {
3501 throw new Error("initializeWasm() must be awaited first!");
3503 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_ok(owner);
3504 return nativeResponseValue;
3506 // struct LDKDecodeError CResult_ChannelConfigDecodeErrorZ_get_err(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
3508 export function CResult_ChannelConfigDecodeErrorZ_get_err(owner: number): number {
3509 if(!isWasmInitialized) {
3510 throw new Error("initializeWasm() must be awaited first!");
3512 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_err(owner);
3513 return nativeResponseValue;
3515 // struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
3517 export function CResult_OutPointDecodeErrorZ_get_ok(owner: number): number {
3518 if(!isWasmInitialized) {
3519 throw new Error("initializeWasm() must be awaited first!");
3521 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_ok(owner);
3522 return nativeResponseValue;
3524 // struct LDKDecodeError CResult_OutPointDecodeErrorZ_get_err(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
3526 export function CResult_OutPointDecodeErrorZ_get_err(owner: number): number {
3527 if(!isWasmInitialized) {
3528 throw new Error("initializeWasm() must be awaited first!");
3530 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_err(owner);
3531 return nativeResponseValue;
3534 export interface LDKType {
3536 debug_str (): number;
3541 export function LDKType_new(impl: LDKType): number {
3542 if(!isWasmInitialized) {
3543 throw new Error("initializeWasm() must be awaited first!");
3545 var new_obj_idx = js_objs.length;
3546 for (var i = 0; i < js_objs.length; i++) {
3547 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3549 js_objs[i] = new WeakRef(impl);
3550 return wasm.TS_LDKType_new(i);
3552 // uint16_t Type_type_id LDKType *NONNULL_PTR this_arg
3554 export function Type_type_id(this_arg: number): number {
3555 if(!isWasmInitialized) {
3556 throw new Error("initializeWasm() must be awaited first!");
3558 const nativeResponseValue = wasm.TS_Type_type_id(this_arg);
3559 return nativeResponseValue;
3561 // LDKStr Type_debug_str LDKType *NONNULL_PTR this_arg
3563 export function Type_debug_str(this_arg: number): number {
3564 if(!isWasmInitialized) {
3565 throw new Error("initializeWasm() must be awaited first!");
3567 const nativeResponseValue = wasm.TS_Type_debug_str(this_arg);
3568 return nativeResponseValue;
3570 // LDKCVec_u8Z Type_write LDKType *NONNULL_PTR this_arg
3572 export function Type_write(this_arg: number): number {
3573 if(!isWasmInitialized) {
3574 throw new Error("initializeWasm() must be awaited first!");
3576 const nativeResponseValue = wasm.TS_Type_write(this_arg);
3577 return nativeResponseValue;
3580 export class LDKCOption_TypeZ {
3581 protected constructor() {}
3584 export function LDKCOption_TypeZ_ty_from_ptr(ptr: number): number {
3585 if(!isWasmInitialized) {
3586 throw new Error("initializeWasm() must be awaited first!");
3588 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_ty_from_ptr(ptr);
3589 return nativeResponseValue;
3592 export function LDKCOption_TypeZ_Some_get_some(ptr: number): number {
3593 if(!isWasmInitialized) {
3594 throw new Error("initializeWasm() must be awaited first!");
3596 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_Some_get_some(ptr);
3597 return nativeResponseValue;
3599 // struct LDKCOption_TypeZ CResult_COption_TypeZDecodeErrorZ_get_ok(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
3601 export function CResult_COption_TypeZDecodeErrorZ_get_ok(owner: number): number {
3602 if(!isWasmInitialized) {
3603 throw new Error("initializeWasm() must be awaited first!");
3605 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_ok(owner);
3606 return nativeResponseValue;
3608 // struct LDKDecodeError CResult_COption_TypeZDecodeErrorZ_get_err(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
3610 export function CResult_COption_TypeZDecodeErrorZ_get_err(owner: number): number {
3611 if(!isWasmInitialized) {
3612 throw new Error("initializeWasm() must be awaited first!");
3614 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_err(owner);
3615 return nativeResponseValue;
3618 export class LDKPaymentError {
3619 protected constructor() {}
3622 export function LDKPaymentError_ty_from_ptr(ptr: number): number {
3623 if(!isWasmInitialized) {
3624 throw new Error("initializeWasm() must be awaited first!");
3626 const nativeResponseValue = wasm.TS_LDKPaymentError_ty_from_ptr(ptr);
3627 return nativeResponseValue;
3630 export function LDKPaymentError_Invoice_get_invoice(ptr: number): number {
3631 if(!isWasmInitialized) {
3632 throw new Error("initializeWasm() must be awaited first!");
3634 const nativeResponseValue = wasm.TS_LDKPaymentError_Invoice_get_invoice(ptr);
3635 return nativeResponseValue;
3638 export function LDKPaymentError_Routing_get_routing(ptr: number): number {
3639 if(!isWasmInitialized) {
3640 throw new Error("initializeWasm() must be awaited first!");
3642 const nativeResponseValue = wasm.TS_LDKPaymentError_Routing_get_routing(ptr);
3643 return nativeResponseValue;
3646 export function LDKPaymentError_Sending_get_sending(ptr: number): number {
3647 if(!isWasmInitialized) {
3648 throw new Error("initializeWasm() must be awaited first!");
3650 const nativeResponseValue = wasm.TS_LDKPaymentError_Sending_get_sending(ptr);
3651 return nativeResponseValue;
3653 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentErrorZ_get_ok(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
3655 export function CResult_PaymentIdPaymentErrorZ_get_ok(owner: number): number {
3656 if(!isWasmInitialized) {
3657 throw new Error("initializeWasm() must be awaited first!");
3659 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_ok(owner);
3660 return nativeResponseValue;
3662 // struct LDKPaymentError CResult_PaymentIdPaymentErrorZ_get_err(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
3664 export function CResult_PaymentIdPaymentErrorZ_get_err(owner: number): number {
3665 if(!isWasmInitialized) {
3666 throw new Error("initializeWasm() must be awaited first!");
3668 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_err(owner);
3669 return nativeResponseValue;
3671 // enum LDKSiPrefix CResult_SiPrefixNoneZ_get_ok(LDKCResult_SiPrefixNoneZ *NONNULL_PTR owner);
3673 export function CResult_SiPrefixNoneZ_get_ok(owner: number): SiPrefix {
3674 if(!isWasmInitialized) {
3675 throw new Error("initializeWasm() must be awaited first!");
3677 const nativeResponseValue = wasm.TS_CResult_SiPrefixNoneZ_get_ok(owner);
3678 return nativeResponseValue;
3680 // void CResult_SiPrefixNoneZ_get_err(LDKCResult_SiPrefixNoneZ *NONNULL_PTR owner);
3682 export function CResult_SiPrefixNoneZ_get_err(owner: number): void {
3683 if(!isWasmInitialized) {
3684 throw new Error("initializeWasm() must be awaited first!");
3686 const nativeResponseValue = wasm.TS_CResult_SiPrefixNoneZ_get_err(owner);
3687 // debug statements here
3689 // struct LDKInvoice CResult_InvoiceNoneZ_get_ok(LDKCResult_InvoiceNoneZ *NONNULL_PTR owner);
3691 export function CResult_InvoiceNoneZ_get_ok(owner: number): number {
3692 if(!isWasmInitialized) {
3693 throw new Error("initializeWasm() must be awaited first!");
3695 const nativeResponseValue = wasm.TS_CResult_InvoiceNoneZ_get_ok(owner);
3696 return nativeResponseValue;
3698 // void CResult_InvoiceNoneZ_get_err(LDKCResult_InvoiceNoneZ *NONNULL_PTR owner);
3700 export function CResult_InvoiceNoneZ_get_err(owner: number): void {
3701 if(!isWasmInitialized) {
3702 throw new Error("initializeWasm() must be awaited first!");
3704 const nativeResponseValue = wasm.TS_CResult_InvoiceNoneZ_get_err(owner);
3705 // debug statements here
3707 // struct LDKSignedRawInvoice CResult_SignedRawInvoiceNoneZ_get_ok(LDKCResult_SignedRawInvoiceNoneZ *NONNULL_PTR owner);
3709 export function CResult_SignedRawInvoiceNoneZ_get_ok(owner: number): number {
3710 if(!isWasmInitialized) {
3711 throw new Error("initializeWasm() must be awaited first!");
3713 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceNoneZ_get_ok(owner);
3714 return nativeResponseValue;
3716 // void CResult_SignedRawInvoiceNoneZ_get_err(LDKCResult_SignedRawInvoiceNoneZ *NONNULL_PTR owner);
3718 export function CResult_SignedRawInvoiceNoneZ_get_err(owner: number): void {
3719 if(!isWasmInitialized) {
3720 throw new Error("initializeWasm() must be awaited first!");
3722 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceNoneZ_get_err(owner);
3723 // debug statements here
3725 // struct LDKRawInvoice C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
3727 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner: number): number {
3728 if(!isWasmInitialized) {
3729 throw new Error("initializeWasm() must be awaited first!");
3731 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner);
3732 return nativeResponseValue;
3734 // struct LDKThirtyTwoBytes C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
3736 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner: number): number {
3737 if(!isWasmInitialized) {
3738 throw new Error("initializeWasm() must be awaited first!");
3740 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner);
3741 return nativeResponseValue;
3743 // struct LDKInvoiceSignature C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
3745 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner: number): number {
3746 if(!isWasmInitialized) {
3747 throw new Error("initializeWasm() must be awaited first!");
3749 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner);
3750 return nativeResponseValue;
3752 // struct LDKPayeePubKey CResult_PayeePubKeyErrorZ_get_ok(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
3754 export function CResult_PayeePubKeyErrorZ_get_ok(owner: number): number {
3755 if(!isWasmInitialized) {
3756 throw new Error("initializeWasm() must be awaited first!");
3758 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_ok(owner);
3759 return nativeResponseValue;
3761 // enum LDKSecp256k1Error CResult_PayeePubKeyErrorZ_get_err(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
3763 export function CResult_PayeePubKeyErrorZ_get_err(owner: number): Secp256k1Error {
3764 if(!isWasmInitialized) {
3765 throw new Error("initializeWasm() must be awaited first!");
3767 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_err(owner);
3768 return nativeResponseValue;
3770 // struct LDKPositiveTimestamp CResult_PositiveTimestampCreationErrorZ_get_ok(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
3772 export function CResult_PositiveTimestampCreationErrorZ_get_ok(owner: number): number {
3773 if(!isWasmInitialized) {
3774 throw new Error("initializeWasm() must be awaited first!");
3776 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_ok(owner);
3777 return nativeResponseValue;
3779 // enum LDKCreationError CResult_PositiveTimestampCreationErrorZ_get_err(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
3781 export function CResult_PositiveTimestampCreationErrorZ_get_err(owner: number): CreationError {
3782 if(!isWasmInitialized) {
3783 throw new Error("initializeWasm() must be awaited first!");
3785 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_err(owner);
3786 return nativeResponseValue;
3788 // void CResult_NoneSemanticErrorZ_get_ok(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
3790 export function CResult_NoneSemanticErrorZ_get_ok(owner: number): void {
3791 if(!isWasmInitialized) {
3792 throw new Error("initializeWasm() must be awaited first!");
3794 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_ok(owner);
3795 // debug statements here
3797 // enum LDKSemanticError CResult_NoneSemanticErrorZ_get_err(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
3799 export function CResult_NoneSemanticErrorZ_get_err(owner: number): SemanticError {
3800 if(!isWasmInitialized) {
3801 throw new Error("initializeWasm() must be awaited first!");
3803 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_err(owner);
3804 return nativeResponseValue;
3806 // struct LDKInvoice CResult_InvoiceSemanticErrorZ_get_ok(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
3808 export function CResult_InvoiceSemanticErrorZ_get_ok(owner: number): number {
3809 if(!isWasmInitialized) {
3810 throw new Error("initializeWasm() must be awaited first!");
3812 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_ok(owner);
3813 return nativeResponseValue;
3815 // enum LDKSemanticError CResult_InvoiceSemanticErrorZ_get_err(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
3817 export function CResult_InvoiceSemanticErrorZ_get_err(owner: number): SemanticError {
3818 if(!isWasmInitialized) {
3819 throw new Error("initializeWasm() must be awaited first!");
3821 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_err(owner);
3822 return nativeResponseValue;
3824 // struct LDKDescription CResult_DescriptionCreationErrorZ_get_ok(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
3826 export function CResult_DescriptionCreationErrorZ_get_ok(owner: number): number {
3827 if(!isWasmInitialized) {
3828 throw new Error("initializeWasm() must be awaited first!");
3830 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_ok(owner);
3831 return nativeResponseValue;
3833 // enum LDKCreationError CResult_DescriptionCreationErrorZ_get_err(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
3835 export function CResult_DescriptionCreationErrorZ_get_err(owner: number): CreationError {
3836 if(!isWasmInitialized) {
3837 throw new Error("initializeWasm() must be awaited first!");
3839 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_err(owner);
3840 return nativeResponseValue;
3842 // struct LDKPrivateRoute CResult_PrivateRouteCreationErrorZ_get_ok(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
3844 export function CResult_PrivateRouteCreationErrorZ_get_ok(owner: number): number {
3845 if(!isWasmInitialized) {
3846 throw new Error("initializeWasm() must be awaited first!");
3848 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_ok(owner);
3849 return nativeResponseValue;
3851 // enum LDKCreationError CResult_PrivateRouteCreationErrorZ_get_err(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
3853 export function CResult_PrivateRouteCreationErrorZ_get_err(owner: number): CreationError {
3854 if(!isWasmInitialized) {
3855 throw new Error("initializeWasm() must be awaited first!");
3857 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_err(owner);
3858 return nativeResponseValue;
3860 // struct LDKStr CResult_StringErrorZ_get_ok(LDKCResult_StringErrorZ *NONNULL_PTR owner);
3862 export function CResult_StringErrorZ_get_ok(owner: number): number {
3863 if(!isWasmInitialized) {
3864 throw new Error("initializeWasm() must be awaited first!");
3866 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_ok(owner);
3867 return nativeResponseValue;
3869 // enum LDKSecp256k1Error CResult_StringErrorZ_get_err(LDKCResult_StringErrorZ *NONNULL_PTR owner);
3871 export function CResult_StringErrorZ_get_err(owner: number): Secp256k1Error {
3872 if(!isWasmInitialized) {
3873 throw new Error("initializeWasm() must be awaited first!");
3875 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_err(owner);
3876 return nativeResponseValue;
3878 // struct LDKChannelMonitorUpdate CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
3880 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner: number): number {
3881 if(!isWasmInitialized) {
3882 throw new Error("initializeWasm() must be awaited first!");
3884 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner);
3885 return nativeResponseValue;
3887 // struct LDKDecodeError CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
3889 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner: number): number {
3890 if(!isWasmInitialized) {
3891 throw new Error("initializeWasm() must be awaited first!");
3893 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner);
3894 return nativeResponseValue;
3897 export class LDKCOption_MonitorEventZ {
3898 protected constructor() {}
3901 export function LDKCOption_MonitorEventZ_ty_from_ptr(ptr: number): number {
3902 if(!isWasmInitialized) {
3903 throw new Error("initializeWasm() must be awaited first!");
3905 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_ty_from_ptr(ptr);
3906 return nativeResponseValue;
3909 export function LDKCOption_MonitorEventZ_Some_get_some(ptr: number): number {
3910 if(!isWasmInitialized) {
3911 throw new Error("initializeWasm() must be awaited first!");
3913 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_Some_get_some(ptr);
3914 return nativeResponseValue;
3916 // struct LDKCOption_MonitorEventZ CResult_COption_MonitorEventZDecodeErrorZ_get_ok(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
3918 export function CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner: number): number {
3919 if(!isWasmInitialized) {
3920 throw new Error("initializeWasm() must be awaited first!");
3922 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner);
3923 return nativeResponseValue;
3925 // struct LDKDecodeError CResult_COption_MonitorEventZDecodeErrorZ_get_err(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
3927 export function CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner: number): number {
3928 if(!isWasmInitialized) {
3929 throw new Error("initializeWasm() must be awaited first!");
3931 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner);
3932 return nativeResponseValue;
3934 // struct LDKHTLCUpdate CResult_HTLCUpdateDecodeErrorZ_get_ok(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
3936 export function CResult_HTLCUpdateDecodeErrorZ_get_ok(owner: number): number {
3937 if(!isWasmInitialized) {
3938 throw new Error("initializeWasm() must be awaited first!");
3940 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_ok(owner);
3941 return nativeResponseValue;
3943 // struct LDKDecodeError CResult_HTLCUpdateDecodeErrorZ_get_err(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
3945 export function CResult_HTLCUpdateDecodeErrorZ_get_err(owner: number): number {
3946 if(!isWasmInitialized) {
3947 throw new Error("initializeWasm() must be awaited first!");
3949 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_err(owner);
3950 return nativeResponseValue;
3952 // struct LDKOutPoint C2Tuple_OutPointScriptZ_get_a(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
3954 export function C2Tuple_OutPointScriptZ_get_a(owner: number): number {
3955 if(!isWasmInitialized) {
3956 throw new Error("initializeWasm() must be awaited first!");
3958 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_a(owner);
3959 return nativeResponseValue;
3961 // struct LDKCVec_u8Z C2Tuple_OutPointScriptZ_get_b(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
3963 export function C2Tuple_OutPointScriptZ_get_b(owner: number): number {
3964 if(!isWasmInitialized) {
3965 throw new Error("initializeWasm() must be awaited first!");
3967 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_b(owner);
3968 return nativeResponseValue;
3970 // uint32_t C2Tuple_u32ScriptZ_get_a(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
3972 export function C2Tuple_u32ScriptZ_get_a(owner: number): number {
3973 if(!isWasmInitialized) {
3974 throw new Error("initializeWasm() must be awaited first!");
3976 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_a(owner);
3977 return nativeResponseValue;
3979 // struct LDKCVec_u8Z C2Tuple_u32ScriptZ_get_b(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
3981 export function C2Tuple_u32ScriptZ_get_b(owner: number): number {
3982 if(!isWasmInitialized) {
3983 throw new Error("initializeWasm() must be awaited first!");
3985 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_b(owner);
3986 return nativeResponseValue;
3988 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
3990 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_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_u32ScriptZZZ_get_a(owner);
3995 return nativeResponseValue;
3997 // struct LDKCVec_C2Tuple_u32ScriptZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
3999 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_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_u32ScriptZZZ_get_b(owner);
4004 return nativeResponseValue;
4006 // uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
4008 export function C2Tuple_u32TxOutZ_get_a(owner: number): number {
4009 if(!isWasmInitialized) {
4010 throw new Error("initializeWasm() must be awaited first!");
4012 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_a(owner);
4013 return nativeResponseValue;
4015 // struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
4017 export function C2Tuple_u32TxOutZ_get_b(owner: number): number {
4018 if(!isWasmInitialized) {
4019 throw new Error("initializeWasm() must be awaited first!");
4021 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_b(owner);
4022 return nativeResponseValue;
4024 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
4026 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner: number): number {
4027 if(!isWasmInitialized) {
4028 throw new Error("initializeWasm() must be awaited first!");
4030 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner);
4031 return nativeResponseValue;
4033 // struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
4035 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner: number): number {
4036 if(!isWasmInitialized) {
4037 throw new Error("initializeWasm() must be awaited first!");
4039 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner);
4040 return nativeResponseValue;
4043 export class LDKBalance {
4044 protected constructor() {}
4047 export function LDKBalance_ty_from_ptr(ptr: number): number {
4048 if(!isWasmInitialized) {
4049 throw new Error("initializeWasm() must be awaited first!");
4051 const nativeResponseValue = wasm.TS_LDKBalance_ty_from_ptr(ptr);
4052 return nativeResponseValue;
4055 export function LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr: number): bigint {
4056 if(!isWasmInitialized) {
4057 throw new Error("initializeWasm() must be awaited first!");
4059 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr);
4060 return nativeResponseValue;
4063 export function LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr: number): bigint {
4064 if(!isWasmInitialized) {
4065 throw new Error("initializeWasm() must be awaited first!");
4067 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr);
4068 return nativeResponseValue;
4071 export function LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr: number): number {
4072 if(!isWasmInitialized) {
4073 throw new Error("initializeWasm() must be awaited first!");
4075 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr);
4076 return nativeResponseValue;
4079 export function LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr: number): bigint {
4080 if(!isWasmInitialized) {
4081 throw new Error("initializeWasm() must be awaited first!");
4083 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr);
4084 return nativeResponseValue;
4087 export function LDKBalance_ContentiousClaimable_get_timeout_height(ptr: number): number {
4088 if(!isWasmInitialized) {
4089 throw new Error("initializeWasm() must be awaited first!");
4091 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_timeout_height(ptr);
4092 return nativeResponseValue;
4095 export function LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_amount_satoshis(ptr: number): bigint {
4096 if(!isWasmInitialized) {
4097 throw new Error("initializeWasm() must be awaited first!");
4099 const nativeResponseValue = wasm.TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_amount_satoshis(ptr);
4100 return nativeResponseValue;
4103 export function LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_height(ptr: number): number {
4104 if(!isWasmInitialized) {
4105 throw new Error("initializeWasm() must be awaited first!");
4107 const nativeResponseValue = wasm.TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_height(ptr);
4108 return nativeResponseValue;
4110 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelMonitorZ_get_a(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
4112 export function C2Tuple_BlockHashChannelMonitorZ_get_a(owner: number): number {
4113 if(!isWasmInitialized) {
4114 throw new Error("initializeWasm() must be awaited first!");
4116 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_a(owner);
4117 return nativeResponseValue;
4119 // struct LDKChannelMonitor C2Tuple_BlockHashChannelMonitorZ_get_b(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
4121 export function C2Tuple_BlockHashChannelMonitorZ_get_b(owner: number): number {
4122 if(!isWasmInitialized) {
4123 throw new Error("initializeWasm() must be awaited first!");
4125 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_b(owner);
4126 return nativeResponseValue;
4128 // struct LDKC2Tuple_BlockHashChannelMonitorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
4130 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner: number): number {
4131 if(!isWasmInitialized) {
4132 throw new Error("initializeWasm() must be awaited first!");
4134 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner);
4135 return nativeResponseValue;
4137 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
4139 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner: number): number {
4140 if(!isWasmInitialized) {
4141 throw new Error("initializeWasm() must be awaited first!");
4143 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner);
4144 return nativeResponseValue;
4146 // void CResult_NoneLightningErrorZ_get_ok(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
4148 export function CResult_NoneLightningErrorZ_get_ok(owner: number): void {
4149 if(!isWasmInitialized) {
4150 throw new Error("initializeWasm() must be awaited first!");
4152 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_ok(owner);
4153 // debug statements here
4155 // struct LDKLightningError CResult_NoneLightningErrorZ_get_err(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
4157 export function CResult_NoneLightningErrorZ_get_err(owner: number): number {
4158 if(!isWasmInitialized) {
4159 throw new Error("initializeWasm() must be awaited first!");
4161 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_err(owner);
4162 return nativeResponseValue;
4164 // struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
4166 export function C2Tuple_PublicKeyTypeZ_get_a(owner: number): number {
4167 if(!isWasmInitialized) {
4168 throw new Error("initializeWasm() must be awaited first!");
4170 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_a(owner);
4171 return nativeResponseValue;
4173 // struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
4175 export function C2Tuple_PublicKeyTypeZ_get_b(owner: number): number {
4176 if(!isWasmInitialized) {
4177 throw new Error("initializeWasm() must be awaited first!");
4179 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_b(owner);
4180 return nativeResponseValue;
4182 // bool CResult_boolLightningErrorZ_get_ok(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
4184 export function CResult_boolLightningErrorZ_get_ok(owner: number): boolean {
4185 if(!isWasmInitialized) {
4186 throw new Error("initializeWasm() must be awaited first!");
4188 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_ok(owner);
4189 return nativeResponseValue;
4191 // struct LDKLightningError CResult_boolLightningErrorZ_get_err(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
4193 export function CResult_boolLightningErrorZ_get_err(owner: number): number {
4194 if(!isWasmInitialized) {
4195 throw new Error("initializeWasm() must be awaited first!");
4197 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_err(owner);
4198 return nativeResponseValue;
4200 // struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
4202 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner: number): number {
4203 if(!isWasmInitialized) {
4204 throw new Error("initializeWasm() must be awaited first!");
4206 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner);
4207 return nativeResponseValue;
4209 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
4211 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner: number): number {
4212 if(!isWasmInitialized) {
4213 throw new Error("initializeWasm() must be awaited first!");
4215 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner);
4216 return nativeResponseValue;
4218 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
4220 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner: number): number {
4221 if(!isWasmInitialized) {
4222 throw new Error("initializeWasm() must be awaited first!");
4224 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner);
4225 return nativeResponseValue;
4227 // struct LDKCVec_u8Z CResult_CVec_u8ZPeerHandleErrorZ_get_ok(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
4229 export function CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner: number): number {
4230 if(!isWasmInitialized) {
4231 throw new Error("initializeWasm() must be awaited first!");
4233 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner);
4234 return nativeResponseValue;
4236 // struct LDKPeerHandleError CResult_CVec_u8ZPeerHandleErrorZ_get_err(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
4238 export function CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner: number): number {
4239 if(!isWasmInitialized) {
4240 throw new Error("initializeWasm() must be awaited first!");
4242 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner);
4243 return nativeResponseValue;
4245 // void CResult_NonePeerHandleErrorZ_get_ok(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
4247 export function CResult_NonePeerHandleErrorZ_get_ok(owner: number): void {
4248 if(!isWasmInitialized) {
4249 throw new Error("initializeWasm() must be awaited first!");
4251 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_ok(owner);
4252 // debug statements here
4254 // struct LDKPeerHandleError CResult_NonePeerHandleErrorZ_get_err(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
4256 export function CResult_NonePeerHandleErrorZ_get_err(owner: number): number {
4257 if(!isWasmInitialized) {
4258 throw new Error("initializeWasm() must be awaited first!");
4260 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_err(owner);
4261 return nativeResponseValue;
4263 // bool CResult_boolPeerHandleErrorZ_get_ok(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
4265 export function CResult_boolPeerHandleErrorZ_get_ok(owner: number): boolean {
4266 if(!isWasmInitialized) {
4267 throw new Error("initializeWasm() must be awaited first!");
4269 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_ok(owner);
4270 return nativeResponseValue;
4272 // struct LDKPeerHandleError CResult_boolPeerHandleErrorZ_get_err(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
4274 export function CResult_boolPeerHandleErrorZ_get_err(owner: number): number {
4275 if(!isWasmInitialized) {
4276 throw new Error("initializeWasm() must be awaited first!");
4278 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_err(owner);
4279 return nativeResponseValue;
4281 // struct LDKNodeId CResult_NodeIdDecodeErrorZ_get_ok(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
4283 export function CResult_NodeIdDecodeErrorZ_get_ok(owner: number): number {
4284 if(!isWasmInitialized) {
4285 throw new Error("initializeWasm() must be awaited first!");
4287 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_ok(owner);
4288 return nativeResponseValue;
4290 // struct LDKDecodeError CResult_NodeIdDecodeErrorZ_get_err(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
4292 export function CResult_NodeIdDecodeErrorZ_get_err(owner: number): number {
4293 if(!isWasmInitialized) {
4294 throw new Error("initializeWasm() must be awaited first!");
4296 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_err(owner);
4297 return nativeResponseValue;
4299 // struct LDKCOption_NetworkUpdateZ CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
4301 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner: number): number {
4302 if(!isWasmInitialized) {
4303 throw new Error("initializeWasm() must be awaited first!");
4305 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner);
4306 return nativeResponseValue;
4308 // struct LDKDecodeError CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
4310 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner: number): number {
4311 if(!isWasmInitialized) {
4312 throw new Error("initializeWasm() must be awaited first!");
4314 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner);
4315 return nativeResponseValue;
4318 export interface LDKAccess {
4319 get_utxo (genesis_hash: number, short_channel_id: bigint): number;
4323 export function LDKAccess_new(impl: LDKAccess): number {
4324 if(!isWasmInitialized) {
4325 throw new Error("initializeWasm() must be awaited first!");
4327 var new_obj_idx = js_objs.length;
4328 for (var i = 0; i < js_objs.length; i++) {
4329 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4331 js_objs[i] = new WeakRef(impl);
4332 return wasm.TS_LDKAccess_new(i);
4334 // LDKCResult_TxOutAccessErrorZ Access_get_utxo LDKAccess *NONNULL_PTR this_arg, const uint8_t (*genesis_hash)[32], uint64_t short_channel_id
4336 export function Access_get_utxo(this_arg: number, genesis_hash: number, short_channel_id: bigint): number {
4337 if(!isWasmInitialized) {
4338 throw new Error("initializeWasm() must be awaited first!");
4340 const nativeResponseValue = wasm.TS_Access_get_utxo(this_arg, genesis_hash, short_channel_id);
4341 return nativeResponseValue;
4344 export class LDKCOption_AccessZ {
4345 protected constructor() {}
4348 export function LDKCOption_AccessZ_ty_from_ptr(ptr: number): number {
4349 if(!isWasmInitialized) {
4350 throw new Error("initializeWasm() must be awaited first!");
4352 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_ty_from_ptr(ptr);
4353 return nativeResponseValue;
4356 export function LDKCOption_AccessZ_Some_get_some(ptr: number): number {
4357 if(!isWasmInitialized) {
4358 throw new Error("initializeWasm() must be awaited first!");
4360 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_Some_get_some(ptr);
4361 return nativeResponseValue;
4363 // struct LDKChannelUpdateInfo CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
4365 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner: number): number {
4366 if(!isWasmInitialized) {
4367 throw new Error("initializeWasm() must be awaited first!");
4369 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner);
4370 return nativeResponseValue;
4372 // struct LDKDecodeError CResult_ChannelUpdateInfoDecodeErrorZ_get_err(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
4374 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner: number): number {
4375 if(!isWasmInitialized) {
4376 throw new Error("initializeWasm() must be awaited first!");
4378 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner);
4379 return nativeResponseValue;
4381 // struct LDKChannelInfo CResult_ChannelInfoDecodeErrorZ_get_ok(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
4383 export function CResult_ChannelInfoDecodeErrorZ_get_ok(owner: number): number {
4384 if(!isWasmInitialized) {
4385 throw new Error("initializeWasm() must be awaited first!");
4387 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_ok(owner);
4388 return nativeResponseValue;
4390 // struct LDKDecodeError CResult_ChannelInfoDecodeErrorZ_get_err(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
4392 export function CResult_ChannelInfoDecodeErrorZ_get_err(owner: number): number {
4393 if(!isWasmInitialized) {
4394 throw new Error("initializeWasm() must be awaited first!");
4396 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_err(owner);
4397 return nativeResponseValue;
4399 // struct LDKRoutingFees CResult_RoutingFeesDecodeErrorZ_get_ok(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
4401 export function CResult_RoutingFeesDecodeErrorZ_get_ok(owner: number): number {
4402 if(!isWasmInitialized) {
4403 throw new Error("initializeWasm() must be awaited first!");
4405 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_ok(owner);
4406 return nativeResponseValue;
4408 // struct LDKDecodeError CResult_RoutingFeesDecodeErrorZ_get_err(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
4410 export function CResult_RoutingFeesDecodeErrorZ_get_err(owner: number): number {
4411 if(!isWasmInitialized) {
4412 throw new Error("initializeWasm() must be awaited first!");
4414 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_err(owner);
4415 return nativeResponseValue;
4417 // struct LDKNodeAnnouncementInfo CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
4419 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner: number): number {
4420 if(!isWasmInitialized) {
4421 throw new Error("initializeWasm() must be awaited first!");
4423 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner);
4424 return nativeResponseValue;
4426 // struct LDKDecodeError CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
4428 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner: number): number {
4429 if(!isWasmInitialized) {
4430 throw new Error("initializeWasm() must be awaited first!");
4432 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner);
4433 return nativeResponseValue;
4435 // struct LDKNodeInfo CResult_NodeInfoDecodeErrorZ_get_ok(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
4437 export function CResult_NodeInfoDecodeErrorZ_get_ok(owner: number): number {
4438 if(!isWasmInitialized) {
4439 throw new Error("initializeWasm() must be awaited first!");
4441 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_ok(owner);
4442 return nativeResponseValue;
4444 // struct LDKDecodeError CResult_NodeInfoDecodeErrorZ_get_err(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
4446 export function CResult_NodeInfoDecodeErrorZ_get_err(owner: number): number {
4447 if(!isWasmInitialized) {
4448 throw new Error("initializeWasm() must be awaited first!");
4450 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_err(owner);
4451 return nativeResponseValue;
4453 // struct LDKNetworkGraph CResult_NetworkGraphDecodeErrorZ_get_ok(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
4455 export function CResult_NetworkGraphDecodeErrorZ_get_ok(owner: number): number {
4456 if(!isWasmInitialized) {
4457 throw new Error("initializeWasm() must be awaited first!");
4459 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_ok(owner);
4460 return nativeResponseValue;
4462 // struct LDKDecodeError CResult_NetworkGraphDecodeErrorZ_get_err(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
4464 export function CResult_NetworkGraphDecodeErrorZ_get_err(owner: number): number {
4465 if(!isWasmInitialized) {
4466 throw new Error("initializeWasm() must be awaited first!");
4468 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_err(owner);
4469 return nativeResponseValue;
4472 export class LDKCOption_CVec_NetAddressZZ {
4473 protected constructor() {}
4476 export function LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr: number): number {
4477 if(!isWasmInitialized) {
4478 throw new Error("initializeWasm() must be awaited first!");
4480 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr);
4481 return nativeResponseValue;
4484 export function LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr: number): number {
4485 if(!isWasmInitialized) {
4486 throw new Error("initializeWasm() must be awaited first!");
4488 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr);
4489 return nativeResponseValue;
4491 // struct LDKNetAddress CResult_NetAddressDecodeErrorZ_get_ok(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
4493 export function CResult_NetAddressDecodeErrorZ_get_ok(owner: number): number {
4494 if(!isWasmInitialized) {
4495 throw new Error("initializeWasm() must be awaited first!");
4497 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_ok(owner);
4498 return nativeResponseValue;
4500 // struct LDKDecodeError CResult_NetAddressDecodeErrorZ_get_err(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
4502 export function CResult_NetAddressDecodeErrorZ_get_err(owner: number): number {
4503 if(!isWasmInitialized) {
4504 throw new Error("initializeWasm() must be awaited first!");
4506 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_err(owner);
4507 return nativeResponseValue;
4509 // struct LDKAcceptChannel CResult_AcceptChannelDecodeErrorZ_get_ok(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
4511 export function CResult_AcceptChannelDecodeErrorZ_get_ok(owner: number): number {
4512 if(!isWasmInitialized) {
4513 throw new Error("initializeWasm() must be awaited first!");
4515 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_ok(owner);
4516 return nativeResponseValue;
4518 // struct LDKDecodeError CResult_AcceptChannelDecodeErrorZ_get_err(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
4520 export function CResult_AcceptChannelDecodeErrorZ_get_err(owner: number): number {
4521 if(!isWasmInitialized) {
4522 throw new Error("initializeWasm() must be awaited first!");
4524 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_err(owner);
4525 return nativeResponseValue;
4527 // struct LDKAnnouncementSignatures CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
4529 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner: number): number {
4530 if(!isWasmInitialized) {
4531 throw new Error("initializeWasm() must be awaited first!");
4533 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner);
4534 return nativeResponseValue;
4536 // struct LDKDecodeError CResult_AnnouncementSignaturesDecodeErrorZ_get_err(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
4538 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner: number): number {
4539 if(!isWasmInitialized) {
4540 throw new Error("initializeWasm() must be awaited first!");
4542 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner);
4543 return nativeResponseValue;
4545 // struct LDKChannelReestablish CResult_ChannelReestablishDecodeErrorZ_get_ok(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
4547 export function CResult_ChannelReestablishDecodeErrorZ_get_ok(owner: number): number {
4548 if(!isWasmInitialized) {
4549 throw new Error("initializeWasm() must be awaited first!");
4551 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_ok(owner);
4552 return nativeResponseValue;
4554 // struct LDKDecodeError CResult_ChannelReestablishDecodeErrorZ_get_err(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
4556 export function CResult_ChannelReestablishDecodeErrorZ_get_err(owner: number): number {
4557 if(!isWasmInitialized) {
4558 throw new Error("initializeWasm() must be awaited first!");
4560 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_err(owner);
4561 return nativeResponseValue;
4563 // struct LDKClosingSigned CResult_ClosingSignedDecodeErrorZ_get_ok(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
4565 export function CResult_ClosingSignedDecodeErrorZ_get_ok(owner: number): number {
4566 if(!isWasmInitialized) {
4567 throw new Error("initializeWasm() must be awaited first!");
4569 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_ok(owner);
4570 return nativeResponseValue;
4572 // struct LDKDecodeError CResult_ClosingSignedDecodeErrorZ_get_err(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
4574 export function CResult_ClosingSignedDecodeErrorZ_get_err(owner: number): number {
4575 if(!isWasmInitialized) {
4576 throw new Error("initializeWasm() must be awaited first!");
4578 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_err(owner);
4579 return nativeResponseValue;
4581 // struct LDKClosingSignedFeeRange CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
4583 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner: number): number {
4584 if(!isWasmInitialized) {
4585 throw new Error("initializeWasm() must be awaited first!");
4587 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner);
4588 return nativeResponseValue;
4590 // struct LDKDecodeError CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
4592 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner: number): number {
4593 if(!isWasmInitialized) {
4594 throw new Error("initializeWasm() must be awaited first!");
4596 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner);
4597 return nativeResponseValue;
4599 // struct LDKCommitmentSigned CResult_CommitmentSignedDecodeErrorZ_get_ok(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
4601 export function CResult_CommitmentSignedDecodeErrorZ_get_ok(owner: number): number {
4602 if(!isWasmInitialized) {
4603 throw new Error("initializeWasm() must be awaited first!");
4605 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_ok(owner);
4606 return nativeResponseValue;
4608 // struct LDKDecodeError CResult_CommitmentSignedDecodeErrorZ_get_err(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
4610 export function CResult_CommitmentSignedDecodeErrorZ_get_err(owner: number): number {
4611 if(!isWasmInitialized) {
4612 throw new Error("initializeWasm() must be awaited first!");
4614 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_err(owner);
4615 return nativeResponseValue;
4617 // struct LDKFundingCreated CResult_FundingCreatedDecodeErrorZ_get_ok(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
4619 export function CResult_FundingCreatedDecodeErrorZ_get_ok(owner: number): number {
4620 if(!isWasmInitialized) {
4621 throw new Error("initializeWasm() must be awaited first!");
4623 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_ok(owner);
4624 return nativeResponseValue;
4626 // struct LDKDecodeError CResult_FundingCreatedDecodeErrorZ_get_err(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
4628 export function CResult_FundingCreatedDecodeErrorZ_get_err(owner: number): number {
4629 if(!isWasmInitialized) {
4630 throw new Error("initializeWasm() must be awaited first!");
4632 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_err(owner);
4633 return nativeResponseValue;
4635 // struct LDKFundingSigned CResult_FundingSignedDecodeErrorZ_get_ok(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
4637 export function CResult_FundingSignedDecodeErrorZ_get_ok(owner: number): number {
4638 if(!isWasmInitialized) {
4639 throw new Error("initializeWasm() must be awaited first!");
4641 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_ok(owner);
4642 return nativeResponseValue;
4644 // struct LDKDecodeError CResult_FundingSignedDecodeErrorZ_get_err(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
4646 export function CResult_FundingSignedDecodeErrorZ_get_err(owner: number): number {
4647 if(!isWasmInitialized) {
4648 throw new Error("initializeWasm() must be awaited first!");
4650 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_err(owner);
4651 return nativeResponseValue;
4653 // struct LDKFundingLocked CResult_FundingLockedDecodeErrorZ_get_ok(LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR owner);
4655 export function CResult_FundingLockedDecodeErrorZ_get_ok(owner: number): number {
4656 if(!isWasmInitialized) {
4657 throw new Error("initializeWasm() must be awaited first!");
4659 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_get_ok(owner);
4660 return nativeResponseValue;
4662 // struct LDKDecodeError CResult_FundingLockedDecodeErrorZ_get_err(LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR owner);
4664 export function CResult_FundingLockedDecodeErrorZ_get_err(owner: number): number {
4665 if(!isWasmInitialized) {
4666 throw new Error("initializeWasm() must be awaited first!");
4668 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_get_err(owner);
4669 return nativeResponseValue;
4671 // struct LDKInit CResult_InitDecodeErrorZ_get_ok(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
4673 export function CResult_InitDecodeErrorZ_get_ok(owner: number): number {
4674 if(!isWasmInitialized) {
4675 throw new Error("initializeWasm() must be awaited first!");
4677 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_ok(owner);
4678 return nativeResponseValue;
4680 // struct LDKDecodeError CResult_InitDecodeErrorZ_get_err(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
4682 export function CResult_InitDecodeErrorZ_get_err(owner: number): number {
4683 if(!isWasmInitialized) {
4684 throw new Error("initializeWasm() must be awaited first!");
4686 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_err(owner);
4687 return nativeResponseValue;
4689 // struct LDKOpenChannel CResult_OpenChannelDecodeErrorZ_get_ok(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
4691 export function CResult_OpenChannelDecodeErrorZ_get_ok(owner: number): number {
4692 if(!isWasmInitialized) {
4693 throw new Error("initializeWasm() must be awaited first!");
4695 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_ok(owner);
4696 return nativeResponseValue;
4698 // struct LDKDecodeError CResult_OpenChannelDecodeErrorZ_get_err(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
4700 export function CResult_OpenChannelDecodeErrorZ_get_err(owner: number): number {
4701 if(!isWasmInitialized) {
4702 throw new Error("initializeWasm() must be awaited first!");
4704 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_err(owner);
4705 return nativeResponseValue;
4707 // struct LDKRevokeAndACK CResult_RevokeAndACKDecodeErrorZ_get_ok(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
4709 export function CResult_RevokeAndACKDecodeErrorZ_get_ok(owner: number): number {
4710 if(!isWasmInitialized) {
4711 throw new Error("initializeWasm() must be awaited first!");
4713 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_ok(owner);
4714 return nativeResponseValue;
4716 // struct LDKDecodeError CResult_RevokeAndACKDecodeErrorZ_get_err(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
4718 export function CResult_RevokeAndACKDecodeErrorZ_get_err(owner: number): number {
4719 if(!isWasmInitialized) {
4720 throw new Error("initializeWasm() must be awaited first!");
4722 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_err(owner);
4723 return nativeResponseValue;
4725 // struct LDKShutdown CResult_ShutdownDecodeErrorZ_get_ok(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
4727 export function CResult_ShutdownDecodeErrorZ_get_ok(owner: number): number {
4728 if(!isWasmInitialized) {
4729 throw new Error("initializeWasm() must be awaited first!");
4731 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_ok(owner);
4732 return nativeResponseValue;
4734 // struct LDKDecodeError CResult_ShutdownDecodeErrorZ_get_err(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
4736 export function CResult_ShutdownDecodeErrorZ_get_err(owner: number): number {
4737 if(!isWasmInitialized) {
4738 throw new Error("initializeWasm() must be awaited first!");
4740 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_err(owner);
4741 return nativeResponseValue;
4743 // struct LDKUpdateFailHTLC CResult_UpdateFailHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
4745 export function CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner: number): number {
4746 if(!isWasmInitialized) {
4747 throw new Error("initializeWasm() must be awaited first!");
4749 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner);
4750 return nativeResponseValue;
4752 // struct LDKDecodeError CResult_UpdateFailHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
4754 export function CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner: number): number {
4755 if(!isWasmInitialized) {
4756 throw new Error("initializeWasm() must be awaited first!");
4758 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner);
4759 return nativeResponseValue;
4761 // struct LDKUpdateFailMalformedHTLC CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
4763 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner: number): number {
4764 if(!isWasmInitialized) {
4765 throw new Error("initializeWasm() must be awaited first!");
4767 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner);
4768 return nativeResponseValue;
4770 // struct LDKDecodeError CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
4772 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner: number): number {
4773 if(!isWasmInitialized) {
4774 throw new Error("initializeWasm() must be awaited first!");
4776 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner);
4777 return nativeResponseValue;
4779 // struct LDKUpdateFee CResult_UpdateFeeDecodeErrorZ_get_ok(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
4781 export function CResult_UpdateFeeDecodeErrorZ_get_ok(owner: number): number {
4782 if(!isWasmInitialized) {
4783 throw new Error("initializeWasm() must be awaited first!");
4785 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_ok(owner);
4786 return nativeResponseValue;
4788 // struct LDKDecodeError CResult_UpdateFeeDecodeErrorZ_get_err(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
4790 export function CResult_UpdateFeeDecodeErrorZ_get_err(owner: number): number {
4791 if(!isWasmInitialized) {
4792 throw new Error("initializeWasm() must be awaited first!");
4794 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_err(owner);
4795 return nativeResponseValue;
4797 // struct LDKUpdateFulfillHTLC CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
4799 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner: number): number {
4800 if(!isWasmInitialized) {
4801 throw new Error("initializeWasm() must be awaited first!");
4803 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner);
4804 return nativeResponseValue;
4806 // struct LDKDecodeError CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
4808 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner: number): number {
4809 if(!isWasmInitialized) {
4810 throw new Error("initializeWasm() must be awaited first!");
4812 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner);
4813 return nativeResponseValue;
4815 // struct LDKUpdateAddHTLC CResult_UpdateAddHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
4817 export function CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner: number): number {
4818 if(!isWasmInitialized) {
4819 throw new Error("initializeWasm() must be awaited first!");
4821 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner);
4822 return nativeResponseValue;
4824 // struct LDKDecodeError CResult_UpdateAddHTLCDecodeErrorZ_get_err(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
4826 export function CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner: number): number {
4827 if(!isWasmInitialized) {
4828 throw new Error("initializeWasm() must be awaited first!");
4830 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner);
4831 return nativeResponseValue;
4833 // struct LDKPing CResult_PingDecodeErrorZ_get_ok(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
4835 export function CResult_PingDecodeErrorZ_get_ok(owner: number): number {
4836 if(!isWasmInitialized) {
4837 throw new Error("initializeWasm() must be awaited first!");
4839 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_ok(owner);
4840 return nativeResponseValue;
4842 // struct LDKDecodeError CResult_PingDecodeErrorZ_get_err(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
4844 export function CResult_PingDecodeErrorZ_get_err(owner: number): number {
4845 if(!isWasmInitialized) {
4846 throw new Error("initializeWasm() must be awaited first!");
4848 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_err(owner);
4849 return nativeResponseValue;
4851 // struct LDKPong CResult_PongDecodeErrorZ_get_ok(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
4853 export function CResult_PongDecodeErrorZ_get_ok(owner: number): number {
4854 if(!isWasmInitialized) {
4855 throw new Error("initializeWasm() must be awaited first!");
4857 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_ok(owner);
4858 return nativeResponseValue;
4860 // struct LDKDecodeError CResult_PongDecodeErrorZ_get_err(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
4862 export function CResult_PongDecodeErrorZ_get_err(owner: number): number {
4863 if(!isWasmInitialized) {
4864 throw new Error("initializeWasm() must be awaited first!");
4866 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_err(owner);
4867 return nativeResponseValue;
4869 // struct LDKUnsignedChannelAnnouncement CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
4871 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner: number): number {
4872 if(!isWasmInitialized) {
4873 throw new Error("initializeWasm() must be awaited first!");
4875 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner);
4876 return nativeResponseValue;
4878 // struct LDKDecodeError CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
4880 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner: number): number {
4881 if(!isWasmInitialized) {
4882 throw new Error("initializeWasm() must be awaited first!");
4884 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner);
4885 return nativeResponseValue;
4887 // struct LDKChannelAnnouncement CResult_ChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
4889 export function CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner: number): number {
4890 if(!isWasmInitialized) {
4891 throw new Error("initializeWasm() must be awaited first!");
4893 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner);
4894 return nativeResponseValue;
4896 // struct LDKDecodeError CResult_ChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
4898 export function CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner: number): number {
4899 if(!isWasmInitialized) {
4900 throw new Error("initializeWasm() must be awaited first!");
4902 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner);
4903 return nativeResponseValue;
4905 // struct LDKUnsignedChannelUpdate CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
4907 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner: number): number {
4908 if(!isWasmInitialized) {
4909 throw new Error("initializeWasm() must be awaited first!");
4911 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner);
4912 return nativeResponseValue;
4914 // struct LDKDecodeError CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
4916 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner: number): number {
4917 if(!isWasmInitialized) {
4918 throw new Error("initializeWasm() must be awaited first!");
4920 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner);
4921 return nativeResponseValue;
4923 // struct LDKChannelUpdate CResult_ChannelUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
4925 export function CResult_ChannelUpdateDecodeErrorZ_get_ok(owner: number): number {
4926 if(!isWasmInitialized) {
4927 throw new Error("initializeWasm() must be awaited first!");
4929 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_ok(owner);
4930 return nativeResponseValue;
4932 // struct LDKDecodeError CResult_ChannelUpdateDecodeErrorZ_get_err(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
4934 export function CResult_ChannelUpdateDecodeErrorZ_get_err(owner: number): number {
4935 if(!isWasmInitialized) {
4936 throw new Error("initializeWasm() must be awaited first!");
4938 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_err(owner);
4939 return nativeResponseValue;
4941 // struct LDKErrorMessage CResult_ErrorMessageDecodeErrorZ_get_ok(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
4943 export function CResult_ErrorMessageDecodeErrorZ_get_ok(owner: number): number {
4944 if(!isWasmInitialized) {
4945 throw new Error("initializeWasm() must be awaited first!");
4947 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_ok(owner);
4948 return nativeResponseValue;
4950 // struct LDKDecodeError CResult_ErrorMessageDecodeErrorZ_get_err(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
4952 export function CResult_ErrorMessageDecodeErrorZ_get_err(owner: number): number {
4953 if(!isWasmInitialized) {
4954 throw new Error("initializeWasm() must be awaited first!");
4956 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_err(owner);
4957 return nativeResponseValue;
4959 // struct LDKWarningMessage CResult_WarningMessageDecodeErrorZ_get_ok(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
4961 export function CResult_WarningMessageDecodeErrorZ_get_ok(owner: number): number {
4962 if(!isWasmInitialized) {
4963 throw new Error("initializeWasm() must be awaited first!");
4965 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_ok(owner);
4966 return nativeResponseValue;
4968 // struct LDKDecodeError CResult_WarningMessageDecodeErrorZ_get_err(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
4970 export function CResult_WarningMessageDecodeErrorZ_get_err(owner: number): number {
4971 if(!isWasmInitialized) {
4972 throw new Error("initializeWasm() must be awaited first!");
4974 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_err(owner);
4975 return nativeResponseValue;
4977 // struct LDKUnsignedNodeAnnouncement CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
4979 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner: number): number {
4980 if(!isWasmInitialized) {
4981 throw new Error("initializeWasm() must be awaited first!");
4983 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner);
4984 return nativeResponseValue;
4986 // struct LDKDecodeError CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
4988 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner: number): number {
4989 if(!isWasmInitialized) {
4990 throw new Error("initializeWasm() must be awaited first!");
4992 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner);
4993 return nativeResponseValue;
4995 // struct LDKNodeAnnouncement CResult_NodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
4997 export function CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner: number): number {
4998 if(!isWasmInitialized) {
4999 throw new Error("initializeWasm() must be awaited first!");
5001 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner);
5002 return nativeResponseValue;
5004 // struct LDKDecodeError CResult_NodeAnnouncementDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5006 export function CResult_NodeAnnouncementDecodeErrorZ_get_err(owner: number): number {
5007 if(!isWasmInitialized) {
5008 throw new Error("initializeWasm() must be awaited first!");
5010 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_err(owner);
5011 return nativeResponseValue;
5013 // struct LDKQueryShortChannelIds CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
5015 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner: number): number {
5016 if(!isWasmInitialized) {
5017 throw new Error("initializeWasm() must be awaited first!");
5019 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner);
5020 return nativeResponseValue;
5022 // struct LDKDecodeError CResult_QueryShortChannelIdsDecodeErrorZ_get_err(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
5024 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner: number): number {
5025 if(!isWasmInitialized) {
5026 throw new Error("initializeWasm() must be awaited first!");
5028 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner);
5029 return nativeResponseValue;
5031 // struct LDKReplyShortChannelIdsEnd CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
5033 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner: number): number {
5034 if(!isWasmInitialized) {
5035 throw new Error("initializeWasm() must be awaited first!");
5037 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner);
5038 return nativeResponseValue;
5040 // struct LDKDecodeError CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
5042 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner: number): number {
5043 if(!isWasmInitialized) {
5044 throw new Error("initializeWasm() must be awaited first!");
5046 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner);
5047 return nativeResponseValue;
5049 // struct LDKQueryChannelRange CResult_QueryChannelRangeDecodeErrorZ_get_ok(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5051 export function CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner: number): number {
5052 if(!isWasmInitialized) {
5053 throw new Error("initializeWasm() must be awaited first!");
5055 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner);
5056 return nativeResponseValue;
5058 // struct LDKDecodeError CResult_QueryChannelRangeDecodeErrorZ_get_err(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5060 export function CResult_QueryChannelRangeDecodeErrorZ_get_err(owner: number): number {
5061 if(!isWasmInitialized) {
5062 throw new Error("initializeWasm() must be awaited first!");
5064 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_err(owner);
5065 return nativeResponseValue;
5067 // struct LDKReplyChannelRange CResult_ReplyChannelRangeDecodeErrorZ_get_ok(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5069 export function CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner: number): number {
5070 if(!isWasmInitialized) {
5071 throw new Error("initializeWasm() must be awaited first!");
5073 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner);
5074 return nativeResponseValue;
5076 // struct LDKDecodeError CResult_ReplyChannelRangeDecodeErrorZ_get_err(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5078 export function CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner: number): number {
5079 if(!isWasmInitialized) {
5080 throw new Error("initializeWasm() must be awaited first!");
5082 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner);
5083 return nativeResponseValue;
5085 // struct LDKGossipTimestampFilter CResult_GossipTimestampFilterDecodeErrorZ_get_ok(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
5087 export function CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner: number): number {
5088 if(!isWasmInitialized) {
5089 throw new Error("initializeWasm() must be awaited first!");
5091 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner);
5092 return nativeResponseValue;
5094 // struct LDKDecodeError CResult_GossipTimestampFilterDecodeErrorZ_get_err(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
5096 export function CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner: number): number {
5097 if(!isWasmInitialized) {
5098 throw new Error("initializeWasm() must be awaited first!");
5100 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner);
5101 return nativeResponseValue;
5104 export class LDKSignOrCreationError {
5105 protected constructor() {}
5108 export function LDKSignOrCreationError_ty_from_ptr(ptr: number): number {
5109 if(!isWasmInitialized) {
5110 throw new Error("initializeWasm() must be awaited first!");
5112 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_ty_from_ptr(ptr);
5113 return nativeResponseValue;
5116 export function LDKSignOrCreationError_CreationError_get_creation_error(ptr: number): CreationError {
5117 if(!isWasmInitialized) {
5118 throw new Error("initializeWasm() must be awaited first!");
5120 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_CreationError_get_creation_error(ptr);
5121 return nativeResponseValue;
5123 // struct LDKInvoice CResult_InvoiceSignOrCreationErrorZ_get_ok(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
5125 export function CResult_InvoiceSignOrCreationErrorZ_get_ok(owner: number): number {
5126 if(!isWasmInitialized) {
5127 throw new Error("initializeWasm() must be awaited first!");
5129 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_ok(owner);
5130 return nativeResponseValue;
5132 // struct LDKSignOrCreationError CResult_InvoiceSignOrCreationErrorZ_get_err(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
5134 export function CResult_InvoiceSignOrCreationErrorZ_get_err(owner: number): number {
5135 if(!isWasmInitialized) {
5136 throw new Error("initializeWasm() must be awaited first!");
5138 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_err(owner);
5139 return nativeResponseValue;
5142 export interface LDKFilter {
5143 register_tx (txid: number, script_pubkey: number): void;
5144 register_output (output: number): number;
5148 export function LDKFilter_new(impl: LDKFilter): number {
5149 if(!isWasmInitialized) {
5150 throw new Error("initializeWasm() must be awaited first!");
5152 var new_obj_idx = js_objs.length;
5153 for (var i = 0; i < js_objs.length; i++) {
5154 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5156 js_objs[i] = new WeakRef(impl);
5157 return wasm.TS_LDKFilter_new(i);
5159 // void Filter_register_tx LDKFilter *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
5161 export function Filter_register_tx(this_arg: number, txid: number, script_pubkey: number): void {
5162 if(!isWasmInitialized) {
5163 throw new Error("initializeWasm() must be awaited first!");
5165 const nativeResponseValue = wasm.TS_Filter_register_tx(this_arg, txid, script_pubkey);
5166 // debug statements here
5168 // LDKCOption_C2Tuple_usizeTransactionZZ Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
5170 export function Filter_register_output(this_arg: number, output: number): number {
5171 if(!isWasmInitialized) {
5172 throw new Error("initializeWasm() must be awaited first!");
5174 const nativeResponseValue = wasm.TS_Filter_register_output(this_arg, output);
5175 return nativeResponseValue;
5178 export class LDKCOption_FilterZ {
5179 protected constructor() {}
5182 export function LDKCOption_FilterZ_ty_from_ptr(ptr: number): number {
5183 if(!isWasmInitialized) {
5184 throw new Error("initializeWasm() must be awaited first!");
5186 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_ty_from_ptr(ptr);
5187 return nativeResponseValue;
5190 export function LDKCOption_FilterZ_Some_get_some(ptr: number): number {
5191 if(!isWasmInitialized) {
5192 throw new Error("initializeWasm() must be awaited first!");
5194 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_Some_get_some(ptr);
5195 return nativeResponseValue;
5197 // struct LDKLockedChannelMonitor *CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
5199 export function CResult_LockedChannelMonitorNoneZ_get_ok(owner: number): number {
5200 if(!isWasmInitialized) {
5201 throw new Error("initializeWasm() must be awaited first!");
5203 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_ok(owner);
5204 return nativeResponseValue;
5206 // void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
5208 export function CResult_LockedChannelMonitorNoneZ_get_err(owner: number): void {
5209 if(!isWasmInitialized) {
5210 throw new Error("initializeWasm() must be awaited first!");
5212 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_err(owner);
5213 // debug statements here
5216 export interface LDKMessageSendEventsProvider {
5217 get_and_clear_pending_msg_events (): number;
5221 export function LDKMessageSendEventsProvider_new(impl: LDKMessageSendEventsProvider): number {
5222 if(!isWasmInitialized) {
5223 throw new Error("initializeWasm() must be awaited first!");
5225 var new_obj_idx = js_objs.length;
5226 for (var i = 0; i < js_objs.length; i++) {
5227 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5229 js_objs[i] = new WeakRef(impl);
5230 return wasm.TS_LDKMessageSendEventsProvider_new(i);
5232 // LDKCVec_MessageSendEventZ MessageSendEventsProvider_get_and_clear_pending_msg_events LDKMessageSendEventsProvider *NONNULL_PTR this_arg
5234 export function MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg: number): number {
5235 if(!isWasmInitialized) {
5236 throw new Error("initializeWasm() must be awaited first!");
5238 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg);
5239 return nativeResponseValue;
5242 export interface LDKEventHandler {
5243 handle_event (event: number): void;
5247 export function LDKEventHandler_new(impl: LDKEventHandler): number {
5248 if(!isWasmInitialized) {
5249 throw new Error("initializeWasm() must be awaited first!");
5251 var new_obj_idx = js_objs.length;
5252 for (var i = 0; i < js_objs.length; i++) {
5253 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5255 js_objs[i] = new WeakRef(impl);
5256 return wasm.TS_LDKEventHandler_new(i);
5258 // void EventHandler_handle_event LDKEventHandler *NONNULL_PTR this_arg, const struct LDKEvent *NONNULL_PTR event
5260 export function EventHandler_handle_event(this_arg: number, event: number): void {
5261 if(!isWasmInitialized) {
5262 throw new Error("initializeWasm() must be awaited first!");
5264 const nativeResponseValue = wasm.TS_EventHandler_handle_event(this_arg, event);
5265 // debug statements here
5268 export interface LDKEventsProvider {
5269 process_pending_events (handler: number): void;
5273 export function LDKEventsProvider_new(impl: LDKEventsProvider): number {
5274 if(!isWasmInitialized) {
5275 throw new Error("initializeWasm() must be awaited first!");
5277 var new_obj_idx = js_objs.length;
5278 for (var i = 0; i < js_objs.length; i++) {
5279 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5281 js_objs[i] = new WeakRef(impl);
5282 return wasm.TS_LDKEventsProvider_new(i);
5284 // void EventsProvider_process_pending_events LDKEventsProvider *NONNULL_PTR this_arg, struct LDKEventHandler handler
5286 export function EventsProvider_process_pending_events(this_arg: number, handler: number): void {
5287 if(!isWasmInitialized) {
5288 throw new Error("initializeWasm() must be awaited first!");
5290 const nativeResponseValue = wasm.TS_EventsProvider_process_pending_events(this_arg, handler);
5291 // debug statements here
5294 export interface LDKListen {
5295 block_connected (block: number, height: number): void;
5296 block_disconnected (header: number, height: number): void;
5300 export function LDKListen_new(impl: LDKListen): number {
5301 if(!isWasmInitialized) {
5302 throw new Error("initializeWasm() must be awaited first!");
5304 var new_obj_idx = js_objs.length;
5305 for (var i = 0; i < js_objs.length; i++) {
5306 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5308 js_objs[i] = new WeakRef(impl);
5309 return wasm.TS_LDKListen_new(i);
5311 // void Listen_block_connected LDKListen *NONNULL_PTR this_arg, struct LDKu8slice block, uint32_t height
5313 export function Listen_block_connected(this_arg: number, block: number, height: number): void {
5314 if(!isWasmInitialized) {
5315 throw new Error("initializeWasm() must be awaited first!");
5317 const nativeResponseValue = wasm.TS_Listen_block_connected(this_arg, block, height);
5318 // debug statements here
5320 // void Listen_block_disconnected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
5322 export function Listen_block_disconnected(this_arg: number, header: number, height: number): void {
5323 if(!isWasmInitialized) {
5324 throw new Error("initializeWasm() must be awaited first!");
5326 const nativeResponseValue = wasm.TS_Listen_block_disconnected(this_arg, header, height);
5327 // debug statements here
5330 export interface LDKConfirm {
5331 transactions_confirmed (header: number, txdata: number, height: number): void;
5332 transaction_unconfirmed (txid: number): void;
5333 best_block_updated (header: number, height: number): void;
5334 get_relevant_txids (): number;
5338 export function LDKConfirm_new(impl: LDKConfirm): number {
5339 if(!isWasmInitialized) {
5340 throw new Error("initializeWasm() must be awaited first!");
5342 var new_obj_idx = js_objs.length;
5343 for (var i = 0; i < js_objs.length; i++) {
5344 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5346 js_objs[i] = new WeakRef(impl);
5347 return wasm.TS_LDKConfirm_new(i);
5349 // void Confirm_transactions_confirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
5351 export function Confirm_transactions_confirmed(this_arg: number, header: number, txdata: number, height: number): void {
5352 if(!isWasmInitialized) {
5353 throw new Error("initializeWasm() must be awaited first!");
5355 const nativeResponseValue = wasm.TS_Confirm_transactions_confirmed(this_arg, header, txdata, height);
5356 // debug statements here
5358 // void Confirm_transaction_unconfirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*txid)[32]
5360 export function Confirm_transaction_unconfirmed(this_arg: number, txid: number): void {
5361 if(!isWasmInitialized) {
5362 throw new Error("initializeWasm() must be awaited first!");
5364 const nativeResponseValue = wasm.TS_Confirm_transaction_unconfirmed(this_arg, txid);
5365 // debug statements here
5367 // void Confirm_best_block_updated LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
5369 export function Confirm_best_block_updated(this_arg: number, header: number, height: number): void {
5370 if(!isWasmInitialized) {
5371 throw new Error("initializeWasm() must be awaited first!");
5373 const nativeResponseValue = wasm.TS_Confirm_best_block_updated(this_arg, header, height);
5374 // debug statements here
5376 // LDKCVec_TxidZ Confirm_get_relevant_txids LDKConfirm *NONNULL_PTR this_arg
5378 export function Confirm_get_relevant_txids(this_arg: number): number {
5379 if(!isWasmInitialized) {
5380 throw new Error("initializeWasm() must be awaited first!");
5382 const nativeResponseValue = wasm.TS_Confirm_get_relevant_txids(this_arg);
5383 return nativeResponseValue;
5386 export interface LDKPersist {
5387 persist_new_channel (channel_id: number, data: number, update_id: number): number;
5388 update_persisted_channel (channel_id: number, update: number, data: number, update_id: number): number;
5392 export function LDKPersist_new(impl: LDKPersist): number {
5393 if(!isWasmInitialized) {
5394 throw new Error("initializeWasm() must be awaited first!");
5396 var new_obj_idx = js_objs.length;
5397 for (var i = 0; i < js_objs.length; i++) {
5398 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5400 js_objs[i] = new WeakRef(impl);
5401 return wasm.TS_LDKPersist_new(i);
5403 // 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
5405 export function Persist_persist_new_channel(this_arg: number, channel_id: number, data: number, update_id: number): number {
5406 if(!isWasmInitialized) {
5407 throw new Error("initializeWasm() must be awaited first!");
5409 const nativeResponseValue = wasm.TS_Persist_persist_new_channel(this_arg, channel_id, data, update_id);
5410 return nativeResponseValue;
5412 // 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
5414 export function Persist_update_persisted_channel(this_arg: number, channel_id: number, update: number, data: number, update_id: number): number {
5415 if(!isWasmInitialized) {
5416 throw new Error("initializeWasm() must be awaited first!");
5418 const nativeResponseValue = wasm.TS_Persist_update_persisted_channel(this_arg, channel_id, update, data, update_id);
5419 return nativeResponseValue;
5422 export interface LDKChannelMessageHandler {
5423 handle_open_channel (their_node_id: number, their_features: number, msg: number): void;
5424 handle_accept_channel (their_node_id: number, their_features: number, msg: number): void;
5425 handle_funding_created (their_node_id: number, msg: number): void;
5426 handle_funding_signed (their_node_id: number, msg: number): void;
5427 handle_funding_locked (their_node_id: number, msg: number): void;
5428 handle_shutdown (their_node_id: number, their_features: number, msg: number): void;
5429 handle_closing_signed (their_node_id: number, msg: number): void;
5430 handle_update_add_htlc (their_node_id: number, msg: number): void;
5431 handle_update_fulfill_htlc (their_node_id: number, msg: number): void;
5432 handle_update_fail_htlc (their_node_id: number, msg: number): void;
5433 handle_update_fail_malformed_htlc (their_node_id: number, msg: number): void;
5434 handle_commitment_signed (their_node_id: number, msg: number): void;
5435 handle_revoke_and_ack (their_node_id: number, msg: number): void;
5436 handle_update_fee (their_node_id: number, msg: number): void;
5437 handle_announcement_signatures (their_node_id: number, msg: number): void;
5438 peer_disconnected (their_node_id: number, no_connection_possible: boolean): void;
5439 peer_connected (their_node_id: number, msg: number): void;
5440 handle_channel_reestablish (their_node_id: number, msg: number): void;
5441 handle_channel_update (their_node_id: number, msg: number): void;
5442 handle_error (their_node_id: number, msg: number): void;
5446 export function LDKChannelMessageHandler_new(impl: LDKChannelMessageHandler, MessageSendEventsProvider: LDKMessageSendEventsProvider): number {
5447 if(!isWasmInitialized) {
5448 throw new Error("initializeWasm() must be awaited first!");
5450 var new_obj_idx = js_objs.length;
5451 for (var i = 0; i < js_objs.length; i++) {
5452 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5454 js_objs[i] = new WeakRef(impl);
5455 return wasm.TS_LDKChannelMessageHandler_new(i);
5457 // 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
5459 export function ChannelMessageHandler_handle_open_channel(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
5460 if(!isWasmInitialized) {
5461 throw new Error("initializeWasm() must be awaited first!");
5463 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_open_channel(this_arg, their_node_id, their_features, msg);
5464 // debug statements here
5466 // 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
5468 export function ChannelMessageHandler_handle_accept_channel(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_accept_channel(this_arg, their_node_id, their_features, msg);
5473 // debug statements here
5475 // void ChannelMessageHandler_handle_funding_created LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg
5477 export function ChannelMessageHandler_handle_funding_created(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_funding_created(this_arg, their_node_id, msg);
5482 // debug statements here
5484 // void ChannelMessageHandler_handle_funding_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg
5486 export function ChannelMessageHandler_handle_funding_signed(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_funding_signed(this_arg, their_node_id, msg);
5491 // debug statements here
5493 // void ChannelMessageHandler_handle_funding_locked LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingLocked *NONNULL_PTR msg
5495 export function ChannelMessageHandler_handle_funding_locked(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_funding_locked(this_arg, their_node_id, msg);
5500 // debug statements here
5502 // 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
5504 export function ChannelMessageHandler_handle_shutdown(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
5505 if(!isWasmInitialized) {
5506 throw new Error("initializeWasm() must be awaited first!");
5508 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_shutdown(this_arg, their_node_id, their_features, msg);
5509 // debug statements here
5511 // void ChannelMessageHandler_handle_closing_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg
5513 export function ChannelMessageHandler_handle_closing_signed(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_closing_signed(this_arg, their_node_id, msg);
5518 // debug statements here
5520 // void ChannelMessageHandler_handle_update_add_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg
5522 export function ChannelMessageHandler_handle_update_add_htlc(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_update_add_htlc(this_arg, their_node_id, msg);
5527 // debug statements here
5529 // void ChannelMessageHandler_handle_update_fulfill_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg
5531 export function ChannelMessageHandler_handle_update_fulfill_htlc(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_update_fulfill_htlc(this_arg, their_node_id, msg);
5536 // debug statements here
5538 // void ChannelMessageHandler_handle_update_fail_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg
5540 export function ChannelMessageHandler_handle_update_fail_htlc(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_fail_htlc(this_arg, their_node_id, msg);
5545 // debug statements here
5547 // void ChannelMessageHandler_handle_update_fail_malformed_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg
5549 export function ChannelMessageHandler_handle_update_fail_malformed_htlc(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_update_fail_malformed_htlc(this_arg, their_node_id, msg);
5554 // debug statements here
5556 // void ChannelMessageHandler_handle_commitment_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg
5558 export function ChannelMessageHandler_handle_commitment_signed(this_arg: number, their_node_id: number, msg: number): void {
5559 if(!isWasmInitialized) {
5560 throw new Error("initializeWasm() must be awaited first!");
5562 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_commitment_signed(this_arg, their_node_id, msg);
5563 // debug statements here
5565 // void ChannelMessageHandler_handle_revoke_and_ack LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg
5567 export function ChannelMessageHandler_handle_revoke_and_ack(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_handle_revoke_and_ack(this_arg, their_node_id, msg);
5572 // debug statements here
5574 // void ChannelMessageHandler_handle_update_fee LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg
5576 export function ChannelMessageHandler_handle_update_fee(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_update_fee(this_arg, their_node_id, msg);
5581 // debug statements here
5583 // void ChannelMessageHandler_handle_announcement_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg
5585 export function ChannelMessageHandler_handle_announcement_signatures(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_announcement_signatures(this_arg, their_node_id, msg);
5590 // debug statements here
5592 // void ChannelMessageHandler_peer_disconnected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, bool no_connection_possible
5594 export function ChannelMessageHandler_peer_disconnected(this_arg: number, their_node_id: number, no_connection_possible: boolean): void {
5595 if(!isWasmInitialized) {
5596 throw new Error("initializeWasm() must be awaited first!");
5598 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_disconnected(this_arg, their_node_id, no_connection_possible);
5599 // debug statements here
5601 // void ChannelMessageHandler_peer_connected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg
5603 export function ChannelMessageHandler_peer_connected(this_arg: number, their_node_id: number, msg: number): void {
5604 if(!isWasmInitialized) {
5605 throw new Error("initializeWasm() must be awaited first!");
5607 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_connected(this_arg, their_node_id, msg);
5608 // debug statements here
5610 // void ChannelMessageHandler_handle_channel_reestablish LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg
5612 export function ChannelMessageHandler_handle_channel_reestablish(this_arg: number, their_node_id: number, msg: number): void {
5613 if(!isWasmInitialized) {
5614 throw new Error("initializeWasm() must be awaited first!");
5616 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_reestablish(this_arg, their_node_id, msg);
5617 // debug statements here
5619 // void ChannelMessageHandler_handle_channel_update LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg
5621 export function ChannelMessageHandler_handle_channel_update(this_arg: number, their_node_id: number, msg: number): void {
5622 if(!isWasmInitialized) {
5623 throw new Error("initializeWasm() must be awaited first!");
5625 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_update(this_arg, their_node_id, msg);
5626 // debug statements here
5628 // void ChannelMessageHandler_handle_error LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
5630 export function ChannelMessageHandler_handle_error(this_arg: number, their_node_id: number, msg: number): void {
5631 if(!isWasmInitialized) {
5632 throw new Error("initializeWasm() must be awaited first!");
5634 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_error(this_arg, their_node_id, msg);
5635 // debug statements here
5638 export interface LDKRoutingMessageHandler {
5639 handle_node_announcement (msg: number): number;
5640 handle_channel_announcement (msg: number): number;
5641 handle_channel_update (msg: number): number;
5642 get_next_channel_announcements (starting_point: bigint, batch_amount: number): number;
5643 get_next_node_announcements (starting_point: number, batch_amount: number): number;
5644 sync_routing_table (their_node_id: number, init: number): void;
5645 handle_reply_channel_range (their_node_id: number, msg: number): number;
5646 handle_reply_short_channel_ids_end (their_node_id: number, msg: number): number;
5647 handle_query_channel_range (their_node_id: number, msg: number): number;
5648 handle_query_short_channel_ids (their_node_id: number, msg: number): number;
5652 export function LDKRoutingMessageHandler_new(impl: LDKRoutingMessageHandler, MessageSendEventsProvider: LDKMessageSendEventsProvider): number {
5653 if(!isWasmInitialized) {
5654 throw new Error("initializeWasm() must be awaited first!");
5656 var new_obj_idx = js_objs.length;
5657 for (var i = 0; i < js_objs.length; i++) {
5658 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5660 js_objs[i] = new WeakRef(impl);
5661 return wasm.TS_LDKRoutingMessageHandler_new(i);
5663 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg
5665 export function RoutingMessageHandler_handle_node_announcement(this_arg: number, msg: number): number {
5666 if(!isWasmInitialized) {
5667 throw new Error("initializeWasm() must be awaited first!");
5669 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_node_announcement(this_arg, msg);
5670 return nativeResponseValue;
5672 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg
5674 export function RoutingMessageHandler_handle_channel_announcement(this_arg: number, msg: number): number {
5675 if(!isWasmInitialized) {
5676 throw new Error("initializeWasm() must be awaited first!");
5678 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_announcement(this_arg, msg);
5679 return nativeResponseValue;
5681 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_update LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg
5683 export function RoutingMessageHandler_handle_channel_update(this_arg: number, msg: number): number {
5684 if(!isWasmInitialized) {
5685 throw new Error("initializeWasm() must be awaited first!");
5687 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_update(this_arg, msg);
5688 return nativeResponseValue;
5690 // LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler_get_next_channel_announcements LDKRoutingMessageHandler *NONNULL_PTR this_arg, uint64_t starting_point, uint8_t batch_amount
5692 export function RoutingMessageHandler_get_next_channel_announcements(this_arg: number, starting_point: bigint, batch_amount: number): number {
5693 if(!isWasmInitialized) {
5694 throw new Error("initializeWasm() must be awaited first!");
5696 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_channel_announcements(this_arg, starting_point, batch_amount);
5697 return nativeResponseValue;
5699 // LDKCVec_NodeAnnouncementZ RoutingMessageHandler_get_next_node_announcements LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey starting_point, uint8_t batch_amount
5701 export function RoutingMessageHandler_get_next_node_announcements(this_arg: number, starting_point: number, batch_amount: number): number {
5702 if(!isWasmInitialized) {
5703 throw new Error("initializeWasm() must be awaited first!");
5705 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_node_announcements(this_arg, starting_point, batch_amount);
5706 return nativeResponseValue;
5708 // void RoutingMessageHandler_sync_routing_table LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init
5710 export function RoutingMessageHandler_sync_routing_table(this_arg: number, their_node_id: number, init: number): void {
5711 if(!isWasmInitialized) {
5712 throw new Error("initializeWasm() must be awaited first!");
5714 const nativeResponseValue = wasm.TS_RoutingMessageHandler_sync_routing_table(this_arg, their_node_id, init);
5715 // debug statements here
5717 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg
5719 export function RoutingMessageHandler_handle_reply_channel_range(this_arg: number, their_node_id: number, msg: number): number {
5720 if(!isWasmInitialized) {
5721 throw new Error("initializeWasm() must be awaited first!");
5723 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_channel_range(this_arg, their_node_id, msg);
5724 return nativeResponseValue;
5726 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_short_channel_ids_end LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg
5728 export function RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg: number, their_node_id: number, msg: number): number {
5729 if(!isWasmInitialized) {
5730 throw new Error("initializeWasm() must be awaited first!");
5732 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg, their_node_id, msg);
5733 return nativeResponseValue;
5735 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg
5737 export function RoutingMessageHandler_handle_query_channel_range(this_arg: number, their_node_id: number, msg: number): number {
5738 if(!isWasmInitialized) {
5739 throw new Error("initializeWasm() must be awaited first!");
5741 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_channel_range(this_arg, their_node_id, msg);
5742 return nativeResponseValue;
5744 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_short_channel_ids LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg
5746 export function RoutingMessageHandler_handle_query_short_channel_ids(this_arg: number, their_node_id: number, msg: number): number {
5747 if(!isWasmInitialized) {
5748 throw new Error("initializeWasm() must be awaited first!");
5750 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_short_channel_ids(this_arg, their_node_id, msg);
5751 return nativeResponseValue;
5754 export interface LDKCustomMessageReader {
5755 read (message_type: number, buffer: number): number;
5759 export function LDKCustomMessageReader_new(impl: LDKCustomMessageReader): number {
5760 if(!isWasmInitialized) {
5761 throw new Error("initializeWasm() must be awaited first!");
5763 var new_obj_idx = js_objs.length;
5764 for (var i = 0; i < js_objs.length; i++) {
5765 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5767 js_objs[i] = new WeakRef(impl);
5768 return wasm.TS_LDKCustomMessageReader_new(i);
5770 // LDKCResult_COption_TypeZDecodeErrorZ CustomMessageReader_read LDKCustomMessageReader *NONNULL_PTR this_arg, uint16_t message_type, struct LDKu8slice buffer
5772 export function CustomMessageReader_read(this_arg: number, message_type: number, buffer: number): number {
5773 if(!isWasmInitialized) {
5774 throw new Error("initializeWasm() must be awaited first!");
5776 const nativeResponseValue = wasm.TS_CustomMessageReader_read(this_arg, message_type, buffer);
5777 return nativeResponseValue;
5780 export interface LDKCustomMessageHandler {
5781 handle_custom_message (msg: number, sender_node_id: number): number;
5782 get_and_clear_pending_msg (): number;
5786 export function LDKCustomMessageHandler_new(impl: LDKCustomMessageHandler, CustomMessageReader: LDKCustomMessageReader): number {
5787 if(!isWasmInitialized) {
5788 throw new Error("initializeWasm() must be awaited first!");
5790 var new_obj_idx = js_objs.length;
5791 for (var i = 0; i < js_objs.length; i++) {
5792 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5794 js_objs[i] = new WeakRef(impl);
5795 return wasm.TS_LDKCustomMessageHandler_new(i);
5797 // LDKCResult_NoneLightningErrorZ CustomMessageHandler_handle_custom_message LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKType msg, struct LDKPublicKey sender_node_id
5799 export function CustomMessageHandler_handle_custom_message(this_arg: number, msg: number, sender_node_id: number): number {
5800 if(!isWasmInitialized) {
5801 throw new Error("initializeWasm() must be awaited first!");
5803 const nativeResponseValue = wasm.TS_CustomMessageHandler_handle_custom_message(this_arg, msg, sender_node_id);
5804 return nativeResponseValue;
5806 // LDKCVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler_get_and_clear_pending_msg LDKCustomMessageHandler *NONNULL_PTR this_arg
5808 export function CustomMessageHandler_get_and_clear_pending_msg(this_arg: number): number {
5809 if(!isWasmInitialized) {
5810 throw new Error("initializeWasm() must be awaited first!");
5812 const nativeResponseValue = wasm.TS_CustomMessageHandler_get_and_clear_pending_msg(this_arg);
5813 return nativeResponseValue;
5816 export interface LDKSocketDescriptor {
5817 send_data (data: number, resume_read: boolean): number;
5818 disconnect_socket (): void;
5819 eq (other_arg: number): boolean;
5824 export function LDKSocketDescriptor_new(impl: LDKSocketDescriptor): number {
5825 if(!isWasmInitialized) {
5826 throw new Error("initializeWasm() must be awaited first!");
5828 var new_obj_idx = js_objs.length;
5829 for (var i = 0; i < js_objs.length; i++) {
5830 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5832 js_objs[i] = new WeakRef(impl);
5833 return wasm.TS_LDKSocketDescriptor_new(i);
5835 // uintptr_t SocketDescriptor_send_data LDKSocketDescriptor *NONNULL_PTR this_arg, struct LDKu8slice data, bool resume_read
5837 export function SocketDescriptor_send_data(this_arg: number, data: number, resume_read: boolean): number {
5838 if(!isWasmInitialized) {
5839 throw new Error("initializeWasm() must be awaited first!");
5841 const nativeResponseValue = wasm.TS_SocketDescriptor_send_data(this_arg, data, resume_read);
5842 return nativeResponseValue;
5844 // void SocketDescriptor_disconnect_socket LDKSocketDescriptor *NONNULL_PTR this_arg
5846 export function SocketDescriptor_disconnect_socket(this_arg: number): void {
5847 if(!isWasmInitialized) {
5848 throw new Error("initializeWasm() must be awaited first!");
5850 const nativeResponseValue = wasm.TS_SocketDescriptor_disconnect_socket(this_arg);
5851 // debug statements here
5853 // uint64_t SocketDescriptor_hash LDKSocketDescriptor *NONNULL_PTR this_arg
5855 export function SocketDescriptor_hash(this_arg: number): bigint {
5856 if(!isWasmInitialized) {
5857 throw new Error("initializeWasm() must be awaited first!");
5859 const nativeResponseValue = wasm.TS_SocketDescriptor_hash(this_arg);
5860 return nativeResponseValue;
5863 export class LDKEffectiveCapacity {
5864 protected constructor() {}
5867 export function LDKEffectiveCapacity_ty_from_ptr(ptr: number): number {
5868 if(!isWasmInitialized) {
5869 throw new Error("initializeWasm() must be awaited first!");
5871 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ty_from_ptr(ptr);
5872 return nativeResponseValue;
5875 export function LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr: number): bigint {
5876 if(!isWasmInitialized) {
5877 throw new Error("initializeWasm() must be awaited first!");
5879 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr);
5880 return nativeResponseValue;
5883 export function LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr: number): bigint {
5884 if(!isWasmInitialized) {
5885 throw new Error("initializeWasm() must be awaited first!");
5887 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr);
5888 return nativeResponseValue;
5891 export function LDKEffectiveCapacity_Total_get_capacity_msat(ptr: number): bigint {
5892 if(!isWasmInitialized) {
5893 throw new Error("initializeWasm() must be awaited first!");
5895 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_capacity_msat(ptr);
5896 return nativeResponseValue;
5899 export interface LDKScore {
5900 channel_penalty_msat (short_channel_id: bigint, send_amt_msat: bigint, capacity_msat: bigint, source: number, target: number): bigint;
5901 payment_path_failed (path: number, short_channel_id: bigint): void;
5902 payment_path_successful (path: number): void;
5907 export function LDKScore_new(impl: LDKScore): number {
5908 if(!isWasmInitialized) {
5909 throw new Error("initializeWasm() must be awaited first!");
5911 var new_obj_idx = js_objs.length;
5912 for (var i = 0; i < js_objs.length; i++) {
5913 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5915 js_objs[i] = new WeakRef(impl);
5916 return wasm.TS_LDKScore_new(i);
5918 // 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
5920 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 {
5921 if(!isWasmInitialized) {
5922 throw new Error("initializeWasm() must be awaited first!");
5924 const nativeResponseValue = wasm.TS_Score_channel_penalty_msat(this_arg, short_channel_id, send_amt_msat, capacity_msat, source, target);
5925 return nativeResponseValue;
5927 // void Score_payment_path_failed LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
5929 export function Score_payment_path_failed(this_arg: number, path: number, short_channel_id: bigint): void {
5930 if(!isWasmInitialized) {
5931 throw new Error("initializeWasm() must be awaited first!");
5933 const nativeResponseValue = wasm.TS_Score_payment_path_failed(this_arg, path, short_channel_id);
5934 // debug statements here
5936 // void Score_payment_path_successful LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
5938 export function Score_payment_path_successful(this_arg: number, path: number): void {
5939 if(!isWasmInitialized) {
5940 throw new Error("initializeWasm() must be awaited first!");
5942 const nativeResponseValue = wasm.TS_Score_payment_path_successful(this_arg, path);
5943 // debug statements here
5945 // LDKCVec_u8Z Score_write LDKScore *NONNULL_PTR this_arg
5947 export function Score_write(this_arg: number): number {
5948 if(!isWasmInitialized) {
5949 throw new Error("initializeWasm() must be awaited first!");
5951 const nativeResponseValue = wasm.TS_Score_write(this_arg);
5952 return nativeResponseValue;
5955 export interface LDKLockableScore {
5960 export function LDKLockableScore_new(impl: LDKLockableScore): number {
5961 if(!isWasmInitialized) {
5962 throw new Error("initializeWasm() must be awaited first!");
5964 var new_obj_idx = js_objs.length;
5965 for (var i = 0; i < js_objs.length; i++) {
5966 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5968 js_objs[i] = new WeakRef(impl);
5969 return wasm.TS_LDKLockableScore_new(i);
5971 // LDKScore LockableScore_lock LDKLockableScore *NONNULL_PTR this_arg
5973 export function LockableScore_lock(this_arg: number): number {
5974 if(!isWasmInitialized) {
5975 throw new Error("initializeWasm() must be awaited first!");
5977 const nativeResponseValue = wasm.TS_LockableScore_lock(this_arg);
5978 return nativeResponseValue;
5981 export class LDKFallback {
5982 protected constructor() {}
5985 export function LDKFallback_ty_from_ptr(ptr: number): number {
5986 if(!isWasmInitialized) {
5987 throw new Error("initializeWasm() must be awaited first!");
5989 const nativeResponseValue = wasm.TS_LDKFallback_ty_from_ptr(ptr);
5990 return nativeResponseValue;
5993 export function LDKFallback_SegWitProgram_get_version(ptr: number): number {
5994 if(!isWasmInitialized) {
5995 throw new Error("initializeWasm() must be awaited first!");
5997 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_version(ptr);
5998 return nativeResponseValue;
6001 export function LDKFallback_SegWitProgram_get_program(ptr: number): number {
6002 if(!isWasmInitialized) {
6003 throw new Error("initializeWasm() must be awaited first!");
6005 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_program(ptr);
6006 return nativeResponseValue;
6009 export function LDKFallback_PubKeyHash_get_pub_key_hash(ptr: number): number {
6010 if(!isWasmInitialized) {
6011 throw new Error("initializeWasm() must be awaited first!");
6013 const nativeResponseValue = wasm.TS_LDKFallback_PubKeyHash_get_pub_key_hash(ptr);
6014 return nativeResponseValue;
6017 export function LDKFallback_ScriptHash_get_script_hash(ptr: number): number {
6018 if(!isWasmInitialized) {
6019 throw new Error("initializeWasm() must be awaited first!");
6021 const nativeResponseValue = wasm.TS_LDKFallback_ScriptHash_get_script_hash(ptr);
6022 return nativeResponseValue;
6025 export interface LDKPayer {
6027 first_hops (): number;
6028 send_payment (route: number, payment_hash: number, payment_secret: number): number;
6029 send_spontaneous_payment (route: number, payment_preimage: number): number;
6030 retry_payment (route: number, payment_id: number): number;
6031 abandon_payment (payment_id: number): void;
6035 export function LDKPayer_new(impl: LDKPayer): number {
6036 if(!isWasmInitialized) {
6037 throw new Error("initializeWasm() must be awaited first!");
6039 var new_obj_idx = js_objs.length;
6040 for (var i = 0; i < js_objs.length; i++) {
6041 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6043 js_objs[i] = new WeakRef(impl);
6044 return wasm.TS_LDKPayer_new(i);
6046 // LDKPublicKey Payer_node_id LDKPayer *NONNULL_PTR this_arg
6048 export function Payer_node_id(this_arg: number): number {
6049 if(!isWasmInitialized) {
6050 throw new Error("initializeWasm() must be awaited first!");
6052 const nativeResponseValue = wasm.TS_Payer_node_id(this_arg);
6053 return nativeResponseValue;
6055 // LDKCVec_ChannelDetailsZ Payer_first_hops LDKPayer *NONNULL_PTR this_arg
6057 export function Payer_first_hops(this_arg: number): number {
6058 if(!isWasmInitialized) {
6059 throw new Error("initializeWasm() must be awaited first!");
6061 const nativeResponseValue = wasm.TS_Payer_first_hops(this_arg);
6062 return nativeResponseValue;
6064 // LDKCResult_PaymentIdPaymentSendFailureZ Payer_send_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret
6066 export function Payer_send_payment(this_arg: number, route: number, payment_hash: number, payment_secret: number): number {
6067 if(!isWasmInitialized) {
6068 throw new Error("initializeWasm() must be awaited first!");
6070 const nativeResponseValue = wasm.TS_Payer_send_payment(this_arg, route, payment_hash, payment_secret);
6071 return nativeResponseValue;
6073 // LDKCResult_PaymentIdPaymentSendFailureZ Payer_send_spontaneous_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage
6075 export function Payer_send_spontaneous_payment(this_arg: number, route: number, payment_preimage: number): number {
6076 if(!isWasmInitialized) {
6077 throw new Error("initializeWasm() must be awaited first!");
6079 const nativeResponseValue = wasm.TS_Payer_send_spontaneous_payment(this_arg, route, payment_preimage);
6080 return nativeResponseValue;
6082 // LDKCResult_NonePaymentSendFailureZ Payer_retry_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_id
6084 export function Payer_retry_payment(this_arg: number, route: number, payment_id: number): number {
6085 if(!isWasmInitialized) {
6086 throw new Error("initializeWasm() must be awaited first!");
6088 const nativeResponseValue = wasm.TS_Payer_retry_payment(this_arg, route, payment_id);
6089 return nativeResponseValue;
6091 // void Payer_abandon_payment LDKPayer *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id
6093 export function Payer_abandon_payment(this_arg: number, payment_id: number): void {
6094 if(!isWasmInitialized) {
6095 throw new Error("initializeWasm() must be awaited first!");
6097 const nativeResponseValue = wasm.TS_Payer_abandon_payment(this_arg, payment_id);
6098 // debug statements here
6101 export interface LDKRouter {
6102 find_route (payer: number, route_params: number, payment_hash: number, first_hops: number, scorer: number): number;
6106 export function LDKRouter_new(impl: LDKRouter): number {
6107 if(!isWasmInitialized) {
6108 throw new Error("initializeWasm() must be awaited first!");
6110 var new_obj_idx = js_objs.length;
6111 for (var i = 0; i < js_objs.length; i++) {
6112 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6114 js_objs[i] = new WeakRef(impl);
6115 return wasm.TS_LDKRouter_new(i);
6117 // 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
6119 export function Router_find_route(this_arg: number, payer: number, route_params: number, payment_hash: number, first_hops: number, scorer: number): number {
6120 if(!isWasmInitialized) {
6121 throw new Error("initializeWasm() must be awaited first!");
6123 const nativeResponseValue = wasm.TS_Router_find_route(this_arg, payer, route_params, payment_hash, first_hops, scorer);
6124 return nativeResponseValue;
6126 // struct LDKStr _ldk_get_compiled_version(void);
6128 export function _ldk_get_compiled_version(): number {
6129 if(!isWasmInitialized) {
6130 throw new Error("initializeWasm() must be awaited first!");
6132 const nativeResponseValue = wasm.TS__ldk_get_compiled_version();
6133 return nativeResponseValue;
6135 // struct LDKStr _ldk_c_bindings_get_compiled_version(void);
6137 export function _ldk_c_bindings_get_compiled_version(): number {
6138 if(!isWasmInitialized) {
6139 throw new Error("initializeWasm() must be awaited first!");
6141 const nativeResponseValue = wasm.TS__ldk_c_bindings_get_compiled_version();
6142 return nativeResponseValue;
6144 // void Transaction_free(struct LDKTransaction _res);
6146 export function Transaction_free(_res: number): void {
6147 if(!isWasmInitialized) {
6148 throw new Error("initializeWasm() must be awaited first!");
6150 const nativeResponseValue = wasm.TS_Transaction_free(_res);
6151 // debug statements here
6153 // struct LDKTxOut TxOut_new(struct LDKCVec_u8Z script_pubkey, uint64_t value);
6155 export function TxOut_new(script_pubkey: number, value: bigint): number {
6156 if(!isWasmInitialized) {
6157 throw new Error("initializeWasm() must be awaited first!");
6159 const nativeResponseValue = wasm.TS_TxOut_new(script_pubkey, value);
6160 return nativeResponseValue;
6162 // void TxOut_free(struct LDKTxOut _res);
6164 export function TxOut_free(_res: number): void {
6165 if(!isWasmInitialized) {
6166 throw new Error("initializeWasm() must be awaited first!");
6168 const nativeResponseValue = wasm.TS_TxOut_free(_res);
6169 // debug statements here
6171 // uintptr_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg);
6173 export function TxOut_clone_ptr(arg: number): number {
6174 if(!isWasmInitialized) {
6175 throw new Error("initializeWasm() must be awaited first!");
6177 const nativeResponseValue = wasm.TS_TxOut_clone_ptr(arg);
6178 return nativeResponseValue;
6180 // struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
6182 export function TxOut_clone(orig: number): number {
6183 if(!isWasmInitialized) {
6184 throw new Error("initializeWasm() must be awaited first!");
6186 const nativeResponseValue = wasm.TS_TxOut_clone(orig);
6187 return nativeResponseValue;
6189 // void Str_free(struct LDKStr _res);
6191 export function Str_free(_res: number): void {
6192 if(!isWasmInitialized) {
6193 throw new Error("initializeWasm() must be awaited first!");
6195 const nativeResponseValue = wasm.TS_Str_free(_res);
6196 // debug statements here
6198 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_ok(void);
6200 export function CResult_NoneNoneZ_ok(): number {
6201 if(!isWasmInitialized) {
6202 throw new Error("initializeWasm() must be awaited first!");
6204 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_ok();
6205 return nativeResponseValue;
6207 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_err(void);
6209 export function CResult_NoneNoneZ_err(): number {
6210 if(!isWasmInitialized) {
6211 throw new Error("initializeWasm() must be awaited first!");
6213 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_err();
6214 return nativeResponseValue;
6216 // bool CResult_NoneNoneZ_is_ok(const struct LDKCResult_NoneNoneZ *NONNULL_PTR o);
6218 export function CResult_NoneNoneZ_is_ok(o: number): boolean {
6219 if(!isWasmInitialized) {
6220 throw new Error("initializeWasm() must be awaited first!");
6222 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_is_ok(o);
6223 return nativeResponseValue;
6225 // void CResult_NoneNoneZ_free(struct LDKCResult_NoneNoneZ _res);
6227 export function CResult_NoneNoneZ_free(_res: number): void {
6228 if(!isWasmInitialized) {
6229 throw new Error("initializeWasm() must be awaited first!");
6231 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_free(_res);
6232 // debug statements here
6234 // uintptr_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg);
6236 export function CResult_NoneNoneZ_clone_ptr(arg: number): number {
6237 if(!isWasmInitialized) {
6238 throw new Error("initializeWasm() must be awaited first!");
6240 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone_ptr(arg);
6241 return nativeResponseValue;
6243 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_clone(const struct LDKCResult_NoneNoneZ *NONNULL_PTR orig);
6245 export function CResult_NoneNoneZ_clone(orig: number): number {
6246 if(!isWasmInitialized) {
6247 throw new Error("initializeWasm() must be awaited first!");
6249 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone(orig);
6250 return nativeResponseValue;
6252 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(struct LDKCounterpartyCommitmentSecrets o);
6254 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o: number): number {
6255 if(!isWasmInitialized) {
6256 throw new Error("initializeWasm() must be awaited first!");
6258 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o);
6259 return nativeResponseValue;
6261 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(struct LDKDecodeError e);
6263 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e: number): number {
6264 if(!isWasmInitialized) {
6265 throw new Error("initializeWasm() must be awaited first!");
6267 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e);
6268 return nativeResponseValue;
6270 // bool CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR o);
6272 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o: number): boolean {
6273 if(!isWasmInitialized) {
6274 throw new Error("initializeWasm() must be awaited first!");
6276 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o);
6277 return nativeResponseValue;
6279 // void CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ _res);
6281 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res: number): void {
6282 if(!isWasmInitialized) {
6283 throw new Error("initializeWasm() must be awaited first!");
6285 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res);
6286 // debug statements here
6288 // uintptr_t CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR arg);
6290 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg: number): number {
6291 if(!isWasmInitialized) {
6292 throw new Error("initializeWasm() must be awaited first!");
6294 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg);
6295 return nativeResponseValue;
6297 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR orig);
6299 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig: number): number {
6300 if(!isWasmInitialized) {
6301 throw new Error("initializeWasm() must be awaited first!");
6303 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig);
6304 return nativeResponseValue;
6306 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_ok(struct LDKSecretKey o);
6308 export function CResult_SecretKeyErrorZ_ok(o: number): number {
6309 if(!isWasmInitialized) {
6310 throw new Error("initializeWasm() must be awaited first!");
6312 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_ok(o);
6313 return nativeResponseValue;
6315 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_err(enum LDKSecp256k1Error e);
6317 export function CResult_SecretKeyErrorZ_err(e: Secp256k1Error): number {
6318 if(!isWasmInitialized) {
6319 throw new Error("initializeWasm() must be awaited first!");
6321 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_err(e);
6322 return nativeResponseValue;
6324 // bool CResult_SecretKeyErrorZ_is_ok(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR o);
6326 export function CResult_SecretKeyErrorZ_is_ok(o: number): boolean {
6327 if(!isWasmInitialized) {
6328 throw new Error("initializeWasm() must be awaited first!");
6330 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_is_ok(o);
6331 return nativeResponseValue;
6333 // void CResult_SecretKeyErrorZ_free(struct LDKCResult_SecretKeyErrorZ _res);
6335 export function CResult_SecretKeyErrorZ_free(_res: number): void {
6336 if(!isWasmInitialized) {
6337 throw new Error("initializeWasm() must be awaited first!");
6339 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_free(_res);
6340 // debug statements here
6342 // uintptr_t CResult_SecretKeyErrorZ_clone_ptr(LDKCResult_SecretKeyErrorZ *NONNULL_PTR arg);
6344 export function CResult_SecretKeyErrorZ_clone_ptr(arg: number): number {
6345 if(!isWasmInitialized) {
6346 throw new Error("initializeWasm() must be awaited first!");
6348 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_clone_ptr(arg);
6349 return nativeResponseValue;
6351 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_clone(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR orig);
6353 export function CResult_SecretKeyErrorZ_clone(orig: number): number {
6354 if(!isWasmInitialized) {
6355 throw new Error("initializeWasm() must be awaited first!");
6357 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_clone(orig);
6358 return nativeResponseValue;
6360 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_ok(struct LDKPublicKey o);
6362 export function CResult_PublicKeyErrorZ_ok(o: number): number {
6363 if(!isWasmInitialized) {
6364 throw new Error("initializeWasm() must be awaited first!");
6366 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_ok(o);
6367 return nativeResponseValue;
6369 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_err(enum LDKSecp256k1Error e);
6371 export function CResult_PublicKeyErrorZ_err(e: Secp256k1Error): number {
6372 if(!isWasmInitialized) {
6373 throw new Error("initializeWasm() must be awaited first!");
6375 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_err(e);
6376 return nativeResponseValue;
6378 // bool CResult_PublicKeyErrorZ_is_ok(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR o);
6380 export function CResult_PublicKeyErrorZ_is_ok(o: number): boolean {
6381 if(!isWasmInitialized) {
6382 throw new Error("initializeWasm() must be awaited first!");
6384 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_is_ok(o);
6385 return nativeResponseValue;
6387 // void CResult_PublicKeyErrorZ_free(struct LDKCResult_PublicKeyErrorZ _res);
6389 export function CResult_PublicKeyErrorZ_free(_res: number): void {
6390 if(!isWasmInitialized) {
6391 throw new Error("initializeWasm() must be awaited first!");
6393 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_free(_res);
6394 // debug statements here
6396 // uintptr_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg);
6398 export function CResult_PublicKeyErrorZ_clone_ptr(arg: number): number {
6399 if(!isWasmInitialized) {
6400 throw new Error("initializeWasm() must be awaited first!");
6402 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone_ptr(arg);
6403 return nativeResponseValue;
6405 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_clone(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR orig);
6407 export function CResult_PublicKeyErrorZ_clone(orig: number): number {
6408 if(!isWasmInitialized) {
6409 throw new Error("initializeWasm() must be awaited first!");
6411 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone(orig);
6412 return nativeResponseValue;
6414 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_ok(struct LDKTxCreationKeys o);
6416 export function CResult_TxCreationKeysDecodeErrorZ_ok(o: number): number {
6417 if(!isWasmInitialized) {
6418 throw new Error("initializeWasm() must be awaited first!");
6420 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_ok(o);
6421 return nativeResponseValue;
6423 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_err(struct LDKDecodeError e);
6425 export function CResult_TxCreationKeysDecodeErrorZ_err(e: number): number {
6426 if(!isWasmInitialized) {
6427 throw new Error("initializeWasm() must be awaited first!");
6429 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_err(e);
6430 return nativeResponseValue;
6432 // bool CResult_TxCreationKeysDecodeErrorZ_is_ok(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR o);
6434 export function CResult_TxCreationKeysDecodeErrorZ_is_ok(o: number): boolean {
6435 if(!isWasmInitialized) {
6436 throw new Error("initializeWasm() must be awaited first!");
6438 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(o);
6439 return nativeResponseValue;
6441 // void CResult_TxCreationKeysDecodeErrorZ_free(struct LDKCResult_TxCreationKeysDecodeErrorZ _res);
6443 export function CResult_TxCreationKeysDecodeErrorZ_free(_res: number): void {
6444 if(!isWasmInitialized) {
6445 throw new Error("initializeWasm() must be awaited first!");
6447 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_free(_res);
6448 // debug statements here
6450 // uintptr_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg);
6452 export function CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg: number): number {
6453 if(!isWasmInitialized) {
6454 throw new Error("initializeWasm() must be awaited first!");
6456 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg);
6457 return nativeResponseValue;
6459 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_clone(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR orig);
6461 export function CResult_TxCreationKeysDecodeErrorZ_clone(orig: number): number {
6462 if(!isWasmInitialized) {
6463 throw new Error("initializeWasm() must be awaited first!");
6465 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone(orig);
6466 return nativeResponseValue;
6468 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_ok(struct LDKChannelPublicKeys o);
6470 export function CResult_ChannelPublicKeysDecodeErrorZ_ok(o: number): number {
6471 if(!isWasmInitialized) {
6472 throw new Error("initializeWasm() must be awaited first!");
6474 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_ok(o);
6475 return nativeResponseValue;
6477 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_err(struct LDKDecodeError e);
6479 export function CResult_ChannelPublicKeysDecodeErrorZ_err(e: number): number {
6480 if(!isWasmInitialized) {
6481 throw new Error("initializeWasm() must be awaited first!");
6483 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_err(e);
6484 return nativeResponseValue;
6486 // bool CResult_ChannelPublicKeysDecodeErrorZ_is_ok(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR o);
6488 export function CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o: number): boolean {
6489 if(!isWasmInitialized) {
6490 throw new Error("initializeWasm() must be awaited first!");
6492 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o);
6493 return nativeResponseValue;
6495 // void CResult_ChannelPublicKeysDecodeErrorZ_free(struct LDKCResult_ChannelPublicKeysDecodeErrorZ _res);
6497 export function CResult_ChannelPublicKeysDecodeErrorZ_free(_res: number): void {
6498 if(!isWasmInitialized) {
6499 throw new Error("initializeWasm() must be awaited first!");
6501 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_free(_res);
6502 // debug statements here
6504 // uintptr_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg);
6506 export function CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg: number): number {
6507 if(!isWasmInitialized) {
6508 throw new Error("initializeWasm() must be awaited first!");
6510 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg);
6511 return nativeResponseValue;
6513 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_clone(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR orig);
6515 export function CResult_ChannelPublicKeysDecodeErrorZ_clone(orig: number): number {
6516 if(!isWasmInitialized) {
6517 throw new Error("initializeWasm() must be awaited first!");
6519 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(orig);
6520 return nativeResponseValue;
6522 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_ok(struct LDKTxCreationKeys o);
6524 export function CResult_TxCreationKeysErrorZ_ok(o: number): number {
6525 if(!isWasmInitialized) {
6526 throw new Error("initializeWasm() must be awaited first!");
6528 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_ok(o);
6529 return nativeResponseValue;
6531 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_err(enum LDKSecp256k1Error e);
6533 export function CResult_TxCreationKeysErrorZ_err(e: Secp256k1Error): number {
6534 if(!isWasmInitialized) {
6535 throw new Error("initializeWasm() must be awaited first!");
6537 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_err(e);
6538 return nativeResponseValue;
6540 // bool CResult_TxCreationKeysErrorZ_is_ok(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR o);
6542 export function CResult_TxCreationKeysErrorZ_is_ok(o: number): boolean {
6543 if(!isWasmInitialized) {
6544 throw new Error("initializeWasm() must be awaited first!");
6546 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_is_ok(o);
6547 return nativeResponseValue;
6549 // void CResult_TxCreationKeysErrorZ_free(struct LDKCResult_TxCreationKeysErrorZ _res);
6551 export function CResult_TxCreationKeysErrorZ_free(_res: number): void {
6552 if(!isWasmInitialized) {
6553 throw new Error("initializeWasm() must be awaited first!");
6555 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_free(_res);
6556 // debug statements here
6558 // uintptr_t CResult_TxCreationKeysErrorZ_clone_ptr(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR arg);
6560 export function CResult_TxCreationKeysErrorZ_clone_ptr(arg: number): number {
6561 if(!isWasmInitialized) {
6562 throw new Error("initializeWasm() must be awaited first!");
6564 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone_ptr(arg);
6565 return nativeResponseValue;
6567 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_clone(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR orig);
6569 export function CResult_TxCreationKeysErrorZ_clone(orig: number): number {
6570 if(!isWasmInitialized) {
6571 throw new Error("initializeWasm() must be awaited first!");
6573 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone(orig);
6574 return nativeResponseValue;
6576 // struct LDKCOption_u32Z COption_u32Z_some(uint32_t o);
6578 export function COption_u32Z_some(o: number): number {
6579 if(!isWasmInitialized) {
6580 throw new Error("initializeWasm() must be awaited first!");
6582 const nativeResponseValue = wasm.TS_COption_u32Z_some(o);
6583 return nativeResponseValue;
6585 // struct LDKCOption_u32Z COption_u32Z_none(void);
6587 export function COption_u32Z_none(): number {
6588 if(!isWasmInitialized) {
6589 throw new Error("initializeWasm() must be awaited first!");
6591 const nativeResponseValue = wasm.TS_COption_u32Z_none();
6592 return nativeResponseValue;
6594 // void COption_u32Z_free(struct LDKCOption_u32Z _res);
6596 export function COption_u32Z_free(_res: number): void {
6597 if(!isWasmInitialized) {
6598 throw new Error("initializeWasm() must be awaited first!");
6600 const nativeResponseValue = wasm.TS_COption_u32Z_free(_res);
6601 // debug statements here
6603 // uintptr_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg);
6605 export function COption_u32Z_clone_ptr(arg: number): number {
6606 if(!isWasmInitialized) {
6607 throw new Error("initializeWasm() must be awaited first!");
6609 const nativeResponseValue = wasm.TS_COption_u32Z_clone_ptr(arg);
6610 return nativeResponseValue;
6612 // struct LDKCOption_u32Z COption_u32Z_clone(const struct LDKCOption_u32Z *NONNULL_PTR orig);
6614 export function COption_u32Z_clone(orig: number): number {
6615 if(!isWasmInitialized) {
6616 throw new Error("initializeWasm() must be awaited first!");
6618 const nativeResponseValue = wasm.TS_COption_u32Z_clone(orig);
6619 return nativeResponseValue;
6621 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(struct LDKHTLCOutputInCommitment o);
6623 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o: number): number {
6624 if(!isWasmInitialized) {
6625 throw new Error("initializeWasm() must be awaited first!");
6627 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o);
6628 return nativeResponseValue;
6630 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_err(struct LDKDecodeError e);
6632 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e: number): number {
6633 if(!isWasmInitialized) {
6634 throw new Error("initializeWasm() must be awaited first!");
6636 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e);
6637 return nativeResponseValue;
6639 // bool CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR o);
6641 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o: number): boolean {
6642 if(!isWasmInitialized) {
6643 throw new Error("initializeWasm() must be awaited first!");
6645 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o);
6646 return nativeResponseValue;
6648 // void CResult_HTLCOutputInCommitmentDecodeErrorZ_free(struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res);
6650 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res: number): void {
6651 if(!isWasmInitialized) {
6652 throw new Error("initializeWasm() must be awaited first!");
6654 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res);
6655 // debug statements here
6657 // uintptr_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg);
6659 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg: number): number {
6660 if(!isWasmInitialized) {
6661 throw new Error("initializeWasm() must be awaited first!");
6663 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg);
6664 return nativeResponseValue;
6666 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR orig);
6668 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig: number): number {
6669 if(!isWasmInitialized) {
6670 throw new Error("initializeWasm() must be awaited first!");
6672 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig);
6673 return nativeResponseValue;
6675 // enum LDKCOption_NoneZ COption_NoneZ_some(void);
6677 export function COption_NoneZ_some(): COption_NoneZ {
6678 if(!isWasmInitialized) {
6679 throw new Error("initializeWasm() must be awaited first!");
6681 const nativeResponseValue = wasm.TS_COption_NoneZ_some();
6682 return nativeResponseValue;
6684 // enum LDKCOption_NoneZ COption_NoneZ_none(void);
6686 export function COption_NoneZ_none(): COption_NoneZ {
6687 if(!isWasmInitialized) {
6688 throw new Error("initializeWasm() must be awaited first!");
6690 const nativeResponseValue = wasm.TS_COption_NoneZ_none();
6691 return nativeResponseValue;
6693 // void COption_NoneZ_free(enum LDKCOption_NoneZ _res);
6695 export function COption_NoneZ_free(_res: COption_NoneZ): void {
6696 if(!isWasmInitialized) {
6697 throw new Error("initializeWasm() must be awaited first!");
6699 const nativeResponseValue = wasm.TS_COption_NoneZ_free(_res);
6700 // debug statements here
6702 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(struct LDKCounterpartyChannelTransactionParameters o);
6704 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o: number): number {
6705 if(!isWasmInitialized) {
6706 throw new Error("initializeWasm() must be awaited first!");
6708 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o);
6709 return nativeResponseValue;
6711 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
6713 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e: number): number {
6714 if(!isWasmInitialized) {
6715 throw new Error("initializeWasm() must be awaited first!");
6717 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e);
6718 return nativeResponseValue;
6720 // bool CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
6722 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o: number): boolean {
6723 if(!isWasmInitialized) {
6724 throw new Error("initializeWasm() must be awaited first!");
6726 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o);
6727 return nativeResponseValue;
6729 // void CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res);
6731 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res: number): void {
6732 if(!isWasmInitialized) {
6733 throw new Error("initializeWasm() must be awaited first!");
6735 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res);
6736 // debug statements here
6738 // uintptr_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
6740 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: number): number {
6741 if(!isWasmInitialized) {
6742 throw new Error("initializeWasm() must be awaited first!");
6744 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
6745 return nativeResponseValue;
6747 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
6749 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig: number): number {
6750 if(!isWasmInitialized) {
6751 throw new Error("initializeWasm() must be awaited first!");
6753 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig);
6754 return nativeResponseValue;
6756 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_ok(struct LDKChannelTransactionParameters o);
6758 export function CResult_ChannelTransactionParametersDecodeErrorZ_ok(o: number): number {
6759 if(!isWasmInitialized) {
6760 throw new Error("initializeWasm() must be awaited first!");
6762 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok(o);
6763 return nativeResponseValue;
6765 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
6767 export function CResult_ChannelTransactionParametersDecodeErrorZ_err(e: number): number {
6768 if(!isWasmInitialized) {
6769 throw new Error("initializeWasm() must be awaited first!");
6771 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_err(e);
6772 return nativeResponseValue;
6774 // bool CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
6776 export function CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o: number): boolean {
6777 if(!isWasmInitialized) {
6778 throw new Error("initializeWasm() must be awaited first!");
6780 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o);
6781 return nativeResponseValue;
6783 // void CResult_ChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_ChannelTransactionParametersDecodeErrorZ _res);
6785 export function CResult_ChannelTransactionParametersDecodeErrorZ_free(_res: number): void {
6786 if(!isWasmInitialized) {
6787 throw new Error("initializeWasm() must be awaited first!");
6789 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(_res);
6790 // debug statements here
6792 // uintptr_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
6794 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: number): number {
6795 if(!isWasmInitialized) {
6796 throw new Error("initializeWasm() must be awaited first!");
6798 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
6799 return nativeResponseValue;
6801 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
6803 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig: number): number {
6804 if(!isWasmInitialized) {
6805 throw new Error("initializeWasm() must be awaited first!");
6807 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig);
6808 return nativeResponseValue;
6810 // void CVec_SignatureZ_free(struct LDKCVec_SignatureZ _res);
6812 export function CVec_SignatureZ_free(_res: number): void {
6813 if(!isWasmInitialized) {
6814 throw new Error("initializeWasm() must be awaited first!");
6816 const nativeResponseValue = wasm.TS_CVec_SignatureZ_free(_res);
6817 // debug statements here
6819 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_ok(struct LDKHolderCommitmentTransaction o);
6821 export function CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o: number): number {
6822 if(!isWasmInitialized) {
6823 throw new Error("initializeWasm() must be awaited first!");
6825 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o);
6826 return nativeResponseValue;
6828 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
6830 export function CResult_HolderCommitmentTransactionDecodeErrorZ_err(e: number): number {
6831 if(!isWasmInitialized) {
6832 throw new Error("initializeWasm() must be awaited first!");
6834 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err(e);
6835 return nativeResponseValue;
6837 // bool CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
6839 export function CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
6840 if(!isWasmInitialized) {
6841 throw new Error("initializeWasm() must be awaited first!");
6843 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o);
6844 return nativeResponseValue;
6846 // void CResult_HolderCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res);
6848 export function CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res: number): void {
6849 if(!isWasmInitialized) {
6850 throw new Error("initializeWasm() must be awaited first!");
6852 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res);
6853 // debug statements here
6855 // uintptr_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
6857 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
6858 if(!isWasmInitialized) {
6859 throw new Error("initializeWasm() must be awaited first!");
6861 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
6862 return nativeResponseValue;
6864 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
6866 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig: number): number {
6867 if(!isWasmInitialized) {
6868 throw new Error("initializeWasm() must be awaited first!");
6870 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig);
6871 return nativeResponseValue;
6873 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(struct LDKBuiltCommitmentTransaction o);
6875 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o: number): number {
6876 if(!isWasmInitialized) {
6877 throw new Error("initializeWasm() must be awaited first!");
6879 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o);
6880 return nativeResponseValue;
6882 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
6884 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e: number): number {
6885 if(!isWasmInitialized) {
6886 throw new Error("initializeWasm() must be awaited first!");
6888 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e);
6889 return nativeResponseValue;
6891 // bool CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
6893 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
6894 if(!isWasmInitialized) {
6895 throw new Error("initializeWasm() must be awaited first!");
6897 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o);
6898 return nativeResponseValue;
6900 // void CResult_BuiltCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res);
6902 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res: number): void {
6903 if(!isWasmInitialized) {
6904 throw new Error("initializeWasm() must be awaited first!");
6906 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res);
6907 // debug statements here
6909 // uintptr_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
6911 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
6912 if(!isWasmInitialized) {
6913 throw new Error("initializeWasm() must be awaited first!");
6915 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
6916 return nativeResponseValue;
6918 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
6920 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig: number): number {
6921 if(!isWasmInitialized) {
6922 throw new Error("initializeWasm() must be awaited first!");
6924 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig);
6925 return nativeResponseValue;
6927 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_ok(struct LDKTrustedClosingTransaction o);
6929 export function CResult_TrustedClosingTransactionNoneZ_ok(o: number): number {
6930 if(!isWasmInitialized) {
6931 throw new Error("initializeWasm() must be awaited first!");
6933 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_ok(o);
6934 return nativeResponseValue;
6936 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_err(void);
6938 export function CResult_TrustedClosingTransactionNoneZ_err(): number {
6939 if(!isWasmInitialized) {
6940 throw new Error("initializeWasm() must be awaited first!");
6942 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_err();
6943 return nativeResponseValue;
6945 // bool CResult_TrustedClosingTransactionNoneZ_is_ok(const struct LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR o);
6947 export function CResult_TrustedClosingTransactionNoneZ_is_ok(o: number): boolean {
6948 if(!isWasmInitialized) {
6949 throw new Error("initializeWasm() must be awaited first!");
6951 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_is_ok(o);
6952 return nativeResponseValue;
6954 // void CResult_TrustedClosingTransactionNoneZ_free(struct LDKCResult_TrustedClosingTransactionNoneZ _res);
6956 export function CResult_TrustedClosingTransactionNoneZ_free(_res: number): void {
6957 if(!isWasmInitialized) {
6958 throw new Error("initializeWasm() must be awaited first!");
6960 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_free(_res);
6961 // debug statements here
6963 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_ok(struct LDKCommitmentTransaction o);
6965 export function CResult_CommitmentTransactionDecodeErrorZ_ok(o: number): number {
6966 if(!isWasmInitialized) {
6967 throw new Error("initializeWasm() must be awaited first!");
6969 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_ok(o);
6970 return nativeResponseValue;
6972 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
6974 export function CResult_CommitmentTransactionDecodeErrorZ_err(e: number): number {
6975 if(!isWasmInitialized) {
6976 throw new Error("initializeWasm() must be awaited first!");
6978 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_err(e);
6979 return nativeResponseValue;
6981 // bool CResult_CommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
6983 export function CResult_CommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
6984 if(!isWasmInitialized) {
6985 throw new Error("initializeWasm() must be awaited first!");
6987 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(o);
6988 return nativeResponseValue;
6990 // void CResult_CommitmentTransactionDecodeErrorZ_free(struct LDKCResult_CommitmentTransactionDecodeErrorZ _res);
6992 export function CResult_CommitmentTransactionDecodeErrorZ_free(_res: number): void {
6993 if(!isWasmInitialized) {
6994 throw new Error("initializeWasm() must be awaited first!");
6996 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_free(_res);
6997 // debug statements here
6999 // uintptr_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
7001 export function CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
7002 if(!isWasmInitialized) {
7003 throw new Error("initializeWasm() must be awaited first!");
7005 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg);
7006 return nativeResponseValue;
7008 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
7010 export function CResult_CommitmentTransactionDecodeErrorZ_clone(orig: number): number {
7011 if(!isWasmInitialized) {
7012 throw new Error("initializeWasm() must be awaited first!");
7014 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone(orig);
7015 return nativeResponseValue;
7017 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_ok(struct LDKTrustedCommitmentTransaction o);
7019 export function CResult_TrustedCommitmentTransactionNoneZ_ok(o: number): number {
7020 if(!isWasmInitialized) {
7021 throw new Error("initializeWasm() must be awaited first!");
7023 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_ok(o);
7024 return nativeResponseValue;
7026 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_err(void);
7028 export function CResult_TrustedCommitmentTransactionNoneZ_err(): number {
7029 if(!isWasmInitialized) {
7030 throw new Error("initializeWasm() must be awaited first!");
7032 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_err();
7033 return nativeResponseValue;
7035 // bool CResult_TrustedCommitmentTransactionNoneZ_is_ok(const struct LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR o);
7037 export function CResult_TrustedCommitmentTransactionNoneZ_is_ok(o: number): boolean {
7038 if(!isWasmInitialized) {
7039 throw new Error("initializeWasm() must be awaited first!");
7041 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(o);
7042 return nativeResponseValue;
7044 // void CResult_TrustedCommitmentTransactionNoneZ_free(struct LDKCResult_TrustedCommitmentTransactionNoneZ _res);
7046 export function CResult_TrustedCommitmentTransactionNoneZ_free(_res: number): void {
7047 if(!isWasmInitialized) {
7048 throw new Error("initializeWasm() must be awaited first!");
7050 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_free(_res);
7051 // debug statements here
7053 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_ok(struct LDKCVec_SignatureZ o);
7055 export function CResult_CVec_SignatureZNoneZ_ok(o: number): number {
7056 if(!isWasmInitialized) {
7057 throw new Error("initializeWasm() must be awaited first!");
7059 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_ok(o);
7060 return nativeResponseValue;
7062 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_err(void);
7064 export function CResult_CVec_SignatureZNoneZ_err(): number {
7065 if(!isWasmInitialized) {
7066 throw new Error("initializeWasm() must be awaited first!");
7068 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_err();
7069 return nativeResponseValue;
7071 // bool CResult_CVec_SignatureZNoneZ_is_ok(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR o);
7073 export function CResult_CVec_SignatureZNoneZ_is_ok(o: number): boolean {
7074 if(!isWasmInitialized) {
7075 throw new Error("initializeWasm() must be awaited first!");
7077 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_is_ok(o);
7078 return nativeResponseValue;
7080 // void CResult_CVec_SignatureZNoneZ_free(struct LDKCResult_CVec_SignatureZNoneZ _res);
7082 export function CResult_CVec_SignatureZNoneZ_free(_res: number): void {
7083 if(!isWasmInitialized) {
7084 throw new Error("initializeWasm() must be awaited first!");
7086 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_free(_res);
7087 // debug statements here
7089 // uintptr_t CResult_CVec_SignatureZNoneZ_clone_ptr(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR arg);
7091 export function CResult_CVec_SignatureZNoneZ_clone_ptr(arg: number): number {
7092 if(!isWasmInitialized) {
7093 throw new Error("initializeWasm() must be awaited first!");
7095 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone_ptr(arg);
7096 return nativeResponseValue;
7098 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_clone(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR orig);
7100 export function CResult_CVec_SignatureZNoneZ_clone(orig: number): number {
7101 if(!isWasmInitialized) {
7102 throw new Error("initializeWasm() must be awaited first!");
7104 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone(orig);
7105 return nativeResponseValue;
7107 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_ok(struct LDKShutdownScript o);
7109 export function CResult_ShutdownScriptDecodeErrorZ_ok(o: number): number {
7110 if(!isWasmInitialized) {
7111 throw new Error("initializeWasm() must be awaited first!");
7113 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_ok(o);
7114 return nativeResponseValue;
7116 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_err(struct LDKDecodeError e);
7118 export function CResult_ShutdownScriptDecodeErrorZ_err(e: number): number {
7119 if(!isWasmInitialized) {
7120 throw new Error("initializeWasm() must be awaited first!");
7122 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_err(e);
7123 return nativeResponseValue;
7125 // bool CResult_ShutdownScriptDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR o);
7127 export function CResult_ShutdownScriptDecodeErrorZ_is_ok(o: number): boolean {
7128 if(!isWasmInitialized) {
7129 throw new Error("initializeWasm() must be awaited first!");
7131 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(o);
7132 return nativeResponseValue;
7134 // void CResult_ShutdownScriptDecodeErrorZ_free(struct LDKCResult_ShutdownScriptDecodeErrorZ _res);
7136 export function CResult_ShutdownScriptDecodeErrorZ_free(_res: number): void {
7137 if(!isWasmInitialized) {
7138 throw new Error("initializeWasm() must be awaited first!");
7140 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_free(_res);
7141 // debug statements here
7143 // uintptr_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg);
7145 export function CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg: number): number {
7146 if(!isWasmInitialized) {
7147 throw new Error("initializeWasm() must be awaited first!");
7149 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg);
7150 return nativeResponseValue;
7152 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_clone(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR orig);
7154 export function CResult_ShutdownScriptDecodeErrorZ_clone(orig: number): number {
7155 if(!isWasmInitialized) {
7156 throw new Error("initializeWasm() must be awaited first!");
7158 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone(orig);
7159 return nativeResponseValue;
7161 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_ok(struct LDKShutdownScript o);
7163 export function CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o: number): number {
7164 if(!isWasmInitialized) {
7165 throw new Error("initializeWasm() must be awaited first!");
7167 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o);
7168 return nativeResponseValue;
7170 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_err(struct LDKInvalidShutdownScript e);
7172 export function CResult_ShutdownScriptInvalidShutdownScriptZ_err(e: number): number {
7173 if(!isWasmInitialized) {
7174 throw new Error("initializeWasm() must be awaited first!");
7176 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err(e);
7177 return nativeResponseValue;
7179 // bool CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR o);
7181 export function CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o: number): boolean {
7182 if(!isWasmInitialized) {
7183 throw new Error("initializeWasm() must be awaited first!");
7185 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o);
7186 return nativeResponseValue;
7188 // void CResult_ShutdownScriptInvalidShutdownScriptZ_free(struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res);
7190 export function CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res: number): void {
7191 if(!isWasmInitialized) {
7192 throw new Error("initializeWasm() must be awaited first!");
7194 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res);
7195 // debug statements here
7197 // uintptr_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg);
7199 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg: number): number {
7200 if(!isWasmInitialized) {
7201 throw new Error("initializeWasm() must be awaited first!");
7203 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg);
7204 return nativeResponseValue;
7206 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_clone(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR orig);
7208 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig: number): number {
7209 if(!isWasmInitialized) {
7210 throw new Error("initializeWasm() must be awaited first!");
7212 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig);
7213 return nativeResponseValue;
7215 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_ok(struct LDKRouteHop o);
7217 export function CResult_RouteHopDecodeErrorZ_ok(o: number): number {
7218 if(!isWasmInitialized) {
7219 throw new Error("initializeWasm() must be awaited first!");
7221 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_ok(o);
7222 return nativeResponseValue;
7224 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_err(struct LDKDecodeError e);
7226 export function CResult_RouteHopDecodeErrorZ_err(e: number): number {
7227 if(!isWasmInitialized) {
7228 throw new Error("initializeWasm() must be awaited first!");
7230 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_err(e);
7231 return nativeResponseValue;
7233 // bool CResult_RouteHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR o);
7235 export function CResult_RouteHopDecodeErrorZ_is_ok(o: number): boolean {
7236 if(!isWasmInitialized) {
7237 throw new Error("initializeWasm() must be awaited first!");
7239 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_is_ok(o);
7240 return nativeResponseValue;
7242 // void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
7244 export function CResult_RouteHopDecodeErrorZ_free(_res: number): void {
7245 if(!isWasmInitialized) {
7246 throw new Error("initializeWasm() must be awaited first!");
7248 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_free(_res);
7249 // debug statements here
7251 // uintptr_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg);
7253 export function CResult_RouteHopDecodeErrorZ_clone_ptr(arg: number): number {
7254 if(!isWasmInitialized) {
7255 throw new Error("initializeWasm() must be awaited first!");
7257 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone_ptr(arg);
7258 return nativeResponseValue;
7260 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
7262 export function CResult_RouteHopDecodeErrorZ_clone(orig: number): number {
7263 if(!isWasmInitialized) {
7264 throw new Error("initializeWasm() must be awaited first!");
7266 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone(orig);
7267 return nativeResponseValue;
7269 // void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
7271 export function CVec_RouteHopZ_free(_res: number): void {
7272 if(!isWasmInitialized) {
7273 throw new Error("initializeWasm() must be awaited first!");
7275 const nativeResponseValue = wasm.TS_CVec_RouteHopZ_free(_res);
7276 // debug statements here
7278 // void CVec_CVec_RouteHopZZ_free(struct LDKCVec_CVec_RouteHopZZ _res);
7280 export function CVec_CVec_RouteHopZZ_free(_res: number): void {
7281 if(!isWasmInitialized) {
7282 throw new Error("initializeWasm() must be awaited first!");
7284 const nativeResponseValue = wasm.TS_CVec_CVec_RouteHopZZ_free(_res);
7285 // debug statements here
7287 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
7289 export function CResult_RouteDecodeErrorZ_ok(o: number): number {
7290 if(!isWasmInitialized) {
7291 throw new Error("initializeWasm() must be awaited first!");
7293 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_ok(o);
7294 return nativeResponseValue;
7296 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
7298 export function CResult_RouteDecodeErrorZ_err(e: number): number {
7299 if(!isWasmInitialized) {
7300 throw new Error("initializeWasm() must be awaited first!");
7302 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_err(e);
7303 return nativeResponseValue;
7305 // bool CResult_RouteDecodeErrorZ_is_ok(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR o);
7307 export function CResult_RouteDecodeErrorZ_is_ok(o: number): boolean {
7308 if(!isWasmInitialized) {
7309 throw new Error("initializeWasm() must be awaited first!");
7311 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_is_ok(o);
7312 return nativeResponseValue;
7314 // void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
7316 export function CResult_RouteDecodeErrorZ_free(_res: number): void {
7317 if(!isWasmInitialized) {
7318 throw new Error("initializeWasm() must be awaited first!");
7320 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_free(_res);
7321 // debug statements here
7323 // uintptr_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg);
7325 export function CResult_RouteDecodeErrorZ_clone_ptr(arg: number): number {
7326 if(!isWasmInitialized) {
7327 throw new Error("initializeWasm() must be awaited first!");
7329 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone_ptr(arg);
7330 return nativeResponseValue;
7332 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
7334 export function CResult_RouteDecodeErrorZ_clone(orig: number): number {
7335 if(!isWasmInitialized) {
7336 throw new Error("initializeWasm() must be awaited first!");
7338 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone(orig);
7339 return nativeResponseValue;
7341 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_ok(struct LDKRouteParameters o);
7343 export function CResult_RouteParametersDecodeErrorZ_ok(o: number): number {
7344 if(!isWasmInitialized) {
7345 throw new Error("initializeWasm() must be awaited first!");
7347 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_ok(o);
7348 return nativeResponseValue;
7350 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_err(struct LDKDecodeError e);
7352 export function CResult_RouteParametersDecodeErrorZ_err(e: number): number {
7353 if(!isWasmInitialized) {
7354 throw new Error("initializeWasm() must be awaited first!");
7356 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_err(e);
7357 return nativeResponseValue;
7359 // bool CResult_RouteParametersDecodeErrorZ_is_ok(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR o);
7361 export function CResult_RouteParametersDecodeErrorZ_is_ok(o: number): boolean {
7362 if(!isWasmInitialized) {
7363 throw new Error("initializeWasm() must be awaited first!");
7365 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_is_ok(o);
7366 return nativeResponseValue;
7368 // void CResult_RouteParametersDecodeErrorZ_free(struct LDKCResult_RouteParametersDecodeErrorZ _res);
7370 export function CResult_RouteParametersDecodeErrorZ_free(_res: number): void {
7371 if(!isWasmInitialized) {
7372 throw new Error("initializeWasm() must be awaited first!");
7374 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_free(_res);
7375 // debug statements here
7377 // uintptr_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg);
7379 export function CResult_RouteParametersDecodeErrorZ_clone_ptr(arg: number): number {
7380 if(!isWasmInitialized) {
7381 throw new Error("initializeWasm() must be awaited first!");
7383 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(arg);
7384 return nativeResponseValue;
7386 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_clone(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR orig);
7388 export function CResult_RouteParametersDecodeErrorZ_clone(orig: number): number {
7389 if(!isWasmInitialized) {
7390 throw new Error("initializeWasm() must be awaited first!");
7392 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone(orig);
7393 return nativeResponseValue;
7395 // void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
7397 export function CVec_RouteHintZ_free(_res: number): void {
7398 if(!isWasmInitialized) {
7399 throw new Error("initializeWasm() must be awaited first!");
7401 const nativeResponseValue = wasm.TS_CVec_RouteHintZ_free(_res);
7402 // debug statements here
7404 // struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
7406 export function COption_u64Z_some(o: bigint): number {
7407 if(!isWasmInitialized) {
7408 throw new Error("initializeWasm() must be awaited first!");
7410 const nativeResponseValue = wasm.TS_COption_u64Z_some(o);
7411 return nativeResponseValue;
7413 // struct LDKCOption_u64Z COption_u64Z_none(void);
7415 export function COption_u64Z_none(): number {
7416 if(!isWasmInitialized) {
7417 throw new Error("initializeWasm() must be awaited first!");
7419 const nativeResponseValue = wasm.TS_COption_u64Z_none();
7420 return nativeResponseValue;
7422 // void COption_u64Z_free(struct LDKCOption_u64Z _res);
7424 export function COption_u64Z_free(_res: number): void {
7425 if(!isWasmInitialized) {
7426 throw new Error("initializeWasm() must be awaited first!");
7428 const nativeResponseValue = wasm.TS_COption_u64Z_free(_res);
7429 // debug statements here
7431 // uintptr_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg);
7433 export function COption_u64Z_clone_ptr(arg: number): number {
7434 if(!isWasmInitialized) {
7435 throw new Error("initializeWasm() must be awaited first!");
7437 const nativeResponseValue = wasm.TS_COption_u64Z_clone_ptr(arg);
7438 return nativeResponseValue;
7440 // struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
7442 export function COption_u64Z_clone(orig: number): number {
7443 if(!isWasmInitialized) {
7444 throw new Error("initializeWasm() must be awaited first!");
7446 const nativeResponseValue = wasm.TS_COption_u64Z_clone(orig);
7447 return nativeResponseValue;
7449 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_ok(struct LDKPaymentParameters o);
7451 export function CResult_PaymentParametersDecodeErrorZ_ok(o: number): number {
7452 if(!isWasmInitialized) {
7453 throw new Error("initializeWasm() must be awaited first!");
7455 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_ok(o);
7456 return nativeResponseValue;
7458 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_err(struct LDKDecodeError e);
7460 export function CResult_PaymentParametersDecodeErrorZ_err(e: number): number {
7461 if(!isWasmInitialized) {
7462 throw new Error("initializeWasm() must be awaited first!");
7464 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_err(e);
7465 return nativeResponseValue;
7467 // bool CResult_PaymentParametersDecodeErrorZ_is_ok(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR o);
7469 export function CResult_PaymentParametersDecodeErrorZ_is_ok(o: number): boolean {
7470 if(!isWasmInitialized) {
7471 throw new Error("initializeWasm() must be awaited first!");
7473 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_is_ok(o);
7474 return nativeResponseValue;
7476 // void CResult_PaymentParametersDecodeErrorZ_free(struct LDKCResult_PaymentParametersDecodeErrorZ _res);
7478 export function CResult_PaymentParametersDecodeErrorZ_free(_res: number): void {
7479 if(!isWasmInitialized) {
7480 throw new Error("initializeWasm() must be awaited first!");
7482 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_free(_res);
7483 // debug statements here
7485 // uintptr_t CResult_PaymentParametersDecodeErrorZ_clone_ptr(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR arg);
7487 export function CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg: number): number {
7488 if(!isWasmInitialized) {
7489 throw new Error("initializeWasm() must be awaited first!");
7491 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg);
7492 return nativeResponseValue;
7494 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_clone(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR orig);
7496 export function CResult_PaymentParametersDecodeErrorZ_clone(orig: number): number {
7497 if(!isWasmInitialized) {
7498 throw new Error("initializeWasm() must be awaited first!");
7500 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone(orig);
7501 return nativeResponseValue;
7503 // void CVec_RouteHintHopZ_free(struct LDKCVec_RouteHintHopZ _res);
7505 export function CVec_RouteHintHopZ_free(_res: number): void {
7506 if(!isWasmInitialized) {
7507 throw new Error("initializeWasm() must be awaited first!");
7509 const nativeResponseValue = wasm.TS_CVec_RouteHintHopZ_free(_res);
7510 // debug statements here
7512 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_ok(struct LDKRouteHint o);
7514 export function CResult_RouteHintDecodeErrorZ_ok(o: number): number {
7515 if(!isWasmInitialized) {
7516 throw new Error("initializeWasm() must be awaited first!");
7518 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_ok(o);
7519 return nativeResponseValue;
7521 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_err(struct LDKDecodeError e);
7523 export function CResult_RouteHintDecodeErrorZ_err(e: number): number {
7524 if(!isWasmInitialized) {
7525 throw new Error("initializeWasm() must be awaited first!");
7527 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_err(e);
7528 return nativeResponseValue;
7530 // bool CResult_RouteHintDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR o);
7532 export function CResult_RouteHintDecodeErrorZ_is_ok(o: number): boolean {
7533 if(!isWasmInitialized) {
7534 throw new Error("initializeWasm() must be awaited first!");
7536 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_is_ok(o);
7537 return nativeResponseValue;
7539 // void CResult_RouteHintDecodeErrorZ_free(struct LDKCResult_RouteHintDecodeErrorZ _res);
7541 export function CResult_RouteHintDecodeErrorZ_free(_res: number): void {
7542 if(!isWasmInitialized) {
7543 throw new Error("initializeWasm() must be awaited first!");
7545 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_free(_res);
7546 // debug statements here
7548 // uintptr_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg);
7550 export function CResult_RouteHintDecodeErrorZ_clone_ptr(arg: number): number {
7551 if(!isWasmInitialized) {
7552 throw new Error("initializeWasm() must be awaited first!");
7554 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone_ptr(arg);
7555 return nativeResponseValue;
7557 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_clone(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR orig);
7559 export function CResult_RouteHintDecodeErrorZ_clone(orig: number): number {
7560 if(!isWasmInitialized) {
7561 throw new Error("initializeWasm() must be awaited first!");
7563 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone(orig);
7564 return nativeResponseValue;
7566 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_ok(struct LDKRouteHintHop o);
7568 export function CResult_RouteHintHopDecodeErrorZ_ok(o: number): number {
7569 if(!isWasmInitialized) {
7570 throw new Error("initializeWasm() must be awaited first!");
7572 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_ok(o);
7573 return nativeResponseValue;
7575 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_err(struct LDKDecodeError e);
7577 export function CResult_RouteHintHopDecodeErrorZ_err(e: number): number {
7578 if(!isWasmInitialized) {
7579 throw new Error("initializeWasm() must be awaited first!");
7581 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_err(e);
7582 return nativeResponseValue;
7584 // bool CResult_RouteHintHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR o);
7586 export function CResult_RouteHintHopDecodeErrorZ_is_ok(o: number): boolean {
7587 if(!isWasmInitialized) {
7588 throw new Error("initializeWasm() must be awaited first!");
7590 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_is_ok(o);
7591 return nativeResponseValue;
7593 // void CResult_RouteHintHopDecodeErrorZ_free(struct LDKCResult_RouteHintHopDecodeErrorZ _res);
7595 export function CResult_RouteHintHopDecodeErrorZ_free(_res: number): void {
7596 if(!isWasmInitialized) {
7597 throw new Error("initializeWasm() must be awaited first!");
7599 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_free(_res);
7600 // debug statements here
7602 // uintptr_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg);
7604 export function CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg: number): number {
7605 if(!isWasmInitialized) {
7606 throw new Error("initializeWasm() must be awaited first!");
7608 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg);
7609 return nativeResponseValue;
7611 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_clone(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR orig);
7613 export function CResult_RouteHintHopDecodeErrorZ_clone(orig: number): number {
7614 if(!isWasmInitialized) {
7615 throw new Error("initializeWasm() must be awaited first!");
7617 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone(orig);
7618 return nativeResponseValue;
7620 // void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
7622 export function CVec_ChannelDetailsZ_free(_res: number): void {
7623 if(!isWasmInitialized) {
7624 throw new Error("initializeWasm() must be awaited first!");
7626 const nativeResponseValue = wasm.TS_CVec_ChannelDetailsZ_free(_res);
7627 // debug statements here
7629 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
7631 export function CResult_RouteLightningErrorZ_ok(o: number): number {
7632 if(!isWasmInitialized) {
7633 throw new Error("initializeWasm() must be awaited first!");
7635 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_ok(o);
7636 return nativeResponseValue;
7638 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
7640 export function CResult_RouteLightningErrorZ_err(e: number): number {
7641 if(!isWasmInitialized) {
7642 throw new Error("initializeWasm() must be awaited first!");
7644 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_err(e);
7645 return nativeResponseValue;
7647 // bool CResult_RouteLightningErrorZ_is_ok(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR o);
7649 export function CResult_RouteLightningErrorZ_is_ok(o: number): boolean {
7650 if(!isWasmInitialized) {
7651 throw new Error("initializeWasm() must be awaited first!");
7653 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_is_ok(o);
7654 return nativeResponseValue;
7656 // void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
7658 export function CResult_RouteLightningErrorZ_free(_res: number): void {
7659 if(!isWasmInitialized) {
7660 throw new Error("initializeWasm() must be awaited first!");
7662 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_free(_res);
7663 // debug statements here
7665 // uintptr_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg);
7667 export function CResult_RouteLightningErrorZ_clone_ptr(arg: number): number {
7668 if(!isWasmInitialized) {
7669 throw new Error("initializeWasm() must be awaited first!");
7671 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone_ptr(arg);
7672 return nativeResponseValue;
7674 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
7676 export function CResult_RouteLightningErrorZ_clone(orig: number): number {
7677 if(!isWasmInitialized) {
7678 throw new Error("initializeWasm() must be awaited first!");
7680 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone(orig);
7681 return nativeResponseValue;
7683 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_ok(struct LDKTxOut o);
7685 export function CResult_TxOutAccessErrorZ_ok(o: number): number {
7686 if(!isWasmInitialized) {
7687 throw new Error("initializeWasm() must be awaited first!");
7689 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_ok(o);
7690 return nativeResponseValue;
7692 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_err(enum LDKAccessError e);
7694 export function CResult_TxOutAccessErrorZ_err(e: AccessError): number {
7695 if(!isWasmInitialized) {
7696 throw new Error("initializeWasm() must be awaited first!");
7698 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_err(e);
7699 return nativeResponseValue;
7701 // bool CResult_TxOutAccessErrorZ_is_ok(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR o);
7703 export function CResult_TxOutAccessErrorZ_is_ok(o: number): boolean {
7704 if(!isWasmInitialized) {
7705 throw new Error("initializeWasm() must be awaited first!");
7707 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_is_ok(o);
7708 return nativeResponseValue;
7710 // void CResult_TxOutAccessErrorZ_free(struct LDKCResult_TxOutAccessErrorZ _res);
7712 export function CResult_TxOutAccessErrorZ_free(_res: number): void {
7713 if(!isWasmInitialized) {
7714 throw new Error("initializeWasm() must be awaited first!");
7716 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_free(_res);
7717 // debug statements here
7719 // uintptr_t CResult_TxOutAccessErrorZ_clone_ptr(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR arg);
7721 export function CResult_TxOutAccessErrorZ_clone_ptr(arg: number): number {
7722 if(!isWasmInitialized) {
7723 throw new Error("initializeWasm() must be awaited first!");
7725 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone_ptr(arg);
7726 return nativeResponseValue;
7728 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_clone(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR orig);
7730 export function CResult_TxOutAccessErrorZ_clone(orig: number): number {
7731 if(!isWasmInitialized) {
7732 throw new Error("initializeWasm() must be awaited first!");
7734 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone(orig);
7735 return nativeResponseValue;
7737 // uintptr_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg);
7739 export function C2Tuple_usizeTransactionZ_clone_ptr(arg: number): number {
7740 if(!isWasmInitialized) {
7741 throw new Error("initializeWasm() must be awaited first!");
7743 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone_ptr(arg);
7744 return nativeResponseValue;
7746 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_clone(const struct LDKC2Tuple_usizeTransactionZ *NONNULL_PTR orig);
7748 export function C2Tuple_usizeTransactionZ_clone(orig: number): number {
7749 if(!isWasmInitialized) {
7750 throw new Error("initializeWasm() must be awaited first!");
7752 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone(orig);
7753 return nativeResponseValue;
7755 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
7757 export function C2Tuple_usizeTransactionZ_new(a: number, b: number): number {
7758 if(!isWasmInitialized) {
7759 throw new Error("initializeWasm() must be awaited first!");
7761 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_new(a, b);
7762 return nativeResponseValue;
7764 // void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
7766 export function C2Tuple_usizeTransactionZ_free(_res: number): void {
7767 if(!isWasmInitialized) {
7768 throw new Error("initializeWasm() must be awaited first!");
7770 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_free(_res);
7771 // debug statements here
7773 // void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
7775 export function CVec_C2Tuple_usizeTransactionZZ_free(_res: number): void {
7776 if(!isWasmInitialized) {
7777 throw new Error("initializeWasm() must be awaited first!");
7779 const nativeResponseValue = wasm.TS_CVec_C2Tuple_usizeTransactionZZ_free(_res);
7780 // debug statements here
7782 // void CVec_TxidZ_free(struct LDKCVec_TxidZ _res);
7784 export function CVec_TxidZ_free(_res: number): void {
7785 if(!isWasmInitialized) {
7786 throw new Error("initializeWasm() must be awaited first!");
7788 const nativeResponseValue = wasm.TS_CVec_TxidZ_free(_res);
7789 // debug statements here
7791 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_ok(void);
7793 export function CResult_NoneChannelMonitorUpdateErrZ_ok(): number {
7794 if(!isWasmInitialized) {
7795 throw new Error("initializeWasm() must be awaited first!");
7797 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_ok();
7798 return nativeResponseValue;
7800 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_err(enum LDKChannelMonitorUpdateErr e);
7802 export function CResult_NoneChannelMonitorUpdateErrZ_err(e: ChannelMonitorUpdateErr): number {
7803 if(!isWasmInitialized) {
7804 throw new Error("initializeWasm() must be awaited first!");
7806 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_err(e);
7807 return nativeResponseValue;
7809 // bool CResult_NoneChannelMonitorUpdateErrZ_is_ok(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR o);
7811 export function CResult_NoneChannelMonitorUpdateErrZ_is_ok(o: number): boolean {
7812 if(!isWasmInitialized) {
7813 throw new Error("initializeWasm() must be awaited first!");
7815 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_is_ok(o);
7816 return nativeResponseValue;
7818 // void CResult_NoneChannelMonitorUpdateErrZ_free(struct LDKCResult_NoneChannelMonitorUpdateErrZ _res);
7820 export function CResult_NoneChannelMonitorUpdateErrZ_free(_res: number): void {
7821 if(!isWasmInitialized) {
7822 throw new Error("initializeWasm() must be awaited first!");
7824 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_free(_res);
7825 // debug statements here
7827 // uintptr_t CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR arg);
7829 export function CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg: number): number {
7830 if(!isWasmInitialized) {
7831 throw new Error("initializeWasm() must be awaited first!");
7833 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg);
7834 return nativeResponseValue;
7836 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_clone(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR orig);
7838 export function CResult_NoneChannelMonitorUpdateErrZ_clone(orig: number): number {
7839 if(!isWasmInitialized) {
7840 throw new Error("initializeWasm() must be awaited first!");
7842 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_clone(orig);
7843 return nativeResponseValue;
7845 // void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
7847 export function CVec_MonitorEventZ_free(_res: number): void {
7848 if(!isWasmInitialized) {
7849 throw new Error("initializeWasm() must be awaited first!");
7851 const nativeResponseValue = wasm.TS_CVec_MonitorEventZ_free(_res);
7852 // debug statements here
7854 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_some(struct LDKC2Tuple_usizeTransactionZ o);
7856 export function COption_C2Tuple_usizeTransactionZZ_some(o: number): number {
7857 if(!isWasmInitialized) {
7858 throw new Error("initializeWasm() must be awaited first!");
7860 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_some(o);
7861 return nativeResponseValue;
7863 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_none(void);
7865 export function COption_C2Tuple_usizeTransactionZZ_none(): number {
7866 if(!isWasmInitialized) {
7867 throw new Error("initializeWasm() must be awaited first!");
7869 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_none();
7870 return nativeResponseValue;
7872 // void COption_C2Tuple_usizeTransactionZZ_free(struct LDKCOption_C2Tuple_usizeTransactionZZ _res);
7874 export function COption_C2Tuple_usizeTransactionZZ_free(_res: number): void {
7875 if(!isWasmInitialized) {
7876 throw new Error("initializeWasm() must be awaited first!");
7878 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_free(_res);
7879 // debug statements here
7881 // uintptr_t COption_C2Tuple_usizeTransactionZZ_clone_ptr(LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR arg);
7883 export function COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg: number): number {
7884 if(!isWasmInitialized) {
7885 throw new Error("initializeWasm() must be awaited first!");
7887 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg);
7888 return nativeResponseValue;
7890 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_clone(const struct LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR orig);
7892 export function COption_C2Tuple_usizeTransactionZZ_clone(orig: number): number {
7893 if(!isWasmInitialized) {
7894 throw new Error("initializeWasm() must be awaited first!");
7896 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_clone(orig);
7897 return nativeResponseValue;
7899 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_some(struct LDKClosureReason o);
7901 export function COption_ClosureReasonZ_some(o: number): number {
7902 if(!isWasmInitialized) {
7903 throw new Error("initializeWasm() must be awaited first!");
7905 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_some(o);
7906 return nativeResponseValue;
7908 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_none(void);
7910 export function COption_ClosureReasonZ_none(): number {
7911 if(!isWasmInitialized) {
7912 throw new Error("initializeWasm() must be awaited first!");
7914 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_none();
7915 return nativeResponseValue;
7917 // void COption_ClosureReasonZ_free(struct LDKCOption_ClosureReasonZ _res);
7919 export function COption_ClosureReasonZ_free(_res: number): void {
7920 if(!isWasmInitialized) {
7921 throw new Error("initializeWasm() must be awaited first!");
7923 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_free(_res);
7924 // debug statements here
7926 // uintptr_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg);
7928 export function COption_ClosureReasonZ_clone_ptr(arg: number): number {
7929 if(!isWasmInitialized) {
7930 throw new Error("initializeWasm() must be awaited first!");
7932 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone_ptr(arg);
7933 return nativeResponseValue;
7935 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_clone(const struct LDKCOption_ClosureReasonZ *NONNULL_PTR orig);
7937 export function COption_ClosureReasonZ_clone(orig: number): number {
7938 if(!isWasmInitialized) {
7939 throw new Error("initializeWasm() must be awaited first!");
7941 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone(orig);
7942 return nativeResponseValue;
7944 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_ok(struct LDKCOption_ClosureReasonZ o);
7946 export function CResult_COption_ClosureReasonZDecodeErrorZ_ok(o: number): number {
7947 if(!isWasmInitialized) {
7948 throw new Error("initializeWasm() must be awaited first!");
7950 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(o);
7951 return nativeResponseValue;
7953 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_err(struct LDKDecodeError e);
7955 export function CResult_COption_ClosureReasonZDecodeErrorZ_err(e: number): number {
7956 if(!isWasmInitialized) {
7957 throw new Error("initializeWasm() must be awaited first!");
7959 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(e);
7960 return nativeResponseValue;
7962 // bool CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR o);
7964 export function CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o: number): boolean {
7965 if(!isWasmInitialized) {
7966 throw new Error("initializeWasm() must be awaited first!");
7968 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o);
7969 return nativeResponseValue;
7971 // void CResult_COption_ClosureReasonZDecodeErrorZ_free(struct LDKCResult_COption_ClosureReasonZDecodeErrorZ _res);
7973 export function CResult_COption_ClosureReasonZDecodeErrorZ_free(_res: number): void {
7974 if(!isWasmInitialized) {
7975 throw new Error("initializeWasm() must be awaited first!");
7977 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(_res);
7978 // debug statements here
7980 // uintptr_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg);
7982 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg: number): number {
7983 if(!isWasmInitialized) {
7984 throw new Error("initializeWasm() must be awaited first!");
7986 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg);
7987 return nativeResponseValue;
7989 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_clone(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR orig);
7991 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig: number): number {
7992 if(!isWasmInitialized) {
7993 throw new Error("initializeWasm() must be awaited first!");
7995 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig);
7996 return nativeResponseValue;
7998 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_some(struct LDKNetworkUpdate o);
8000 export function COption_NetworkUpdateZ_some(o: number): number {
8001 if(!isWasmInitialized) {
8002 throw new Error("initializeWasm() must be awaited first!");
8004 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_some(o);
8005 return nativeResponseValue;
8007 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_none(void);
8009 export function COption_NetworkUpdateZ_none(): number {
8010 if(!isWasmInitialized) {
8011 throw new Error("initializeWasm() must be awaited first!");
8013 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_none();
8014 return nativeResponseValue;
8016 // void COption_NetworkUpdateZ_free(struct LDKCOption_NetworkUpdateZ _res);
8018 export function COption_NetworkUpdateZ_free(_res: number): void {
8019 if(!isWasmInitialized) {
8020 throw new Error("initializeWasm() must be awaited first!");
8022 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_free(_res);
8023 // debug statements here
8025 // uintptr_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg);
8027 export function COption_NetworkUpdateZ_clone_ptr(arg: number): number {
8028 if(!isWasmInitialized) {
8029 throw new Error("initializeWasm() must be awaited first!");
8031 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone_ptr(arg);
8032 return nativeResponseValue;
8034 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_clone(const struct LDKCOption_NetworkUpdateZ *NONNULL_PTR orig);
8036 export function COption_NetworkUpdateZ_clone(orig: number): number {
8037 if(!isWasmInitialized) {
8038 throw new Error("initializeWasm() must be awaited first!");
8040 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone(orig);
8041 return nativeResponseValue;
8043 // void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
8045 export function CVec_SpendableOutputDescriptorZ_free(_res: number): void {
8046 if(!isWasmInitialized) {
8047 throw new Error("initializeWasm() must be awaited first!");
8049 const nativeResponseValue = wasm.TS_CVec_SpendableOutputDescriptorZ_free(_res);
8050 // debug statements here
8052 // struct LDKCOption_EventZ COption_EventZ_some(struct LDKEvent o);
8054 export function COption_EventZ_some(o: number): number {
8055 if(!isWasmInitialized) {
8056 throw new Error("initializeWasm() must be awaited first!");
8058 const nativeResponseValue = wasm.TS_COption_EventZ_some(o);
8059 return nativeResponseValue;
8061 // struct LDKCOption_EventZ COption_EventZ_none(void);
8063 export function COption_EventZ_none(): number {
8064 if(!isWasmInitialized) {
8065 throw new Error("initializeWasm() must be awaited first!");
8067 const nativeResponseValue = wasm.TS_COption_EventZ_none();
8068 return nativeResponseValue;
8070 // void COption_EventZ_free(struct LDKCOption_EventZ _res);
8072 export function COption_EventZ_free(_res: number): void {
8073 if(!isWasmInitialized) {
8074 throw new Error("initializeWasm() must be awaited first!");
8076 const nativeResponseValue = wasm.TS_COption_EventZ_free(_res);
8077 // debug statements here
8079 // uintptr_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg);
8081 export function COption_EventZ_clone_ptr(arg: number): number {
8082 if(!isWasmInitialized) {
8083 throw new Error("initializeWasm() must be awaited first!");
8085 const nativeResponseValue = wasm.TS_COption_EventZ_clone_ptr(arg);
8086 return nativeResponseValue;
8088 // struct LDKCOption_EventZ COption_EventZ_clone(const struct LDKCOption_EventZ *NONNULL_PTR orig);
8090 export function COption_EventZ_clone(orig: number): number {
8091 if(!isWasmInitialized) {
8092 throw new Error("initializeWasm() must be awaited first!");
8094 const nativeResponseValue = wasm.TS_COption_EventZ_clone(orig);
8095 return nativeResponseValue;
8097 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_ok(struct LDKCOption_EventZ o);
8099 export function CResult_COption_EventZDecodeErrorZ_ok(o: number): number {
8100 if(!isWasmInitialized) {
8101 throw new Error("initializeWasm() must be awaited first!");
8103 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_ok(o);
8104 return nativeResponseValue;
8106 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_err(struct LDKDecodeError e);
8108 export function CResult_COption_EventZDecodeErrorZ_err(e: number): number {
8109 if(!isWasmInitialized) {
8110 throw new Error("initializeWasm() must be awaited first!");
8112 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_err(e);
8113 return nativeResponseValue;
8115 // bool CResult_COption_EventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR o);
8117 export function CResult_COption_EventZDecodeErrorZ_is_ok(o: number): boolean {
8118 if(!isWasmInitialized) {
8119 throw new Error("initializeWasm() must be awaited first!");
8121 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_is_ok(o);
8122 return nativeResponseValue;
8124 // void CResult_COption_EventZDecodeErrorZ_free(struct LDKCResult_COption_EventZDecodeErrorZ _res);
8126 export function CResult_COption_EventZDecodeErrorZ_free(_res: number): void {
8127 if(!isWasmInitialized) {
8128 throw new Error("initializeWasm() must be awaited first!");
8130 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_free(_res);
8131 // debug statements here
8133 // uintptr_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg);
8135 export function CResult_COption_EventZDecodeErrorZ_clone_ptr(arg: number): number {
8136 if(!isWasmInitialized) {
8137 throw new Error("initializeWasm() must be awaited first!");
8139 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(arg);
8140 return nativeResponseValue;
8142 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_clone(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR orig);
8144 export function CResult_COption_EventZDecodeErrorZ_clone(orig: number): number {
8145 if(!isWasmInitialized) {
8146 throw new Error("initializeWasm() must be awaited first!");
8148 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone(orig);
8149 return nativeResponseValue;
8151 // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
8153 export function CVec_MessageSendEventZ_free(_res: number): void {
8154 if(!isWasmInitialized) {
8155 throw new Error("initializeWasm() must be awaited first!");
8157 const nativeResponseValue = wasm.TS_CVec_MessageSendEventZ_free(_res);
8158 // debug statements here
8160 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_ok(struct LDKFixedPenaltyScorer o);
8162 export function CResult_FixedPenaltyScorerDecodeErrorZ_ok(o: number): number {
8163 if(!isWasmInitialized) {
8164 throw new Error("initializeWasm() must be awaited first!");
8166 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok(o);
8167 return nativeResponseValue;
8169 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_err(struct LDKDecodeError e);
8171 export function CResult_FixedPenaltyScorerDecodeErrorZ_err(e: number): number {
8172 if(!isWasmInitialized) {
8173 throw new Error("initializeWasm() must be awaited first!");
8175 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_err(e);
8176 return nativeResponseValue;
8178 // bool CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR o);
8180 export function CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o: number): boolean {
8181 if(!isWasmInitialized) {
8182 throw new Error("initializeWasm() must be awaited first!");
8184 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o);
8185 return nativeResponseValue;
8187 // void CResult_FixedPenaltyScorerDecodeErrorZ_free(struct LDKCResult_FixedPenaltyScorerDecodeErrorZ _res);
8189 export function CResult_FixedPenaltyScorerDecodeErrorZ_free(_res: number): void {
8190 if(!isWasmInitialized) {
8191 throw new Error("initializeWasm() must be awaited first!");
8193 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_free(_res);
8194 // debug statements here
8196 // uintptr_t CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR arg);
8198 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg: number): number {
8199 if(!isWasmInitialized) {
8200 throw new Error("initializeWasm() must be awaited first!");
8202 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg);
8203 return nativeResponseValue;
8205 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_clone(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR orig);
8207 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig: number): number {
8208 if(!isWasmInitialized) {
8209 throw new Error("initializeWasm() must be awaited first!");
8211 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig);
8212 return nativeResponseValue;
8214 // struct LDKCResult_ScoringParametersDecodeErrorZ CResult_ScoringParametersDecodeErrorZ_ok(struct LDKScoringParameters o);
8216 export function CResult_ScoringParametersDecodeErrorZ_ok(o: number): number {
8217 if(!isWasmInitialized) {
8218 throw new Error("initializeWasm() must be awaited first!");
8220 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_ok(o);
8221 return nativeResponseValue;
8223 // struct LDKCResult_ScoringParametersDecodeErrorZ CResult_ScoringParametersDecodeErrorZ_err(struct LDKDecodeError e);
8225 export function CResult_ScoringParametersDecodeErrorZ_err(e: number): number {
8226 if(!isWasmInitialized) {
8227 throw new Error("initializeWasm() must be awaited first!");
8229 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_err(e);
8230 return nativeResponseValue;
8232 // bool CResult_ScoringParametersDecodeErrorZ_is_ok(const struct LDKCResult_ScoringParametersDecodeErrorZ *NONNULL_PTR o);
8234 export function CResult_ScoringParametersDecodeErrorZ_is_ok(o: number): boolean {
8235 if(!isWasmInitialized) {
8236 throw new Error("initializeWasm() must be awaited first!");
8238 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_is_ok(o);
8239 return nativeResponseValue;
8241 // void CResult_ScoringParametersDecodeErrorZ_free(struct LDKCResult_ScoringParametersDecodeErrorZ _res);
8243 export function CResult_ScoringParametersDecodeErrorZ_free(_res: number): void {
8244 if(!isWasmInitialized) {
8245 throw new Error("initializeWasm() must be awaited first!");
8247 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_free(_res);
8248 // debug statements here
8250 // uintptr_t CResult_ScoringParametersDecodeErrorZ_clone_ptr(LDKCResult_ScoringParametersDecodeErrorZ *NONNULL_PTR arg);
8252 export function CResult_ScoringParametersDecodeErrorZ_clone_ptr(arg: number): number {
8253 if(!isWasmInitialized) {
8254 throw new Error("initializeWasm() must be awaited first!");
8256 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_clone_ptr(arg);
8257 return nativeResponseValue;
8259 // struct LDKCResult_ScoringParametersDecodeErrorZ CResult_ScoringParametersDecodeErrorZ_clone(const struct LDKCResult_ScoringParametersDecodeErrorZ *NONNULL_PTR orig);
8261 export function CResult_ScoringParametersDecodeErrorZ_clone(orig: number): number {
8262 if(!isWasmInitialized) {
8263 throw new Error("initializeWasm() must be awaited first!");
8265 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_clone(orig);
8266 return nativeResponseValue;
8268 // struct LDKCResult_ScorerDecodeErrorZ CResult_ScorerDecodeErrorZ_ok(struct LDKScorer o);
8270 export function CResult_ScorerDecodeErrorZ_ok(o: number): number {
8271 if(!isWasmInitialized) {
8272 throw new Error("initializeWasm() must be awaited first!");
8274 const nativeResponseValue = wasm.TS_CResult_ScorerDecodeErrorZ_ok(o);
8275 return nativeResponseValue;
8277 // struct LDKCResult_ScorerDecodeErrorZ CResult_ScorerDecodeErrorZ_err(struct LDKDecodeError e);
8279 export function CResult_ScorerDecodeErrorZ_err(e: number): number {
8280 if(!isWasmInitialized) {
8281 throw new Error("initializeWasm() must be awaited first!");
8283 const nativeResponseValue = wasm.TS_CResult_ScorerDecodeErrorZ_err(e);
8284 return nativeResponseValue;
8286 // bool CResult_ScorerDecodeErrorZ_is_ok(const struct LDKCResult_ScorerDecodeErrorZ *NONNULL_PTR o);
8288 export function CResult_ScorerDecodeErrorZ_is_ok(o: number): boolean {
8289 if(!isWasmInitialized) {
8290 throw new Error("initializeWasm() must be awaited first!");
8292 const nativeResponseValue = wasm.TS_CResult_ScorerDecodeErrorZ_is_ok(o);
8293 return nativeResponseValue;
8295 // void CResult_ScorerDecodeErrorZ_free(struct LDKCResult_ScorerDecodeErrorZ _res);
8297 export function CResult_ScorerDecodeErrorZ_free(_res: number): void {
8298 if(!isWasmInitialized) {
8299 throw new Error("initializeWasm() must be awaited first!");
8301 const nativeResponseValue = wasm.TS_CResult_ScorerDecodeErrorZ_free(_res);
8302 // debug statements here
8304 // struct LDKCResult_ProbabilisticScoringParametersDecodeErrorZ CResult_ProbabilisticScoringParametersDecodeErrorZ_ok(struct LDKProbabilisticScoringParameters o);
8306 export function CResult_ProbabilisticScoringParametersDecodeErrorZ_ok(o: number): number {
8307 if(!isWasmInitialized) {
8308 throw new Error("initializeWasm() must be awaited first!");
8310 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScoringParametersDecodeErrorZ_ok(o);
8311 return nativeResponseValue;
8313 // struct LDKCResult_ProbabilisticScoringParametersDecodeErrorZ CResult_ProbabilisticScoringParametersDecodeErrorZ_err(struct LDKDecodeError e);
8315 export function CResult_ProbabilisticScoringParametersDecodeErrorZ_err(e: number): number {
8316 if(!isWasmInitialized) {
8317 throw new Error("initializeWasm() must be awaited first!");
8319 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScoringParametersDecodeErrorZ_err(e);
8320 return nativeResponseValue;
8322 // bool CResult_ProbabilisticScoringParametersDecodeErrorZ_is_ok(const struct LDKCResult_ProbabilisticScoringParametersDecodeErrorZ *NONNULL_PTR o);
8324 export function CResult_ProbabilisticScoringParametersDecodeErrorZ_is_ok(o: number): boolean {
8325 if(!isWasmInitialized) {
8326 throw new Error("initializeWasm() must be awaited first!");
8328 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScoringParametersDecodeErrorZ_is_ok(o);
8329 return nativeResponseValue;
8331 // void CResult_ProbabilisticScoringParametersDecodeErrorZ_free(struct LDKCResult_ProbabilisticScoringParametersDecodeErrorZ _res);
8333 export function CResult_ProbabilisticScoringParametersDecodeErrorZ_free(_res: number): void {
8334 if(!isWasmInitialized) {
8335 throw new Error("initializeWasm() must be awaited first!");
8337 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScoringParametersDecodeErrorZ_free(_res);
8338 // debug statements here
8340 // uintptr_t CResult_ProbabilisticScoringParametersDecodeErrorZ_clone_ptr(LDKCResult_ProbabilisticScoringParametersDecodeErrorZ *NONNULL_PTR arg);
8342 export function CResult_ProbabilisticScoringParametersDecodeErrorZ_clone_ptr(arg: number): number {
8343 if(!isWasmInitialized) {
8344 throw new Error("initializeWasm() must be awaited first!");
8346 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScoringParametersDecodeErrorZ_clone_ptr(arg);
8347 return nativeResponseValue;
8349 // struct LDKCResult_ProbabilisticScoringParametersDecodeErrorZ CResult_ProbabilisticScoringParametersDecodeErrorZ_clone(const struct LDKCResult_ProbabilisticScoringParametersDecodeErrorZ *NONNULL_PTR orig);
8351 export function CResult_ProbabilisticScoringParametersDecodeErrorZ_clone(orig: number): number {
8352 if(!isWasmInitialized) {
8353 throw new Error("initializeWasm() must be awaited first!");
8355 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScoringParametersDecodeErrorZ_clone(orig);
8356 return nativeResponseValue;
8358 // uintptr_t C2Tuple_ProbabilisticScoringParametersNetworkGraphZ_clone_ptr(LDKC2Tuple_ProbabilisticScoringParametersNetworkGraphZ *NONNULL_PTR arg);
8360 export function C2Tuple_ProbabilisticScoringParametersNetworkGraphZ_clone_ptr(arg: number): number {
8361 if(!isWasmInitialized) {
8362 throw new Error("initializeWasm() must be awaited first!");
8364 const nativeResponseValue = wasm.TS_C2Tuple_ProbabilisticScoringParametersNetworkGraphZ_clone_ptr(arg);
8365 return nativeResponseValue;
8367 // struct LDKC2Tuple_ProbabilisticScoringParametersNetworkGraphZ C2Tuple_ProbabilisticScoringParametersNetworkGraphZ_clone(const struct LDKC2Tuple_ProbabilisticScoringParametersNetworkGraphZ *NONNULL_PTR orig);
8369 export function C2Tuple_ProbabilisticScoringParametersNetworkGraphZ_clone(orig: number): number {
8370 if(!isWasmInitialized) {
8371 throw new Error("initializeWasm() must be awaited first!");
8373 const nativeResponseValue = wasm.TS_C2Tuple_ProbabilisticScoringParametersNetworkGraphZ_clone(orig);
8374 return nativeResponseValue;
8376 // struct LDKC2Tuple_ProbabilisticScoringParametersNetworkGraphZ C2Tuple_ProbabilisticScoringParametersNetworkGraphZ_new(struct LDKProbabilisticScoringParameters a, const struct LDKNetworkGraph *NONNULL_PTR b);
8378 export function C2Tuple_ProbabilisticScoringParametersNetworkGraphZ_new(a: number, b: number): number {
8379 if(!isWasmInitialized) {
8380 throw new Error("initializeWasm() must be awaited first!");
8382 const nativeResponseValue = wasm.TS_C2Tuple_ProbabilisticScoringParametersNetworkGraphZ_new(a, b);
8383 return nativeResponseValue;
8385 // void C2Tuple_ProbabilisticScoringParametersNetworkGraphZ_free(struct LDKC2Tuple_ProbabilisticScoringParametersNetworkGraphZ _res);
8387 export function C2Tuple_ProbabilisticScoringParametersNetworkGraphZ_free(_res: number): void {
8388 if(!isWasmInitialized) {
8389 throw new Error("initializeWasm() must be awaited first!");
8391 const nativeResponseValue = wasm.TS_C2Tuple_ProbabilisticScoringParametersNetworkGraphZ_free(_res);
8392 // debug statements here
8394 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_ok(struct LDKProbabilisticScorer o);
8396 export function CResult_ProbabilisticScorerDecodeErrorZ_ok(o: number): number {
8397 if(!isWasmInitialized) {
8398 throw new Error("initializeWasm() must be awaited first!");
8400 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_ok(o);
8401 return nativeResponseValue;
8403 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_err(struct LDKDecodeError e);
8405 export function CResult_ProbabilisticScorerDecodeErrorZ_err(e: number): number {
8406 if(!isWasmInitialized) {
8407 throw new Error("initializeWasm() must be awaited first!");
8409 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_err(e);
8410 return nativeResponseValue;
8412 // bool CResult_ProbabilisticScorerDecodeErrorZ_is_ok(const struct LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR o);
8414 export function CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o: number): boolean {
8415 if(!isWasmInitialized) {
8416 throw new Error("initializeWasm() must be awaited first!");
8418 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o);
8419 return nativeResponseValue;
8421 // void CResult_ProbabilisticScorerDecodeErrorZ_free(struct LDKCResult_ProbabilisticScorerDecodeErrorZ _res);
8423 export function CResult_ProbabilisticScorerDecodeErrorZ_free(_res: number): void {
8424 if(!isWasmInitialized) {
8425 throw new Error("initializeWasm() must be awaited first!");
8427 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_free(_res);
8428 // debug statements here
8430 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
8432 export function CResult_InitFeaturesDecodeErrorZ_ok(o: number): number {
8433 if(!isWasmInitialized) {
8434 throw new Error("initializeWasm() must be awaited first!");
8436 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_ok(o);
8437 return nativeResponseValue;
8439 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8441 export function CResult_InitFeaturesDecodeErrorZ_err(e: number): number {
8442 if(!isWasmInitialized) {
8443 throw new Error("initializeWasm() must be awaited first!");
8445 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_err(e);
8446 return nativeResponseValue;
8448 // bool CResult_InitFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR o);
8450 export function CResult_InitFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8451 if(!isWasmInitialized) {
8452 throw new Error("initializeWasm() must be awaited first!");
8454 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_is_ok(o);
8455 return nativeResponseValue;
8457 // void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
8459 export function CResult_InitFeaturesDecodeErrorZ_free(_res: number): void {
8460 if(!isWasmInitialized) {
8461 throw new Error("initializeWasm() must be awaited first!");
8463 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_free(_res);
8464 // debug statements here
8466 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
8468 export function CResult_ChannelFeaturesDecodeErrorZ_ok(o: number): number {
8469 if(!isWasmInitialized) {
8470 throw new Error("initializeWasm() must be awaited first!");
8472 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_ok(o);
8473 return nativeResponseValue;
8475 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8477 export function CResult_ChannelFeaturesDecodeErrorZ_err(e: number): number {
8478 if(!isWasmInitialized) {
8479 throw new Error("initializeWasm() must be awaited first!");
8481 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_err(e);
8482 return nativeResponseValue;
8484 // bool CResult_ChannelFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR o);
8486 export function CResult_ChannelFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8487 if(!isWasmInitialized) {
8488 throw new Error("initializeWasm() must be awaited first!");
8490 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(o);
8491 return nativeResponseValue;
8493 // void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
8495 export function CResult_ChannelFeaturesDecodeErrorZ_free(_res: number): void {
8496 if(!isWasmInitialized) {
8497 throw new Error("initializeWasm() must be awaited first!");
8499 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_free(_res);
8500 // debug statements here
8502 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
8504 export function CResult_NodeFeaturesDecodeErrorZ_ok(o: number): number {
8505 if(!isWasmInitialized) {
8506 throw new Error("initializeWasm() must be awaited first!");
8508 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_ok(o);
8509 return nativeResponseValue;
8511 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8513 export function CResult_NodeFeaturesDecodeErrorZ_err(e: number): number {
8514 if(!isWasmInitialized) {
8515 throw new Error("initializeWasm() must be awaited first!");
8517 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_err(e);
8518 return nativeResponseValue;
8520 // bool CResult_NodeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR o);
8522 export function CResult_NodeFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8523 if(!isWasmInitialized) {
8524 throw new Error("initializeWasm() must be awaited first!");
8526 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(o);
8527 return nativeResponseValue;
8529 // void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
8531 export function CResult_NodeFeaturesDecodeErrorZ_free(_res: number): void {
8532 if(!isWasmInitialized) {
8533 throw new Error("initializeWasm() must be awaited first!");
8535 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_free(_res);
8536 // debug statements here
8538 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_ok(struct LDKInvoiceFeatures o);
8540 export function CResult_InvoiceFeaturesDecodeErrorZ_ok(o: number): number {
8541 if(!isWasmInitialized) {
8542 throw new Error("initializeWasm() must be awaited first!");
8544 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_ok(o);
8545 return nativeResponseValue;
8547 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8549 export function CResult_InvoiceFeaturesDecodeErrorZ_err(e: number): number {
8550 if(!isWasmInitialized) {
8551 throw new Error("initializeWasm() must be awaited first!");
8553 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_err(e);
8554 return nativeResponseValue;
8556 // bool CResult_InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
8558 export function CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8559 if(!isWasmInitialized) {
8560 throw new Error("initializeWasm() must be awaited first!");
8562 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o);
8563 return nativeResponseValue;
8565 // void CResult_InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_InvoiceFeaturesDecodeErrorZ _res);
8567 export function CResult_InvoiceFeaturesDecodeErrorZ_free(_res: number): void {
8568 if(!isWasmInitialized) {
8569 throw new Error("initializeWasm() must be awaited first!");
8571 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_free(_res);
8572 // debug statements here
8574 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_ok(struct LDKChannelTypeFeatures o);
8576 export function CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o: number): number {
8577 if(!isWasmInitialized) {
8578 throw new Error("initializeWasm() must be awaited first!");
8580 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o);
8581 return nativeResponseValue;
8583 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8585 export function CResult_ChannelTypeFeaturesDecodeErrorZ_err(e: number): number {
8586 if(!isWasmInitialized) {
8587 throw new Error("initializeWasm() must be awaited first!");
8589 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(e);
8590 return nativeResponseValue;
8592 // bool CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR o);
8594 export function CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8595 if(!isWasmInitialized) {
8596 throw new Error("initializeWasm() must be awaited first!");
8598 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o);
8599 return nativeResponseValue;
8601 // void CResult_ChannelTypeFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res);
8603 export function CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res: number): void {
8604 if(!isWasmInitialized) {
8605 throw new Error("initializeWasm() must be awaited first!");
8607 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res);
8608 // debug statements here
8610 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKDelayedPaymentOutputDescriptor o);
8612 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o: number): number {
8613 if(!isWasmInitialized) {
8614 throw new Error("initializeWasm() must be awaited first!");
8616 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o);
8617 return nativeResponseValue;
8619 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
8621 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e: number): number {
8622 if(!isWasmInitialized) {
8623 throw new Error("initializeWasm() must be awaited first!");
8625 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e);
8626 return nativeResponseValue;
8628 // bool CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
8630 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
8631 if(!isWasmInitialized) {
8632 throw new Error("initializeWasm() must be awaited first!");
8634 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
8635 return nativeResponseValue;
8637 // void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res);
8639 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res: number): void {
8640 if(!isWasmInitialized) {
8641 throw new Error("initializeWasm() must be awaited first!");
8643 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res);
8644 // debug statements here
8646 // uintptr_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
8648 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
8649 if(!isWasmInitialized) {
8650 throw new Error("initializeWasm() must be awaited first!");
8652 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
8653 return nativeResponseValue;
8655 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
8657 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig: number): number {
8658 if(!isWasmInitialized) {
8659 throw new Error("initializeWasm() must be awaited first!");
8661 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig);
8662 return nativeResponseValue;
8664 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKStaticPaymentOutputDescriptor o);
8666 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o: number): number {
8667 if(!isWasmInitialized) {
8668 throw new Error("initializeWasm() must be awaited first!");
8670 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o);
8671 return nativeResponseValue;
8673 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
8675 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e: number): number {
8676 if(!isWasmInitialized) {
8677 throw new Error("initializeWasm() must be awaited first!");
8679 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e);
8680 return nativeResponseValue;
8682 // bool CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
8684 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
8685 if(!isWasmInitialized) {
8686 throw new Error("initializeWasm() must be awaited first!");
8688 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
8689 return nativeResponseValue;
8691 // void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res);
8693 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res: number): void {
8694 if(!isWasmInitialized) {
8695 throw new Error("initializeWasm() must be awaited first!");
8697 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res);
8698 // debug statements here
8700 // uintptr_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
8702 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
8703 if(!isWasmInitialized) {
8704 throw new Error("initializeWasm() must be awaited first!");
8706 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
8707 return nativeResponseValue;
8709 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
8711 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig: number): number {
8712 if(!isWasmInitialized) {
8713 throw new Error("initializeWasm() must be awaited first!");
8715 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig);
8716 return nativeResponseValue;
8718 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
8720 export function CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o: number): number {
8721 if(!isWasmInitialized) {
8722 throw new Error("initializeWasm() must be awaited first!");
8724 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o);
8725 return nativeResponseValue;
8727 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
8729 export function CResult_SpendableOutputDescriptorDecodeErrorZ_err(e: number): number {
8730 if(!isWasmInitialized) {
8731 throw new Error("initializeWasm() must be awaited first!");
8733 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(e);
8734 return nativeResponseValue;
8736 // bool CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
8738 export function CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
8739 if(!isWasmInitialized) {
8740 throw new Error("initializeWasm() must be awaited first!");
8742 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o);
8743 return nativeResponseValue;
8745 // void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
8747 export function CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: number): void {
8748 if(!isWasmInitialized) {
8749 throw new Error("initializeWasm() must be awaited first!");
8751 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res);
8752 // debug statements here
8754 // uintptr_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
8756 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
8757 if(!isWasmInitialized) {
8758 throw new Error("initializeWasm() must be awaited first!");
8760 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg);
8761 return nativeResponseValue;
8763 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
8765 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: number): number {
8766 if(!isWasmInitialized) {
8767 throw new Error("initializeWasm() must be awaited first!");
8769 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig);
8770 return nativeResponseValue;
8772 // void CVec_PaymentPreimageZ_free(struct LDKCVec_PaymentPreimageZ _res);
8774 export function CVec_PaymentPreimageZ_free(_res: number): void {
8775 if(!isWasmInitialized) {
8776 throw new Error("initializeWasm() must be awaited first!");
8778 const nativeResponseValue = wasm.TS_CVec_PaymentPreimageZ_free(_res);
8779 // debug statements here
8781 // uintptr_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg);
8783 export function C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg: number): number {
8784 if(!isWasmInitialized) {
8785 throw new Error("initializeWasm() must be awaited first!");
8787 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg);
8788 return nativeResponseValue;
8790 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_clone(const struct LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR orig);
8792 export function C2Tuple_SignatureCVec_SignatureZZ_clone(orig: number): number {
8793 if(!isWasmInitialized) {
8794 throw new Error("initializeWasm() must be awaited first!");
8796 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone(orig);
8797 return nativeResponseValue;
8799 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_new(struct LDKSignature a, struct LDKCVec_SignatureZ b);
8801 export function C2Tuple_SignatureCVec_SignatureZZ_new(a: number, b: number): number {
8802 if(!isWasmInitialized) {
8803 throw new Error("initializeWasm() must be awaited first!");
8805 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_new(a, b);
8806 return nativeResponseValue;
8808 // void C2Tuple_SignatureCVec_SignatureZZ_free(struct LDKC2Tuple_SignatureCVec_SignatureZZ _res);
8810 export function C2Tuple_SignatureCVec_SignatureZZ_free(_res: number): void {
8811 if(!isWasmInitialized) {
8812 throw new Error("initializeWasm() must be awaited first!");
8814 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_free(_res);
8815 // debug statements here
8817 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(struct LDKC2Tuple_SignatureCVec_SignatureZZ o);
8819 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o: number): number {
8820 if(!isWasmInitialized) {
8821 throw new Error("initializeWasm() must be awaited first!");
8823 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o);
8824 return nativeResponseValue;
8826 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(void);
8828 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(): number {
8829 if(!isWasmInitialized) {
8830 throw new Error("initializeWasm() must be awaited first!");
8832 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
8833 return nativeResponseValue;
8835 // bool CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR o);
8837 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o: number): boolean {
8838 if(!isWasmInitialized) {
8839 throw new Error("initializeWasm() must be awaited first!");
8841 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o);
8842 return nativeResponseValue;
8844 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res);
8846 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res: number): void {
8847 if(!isWasmInitialized) {
8848 throw new Error("initializeWasm() must be awaited first!");
8850 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res);
8851 // debug statements here
8853 // uintptr_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg);
8855 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg: number): number {
8856 if(!isWasmInitialized) {
8857 throw new Error("initializeWasm() must be awaited first!");
8859 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg);
8860 return nativeResponseValue;
8862 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR orig);
8864 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig: number): number {
8865 if(!isWasmInitialized) {
8866 throw new Error("initializeWasm() must be awaited first!");
8868 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig);
8869 return nativeResponseValue;
8871 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_ok(struct LDKSignature o);
8873 export function CResult_SignatureNoneZ_ok(o: number): number {
8874 if(!isWasmInitialized) {
8875 throw new Error("initializeWasm() must be awaited first!");
8877 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_ok(o);
8878 return nativeResponseValue;
8880 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_err(void);
8882 export function CResult_SignatureNoneZ_err(): number {
8883 if(!isWasmInitialized) {
8884 throw new Error("initializeWasm() must be awaited first!");
8886 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_err();
8887 return nativeResponseValue;
8889 // bool CResult_SignatureNoneZ_is_ok(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR o);
8891 export function CResult_SignatureNoneZ_is_ok(o: number): boolean {
8892 if(!isWasmInitialized) {
8893 throw new Error("initializeWasm() must be awaited first!");
8895 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_is_ok(o);
8896 return nativeResponseValue;
8898 // void CResult_SignatureNoneZ_free(struct LDKCResult_SignatureNoneZ _res);
8900 export function CResult_SignatureNoneZ_free(_res: number): void {
8901 if(!isWasmInitialized) {
8902 throw new Error("initializeWasm() must be awaited first!");
8904 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_free(_res);
8905 // debug statements here
8907 // uintptr_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg);
8909 export function CResult_SignatureNoneZ_clone_ptr(arg: number): number {
8910 if(!isWasmInitialized) {
8911 throw new Error("initializeWasm() must be awaited first!");
8913 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone_ptr(arg);
8914 return nativeResponseValue;
8916 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_clone(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR orig);
8918 export function CResult_SignatureNoneZ_clone(orig: number): number {
8919 if(!isWasmInitialized) {
8920 throw new Error("initializeWasm() must be awaited first!");
8922 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone(orig);
8923 return nativeResponseValue;
8925 // uintptr_t C2Tuple_SignatureSignatureZ_clone_ptr(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR arg);
8927 export function C2Tuple_SignatureSignatureZ_clone_ptr(arg: number): number {
8928 if(!isWasmInitialized) {
8929 throw new Error("initializeWasm() must be awaited first!");
8931 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_clone_ptr(arg);
8932 return nativeResponseValue;
8934 // struct LDKC2Tuple_SignatureSignatureZ C2Tuple_SignatureSignatureZ_clone(const struct LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR orig);
8936 export function C2Tuple_SignatureSignatureZ_clone(orig: number): number {
8937 if(!isWasmInitialized) {
8938 throw new Error("initializeWasm() must be awaited first!");
8940 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_clone(orig);
8941 return nativeResponseValue;
8943 // struct LDKC2Tuple_SignatureSignatureZ C2Tuple_SignatureSignatureZ_new(struct LDKSignature a, struct LDKSignature b);
8945 export function C2Tuple_SignatureSignatureZ_new(a: number, b: number): number {
8946 if(!isWasmInitialized) {
8947 throw new Error("initializeWasm() must be awaited first!");
8949 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_new(a, b);
8950 return nativeResponseValue;
8952 // void C2Tuple_SignatureSignatureZ_free(struct LDKC2Tuple_SignatureSignatureZ _res);
8954 export function C2Tuple_SignatureSignatureZ_free(_res: number): void {
8955 if(!isWasmInitialized) {
8956 throw new Error("initializeWasm() must be awaited first!");
8958 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_free(_res);
8959 // debug statements here
8961 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_ok(struct LDKC2Tuple_SignatureSignatureZ o);
8963 export function CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o: number): number {
8964 if(!isWasmInitialized) {
8965 throw new Error("initializeWasm() must be awaited first!");
8967 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o);
8968 return nativeResponseValue;
8970 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_err(void);
8972 export function CResult_C2Tuple_SignatureSignatureZNoneZ_err(): number {
8973 if(!isWasmInitialized) {
8974 throw new Error("initializeWasm() must be awaited first!");
8976 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_err();
8977 return nativeResponseValue;
8979 // bool CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR o);
8981 export function CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o: number): boolean {
8982 if(!isWasmInitialized) {
8983 throw new Error("initializeWasm() must be awaited first!");
8985 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o);
8986 return nativeResponseValue;
8988 // void CResult_C2Tuple_SignatureSignatureZNoneZ_free(struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ _res);
8990 export function CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res: number): void {
8991 if(!isWasmInitialized) {
8992 throw new Error("initializeWasm() must be awaited first!");
8994 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res);
8995 // debug statements here
8997 // uintptr_t CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR arg);
8999 export function CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg: number): number {
9000 if(!isWasmInitialized) {
9001 throw new Error("initializeWasm() must be awaited first!");
9003 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg);
9004 return nativeResponseValue;
9006 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR orig);
9008 export function CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig: number): number {
9009 if(!isWasmInitialized) {
9010 throw new Error("initializeWasm() must be awaited first!");
9012 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig);
9013 return nativeResponseValue;
9015 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_ok(struct LDKSecretKey o);
9017 export function CResult_SecretKeyNoneZ_ok(o: number): number {
9018 if(!isWasmInitialized) {
9019 throw new Error("initializeWasm() must be awaited first!");
9021 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_ok(o);
9022 return nativeResponseValue;
9024 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_err(void);
9026 export function CResult_SecretKeyNoneZ_err(): number {
9027 if(!isWasmInitialized) {
9028 throw new Error("initializeWasm() must be awaited first!");
9030 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_err();
9031 return nativeResponseValue;
9033 // bool CResult_SecretKeyNoneZ_is_ok(const struct LDKCResult_SecretKeyNoneZ *NONNULL_PTR o);
9035 export function CResult_SecretKeyNoneZ_is_ok(o: number): boolean {
9036 if(!isWasmInitialized) {
9037 throw new Error("initializeWasm() must be awaited first!");
9039 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_is_ok(o);
9040 return nativeResponseValue;
9042 // void CResult_SecretKeyNoneZ_free(struct LDKCResult_SecretKeyNoneZ _res);
9044 export function CResult_SecretKeyNoneZ_free(_res: number): void {
9045 if(!isWasmInitialized) {
9046 throw new Error("initializeWasm() must be awaited first!");
9048 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_free(_res);
9049 // debug statements here
9051 // uintptr_t CResult_SecretKeyNoneZ_clone_ptr(LDKCResult_SecretKeyNoneZ *NONNULL_PTR arg);
9053 export function CResult_SecretKeyNoneZ_clone_ptr(arg: number): number {
9054 if(!isWasmInitialized) {
9055 throw new Error("initializeWasm() must be awaited first!");
9057 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_clone_ptr(arg);
9058 return nativeResponseValue;
9060 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_clone(const struct LDKCResult_SecretKeyNoneZ *NONNULL_PTR orig);
9062 export function CResult_SecretKeyNoneZ_clone(orig: number): number {
9063 if(!isWasmInitialized) {
9064 throw new Error("initializeWasm() must be awaited first!");
9066 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_clone(orig);
9067 return nativeResponseValue;
9069 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_ok(struct LDKSign o);
9071 export function CResult_SignDecodeErrorZ_ok(o: number): number {
9072 if(!isWasmInitialized) {
9073 throw new Error("initializeWasm() must be awaited first!");
9075 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_ok(o);
9076 return nativeResponseValue;
9078 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_err(struct LDKDecodeError e);
9080 export function CResult_SignDecodeErrorZ_err(e: number): number {
9081 if(!isWasmInitialized) {
9082 throw new Error("initializeWasm() must be awaited first!");
9084 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_err(e);
9085 return nativeResponseValue;
9087 // bool CResult_SignDecodeErrorZ_is_ok(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR o);
9089 export function CResult_SignDecodeErrorZ_is_ok(o: number): boolean {
9090 if(!isWasmInitialized) {
9091 throw new Error("initializeWasm() must be awaited first!");
9093 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_is_ok(o);
9094 return nativeResponseValue;
9096 // void CResult_SignDecodeErrorZ_free(struct LDKCResult_SignDecodeErrorZ _res);
9098 export function CResult_SignDecodeErrorZ_free(_res: number): void {
9099 if(!isWasmInitialized) {
9100 throw new Error("initializeWasm() must be awaited first!");
9102 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_free(_res);
9103 // debug statements here
9105 // uintptr_t CResult_SignDecodeErrorZ_clone_ptr(LDKCResult_SignDecodeErrorZ *NONNULL_PTR arg);
9107 export function CResult_SignDecodeErrorZ_clone_ptr(arg: number): number {
9108 if(!isWasmInitialized) {
9109 throw new Error("initializeWasm() must be awaited first!");
9111 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone_ptr(arg);
9112 return nativeResponseValue;
9114 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_clone(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR orig);
9116 export function CResult_SignDecodeErrorZ_clone(orig: number): number {
9117 if(!isWasmInitialized) {
9118 throw new Error("initializeWasm() must be awaited first!");
9120 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone(orig);
9121 return nativeResponseValue;
9123 // void CVec_u5Z_free(struct LDKCVec_u5Z _res);
9125 export function CVec_u5Z_free(_res: number): void {
9126 if(!isWasmInitialized) {
9127 throw new Error("initializeWasm() must be awaited first!");
9129 const nativeResponseValue = wasm.TS_CVec_u5Z_free(_res);
9130 // debug statements here
9132 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_ok(struct LDKRecoverableSignature o);
9134 export function CResult_RecoverableSignatureNoneZ_ok(o: number): number {
9135 if(!isWasmInitialized) {
9136 throw new Error("initializeWasm() must be awaited first!");
9138 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_ok(o);
9139 return nativeResponseValue;
9141 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_err(void);
9143 export function CResult_RecoverableSignatureNoneZ_err(): number {
9144 if(!isWasmInitialized) {
9145 throw new Error("initializeWasm() must be awaited first!");
9147 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_err();
9148 return nativeResponseValue;
9150 // bool CResult_RecoverableSignatureNoneZ_is_ok(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR o);
9152 export function CResult_RecoverableSignatureNoneZ_is_ok(o: number): boolean {
9153 if(!isWasmInitialized) {
9154 throw new Error("initializeWasm() must be awaited first!");
9156 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_is_ok(o);
9157 return nativeResponseValue;
9159 // void CResult_RecoverableSignatureNoneZ_free(struct LDKCResult_RecoverableSignatureNoneZ _res);
9161 export function CResult_RecoverableSignatureNoneZ_free(_res: number): void {
9162 if(!isWasmInitialized) {
9163 throw new Error("initializeWasm() must be awaited first!");
9165 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_free(_res);
9166 // debug statements here
9168 // uintptr_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg);
9170 export function CResult_RecoverableSignatureNoneZ_clone_ptr(arg: number): number {
9171 if(!isWasmInitialized) {
9172 throw new Error("initializeWasm() must be awaited first!");
9174 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone_ptr(arg);
9175 return nativeResponseValue;
9177 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_clone(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR orig);
9179 export function CResult_RecoverableSignatureNoneZ_clone(orig: number): number {
9180 if(!isWasmInitialized) {
9181 throw new Error("initializeWasm() must be awaited first!");
9183 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone(orig);
9184 return nativeResponseValue;
9186 // void CVec_u8Z_free(struct LDKCVec_u8Z _res);
9188 export function CVec_u8Z_free(_res: number): void {
9189 if(!isWasmInitialized) {
9190 throw new Error("initializeWasm() must be awaited first!");
9192 const nativeResponseValue = wasm.TS_CVec_u8Z_free(_res);
9193 // debug statements here
9195 // void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
9197 export function CVec_CVec_u8ZZ_free(_res: number): void {
9198 if(!isWasmInitialized) {
9199 throw new Error("initializeWasm() must be awaited first!");
9201 const nativeResponseValue = wasm.TS_CVec_CVec_u8ZZ_free(_res);
9202 // debug statements here
9204 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_ok(struct LDKCVec_CVec_u8ZZ o);
9206 export function CResult_CVec_CVec_u8ZZNoneZ_ok(o: number): number {
9207 if(!isWasmInitialized) {
9208 throw new Error("initializeWasm() must be awaited first!");
9210 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_ok(o);
9211 return nativeResponseValue;
9213 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
9215 export function CResult_CVec_CVec_u8ZZNoneZ_err(): number {
9216 if(!isWasmInitialized) {
9217 throw new Error("initializeWasm() must be awaited first!");
9219 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_err();
9220 return nativeResponseValue;
9222 // bool CResult_CVec_CVec_u8ZZNoneZ_is_ok(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR o);
9224 export function CResult_CVec_CVec_u8ZZNoneZ_is_ok(o: number): boolean {
9225 if(!isWasmInitialized) {
9226 throw new Error("initializeWasm() must be awaited first!");
9228 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(o);
9229 return nativeResponseValue;
9231 // void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
9233 export function CResult_CVec_CVec_u8ZZNoneZ_free(_res: number): void {
9234 if(!isWasmInitialized) {
9235 throw new Error("initializeWasm() must be awaited first!");
9237 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_free(_res);
9238 // debug statements here
9240 // uintptr_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg);
9242 export function CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg: number): number {
9243 if(!isWasmInitialized) {
9244 throw new Error("initializeWasm() must be awaited first!");
9246 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg);
9247 return nativeResponseValue;
9249 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
9251 export function CResult_CVec_CVec_u8ZZNoneZ_clone(orig: number): number {
9252 if(!isWasmInitialized) {
9253 throw new Error("initializeWasm() must be awaited first!");
9255 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone(orig);
9256 return nativeResponseValue;
9258 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
9260 export function CResult_InMemorySignerDecodeErrorZ_ok(o: number): number {
9261 if(!isWasmInitialized) {
9262 throw new Error("initializeWasm() must be awaited first!");
9264 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_ok(o);
9265 return nativeResponseValue;
9267 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
9269 export function CResult_InMemorySignerDecodeErrorZ_err(e: number): number {
9270 if(!isWasmInitialized) {
9271 throw new Error("initializeWasm() must be awaited first!");
9273 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_err(e);
9274 return nativeResponseValue;
9276 // bool CResult_InMemorySignerDecodeErrorZ_is_ok(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR o);
9278 export function CResult_InMemorySignerDecodeErrorZ_is_ok(o: number): boolean {
9279 if(!isWasmInitialized) {
9280 throw new Error("initializeWasm() must be awaited first!");
9282 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_is_ok(o);
9283 return nativeResponseValue;
9285 // void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
9287 export function CResult_InMemorySignerDecodeErrorZ_free(_res: number): void {
9288 if(!isWasmInitialized) {
9289 throw new Error("initializeWasm() must be awaited first!");
9291 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_free(_res);
9292 // debug statements here
9294 // uintptr_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg);
9296 export function CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg: number): number {
9297 if(!isWasmInitialized) {
9298 throw new Error("initializeWasm() must be awaited first!");
9300 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg);
9301 return nativeResponseValue;
9303 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
9305 export function CResult_InMemorySignerDecodeErrorZ_clone(orig: number): number {
9306 if(!isWasmInitialized) {
9307 throw new Error("initializeWasm() must be awaited first!");
9309 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone(orig);
9310 return nativeResponseValue;
9312 // void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
9314 export function CVec_TxOutZ_free(_res: number): void {
9315 if(!isWasmInitialized) {
9316 throw new Error("initializeWasm() must be awaited first!");
9318 const nativeResponseValue = wasm.TS_CVec_TxOutZ_free(_res);
9319 // debug statements here
9321 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
9323 export function CResult_TransactionNoneZ_ok(o: number): number {
9324 if(!isWasmInitialized) {
9325 throw new Error("initializeWasm() must be awaited first!");
9327 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_ok(o);
9328 return nativeResponseValue;
9330 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
9332 export function CResult_TransactionNoneZ_err(): number {
9333 if(!isWasmInitialized) {
9334 throw new Error("initializeWasm() must be awaited first!");
9336 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_err();
9337 return nativeResponseValue;
9339 // bool CResult_TransactionNoneZ_is_ok(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR o);
9341 export function CResult_TransactionNoneZ_is_ok(o: number): boolean {
9342 if(!isWasmInitialized) {
9343 throw new Error("initializeWasm() must be awaited first!");
9345 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_is_ok(o);
9346 return nativeResponseValue;
9348 // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
9350 export function CResult_TransactionNoneZ_free(_res: number): void {
9351 if(!isWasmInitialized) {
9352 throw new Error("initializeWasm() must be awaited first!");
9354 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_free(_res);
9355 // debug statements here
9357 // uintptr_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg);
9359 export function CResult_TransactionNoneZ_clone_ptr(arg: number): number {
9360 if(!isWasmInitialized) {
9361 throw new Error("initializeWasm() must be awaited first!");
9363 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone_ptr(arg);
9364 return nativeResponseValue;
9366 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_clone(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR orig);
9368 export function CResult_TransactionNoneZ_clone(orig: number): number {
9369 if(!isWasmInitialized) {
9370 throw new Error("initializeWasm() must be awaited first!");
9372 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone(orig);
9373 return nativeResponseValue;
9375 // struct LDKCOption_u16Z COption_u16Z_some(uint16_t o);
9377 export function COption_u16Z_some(o: number): number {
9378 if(!isWasmInitialized) {
9379 throw new Error("initializeWasm() must be awaited first!");
9381 const nativeResponseValue = wasm.TS_COption_u16Z_some(o);
9382 return nativeResponseValue;
9384 // struct LDKCOption_u16Z COption_u16Z_none(void);
9386 export function COption_u16Z_none(): number {
9387 if(!isWasmInitialized) {
9388 throw new Error("initializeWasm() must be awaited first!");
9390 const nativeResponseValue = wasm.TS_COption_u16Z_none();
9391 return nativeResponseValue;
9393 // void COption_u16Z_free(struct LDKCOption_u16Z _res);
9395 export function COption_u16Z_free(_res: number): void {
9396 if(!isWasmInitialized) {
9397 throw new Error("initializeWasm() must be awaited first!");
9399 const nativeResponseValue = wasm.TS_COption_u16Z_free(_res);
9400 // debug statements here
9402 // uintptr_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg);
9404 export function COption_u16Z_clone_ptr(arg: number): number {
9405 if(!isWasmInitialized) {
9406 throw new Error("initializeWasm() must be awaited first!");
9408 const nativeResponseValue = wasm.TS_COption_u16Z_clone_ptr(arg);
9409 return nativeResponseValue;
9411 // struct LDKCOption_u16Z COption_u16Z_clone(const struct LDKCOption_u16Z *NONNULL_PTR orig);
9413 export function COption_u16Z_clone(orig: number): number {
9414 if(!isWasmInitialized) {
9415 throw new Error("initializeWasm() must be awaited first!");
9417 const nativeResponseValue = wasm.TS_COption_u16Z_clone(orig);
9418 return nativeResponseValue;
9420 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
9422 export function CResult_NoneAPIErrorZ_ok(): number {
9423 if(!isWasmInitialized) {
9424 throw new Error("initializeWasm() must be awaited first!");
9426 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_ok();
9427 return nativeResponseValue;
9429 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
9431 export function CResult_NoneAPIErrorZ_err(e: number): number {
9432 if(!isWasmInitialized) {
9433 throw new Error("initializeWasm() must be awaited first!");
9435 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_err(e);
9436 return nativeResponseValue;
9438 // bool CResult_NoneAPIErrorZ_is_ok(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR o);
9440 export function CResult_NoneAPIErrorZ_is_ok(o: number): boolean {
9441 if(!isWasmInitialized) {
9442 throw new Error("initializeWasm() must be awaited first!");
9444 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_is_ok(o);
9445 return nativeResponseValue;
9447 // void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
9449 export function CResult_NoneAPIErrorZ_free(_res: number): void {
9450 if(!isWasmInitialized) {
9451 throw new Error("initializeWasm() must be awaited first!");
9453 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_free(_res);
9454 // debug statements here
9456 // uintptr_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg);
9458 export function CResult_NoneAPIErrorZ_clone_ptr(arg: number): number {
9459 if(!isWasmInitialized) {
9460 throw new Error("initializeWasm() must be awaited first!");
9462 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone_ptr(arg);
9463 return nativeResponseValue;
9465 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
9467 export function CResult_NoneAPIErrorZ_clone(orig: number): number {
9468 if(!isWasmInitialized) {
9469 throw new Error("initializeWasm() must be awaited first!");
9471 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone(orig);
9472 return nativeResponseValue;
9474 // void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
9476 export function CVec_CResult_NoneAPIErrorZZ_free(_res: number): void {
9477 if(!isWasmInitialized) {
9478 throw new Error("initializeWasm() must be awaited first!");
9480 const nativeResponseValue = wasm.TS_CVec_CResult_NoneAPIErrorZZ_free(_res);
9481 // debug statements here
9483 // void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
9485 export function CVec_APIErrorZ_free(_res: number): void {
9486 if(!isWasmInitialized) {
9487 throw new Error("initializeWasm() must be awaited first!");
9489 const nativeResponseValue = wasm.TS_CVec_APIErrorZ_free(_res);
9490 // debug statements here
9492 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_ok(struct LDKThirtyTwoBytes o);
9494 export function CResult__u832APIErrorZ_ok(o: number): number {
9495 if(!isWasmInitialized) {
9496 throw new Error("initializeWasm() must be awaited first!");
9498 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_ok(o);
9499 return nativeResponseValue;
9501 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_err(struct LDKAPIError e);
9503 export function CResult__u832APIErrorZ_err(e: number): number {
9504 if(!isWasmInitialized) {
9505 throw new Error("initializeWasm() must be awaited first!");
9507 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_err(e);
9508 return nativeResponseValue;
9510 // bool CResult__u832APIErrorZ_is_ok(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR o);
9512 export function CResult__u832APIErrorZ_is_ok(o: number): boolean {
9513 if(!isWasmInitialized) {
9514 throw new Error("initializeWasm() must be awaited first!");
9516 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_is_ok(o);
9517 return nativeResponseValue;
9519 // void CResult__u832APIErrorZ_free(struct LDKCResult__u832APIErrorZ _res);
9521 export function CResult__u832APIErrorZ_free(_res: number): void {
9522 if(!isWasmInitialized) {
9523 throw new Error("initializeWasm() must be awaited first!");
9525 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_free(_res);
9526 // debug statements here
9528 // uintptr_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg);
9530 export function CResult__u832APIErrorZ_clone_ptr(arg: number): number {
9531 if(!isWasmInitialized) {
9532 throw new Error("initializeWasm() must be awaited first!");
9534 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone_ptr(arg);
9535 return nativeResponseValue;
9537 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_clone(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR orig);
9539 export function CResult__u832APIErrorZ_clone(orig: number): number {
9540 if(!isWasmInitialized) {
9541 throw new Error("initializeWasm() must be awaited first!");
9543 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone(orig);
9544 return nativeResponseValue;
9546 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_ok(struct LDKThirtyTwoBytes o);
9548 export function CResult_PaymentIdPaymentSendFailureZ_ok(o: number): number {
9549 if(!isWasmInitialized) {
9550 throw new Error("initializeWasm() must be awaited first!");
9552 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_ok(o);
9553 return nativeResponseValue;
9555 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
9557 export function CResult_PaymentIdPaymentSendFailureZ_err(e: number): number {
9558 if(!isWasmInitialized) {
9559 throw new Error("initializeWasm() must be awaited first!");
9561 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_err(e);
9562 return nativeResponseValue;
9564 // bool CResult_PaymentIdPaymentSendFailureZ_is_ok(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR o);
9566 export function CResult_PaymentIdPaymentSendFailureZ_is_ok(o: number): boolean {
9567 if(!isWasmInitialized) {
9568 throw new Error("initializeWasm() must be awaited first!");
9570 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_is_ok(o);
9571 return nativeResponseValue;
9573 // void CResult_PaymentIdPaymentSendFailureZ_free(struct LDKCResult_PaymentIdPaymentSendFailureZ _res);
9575 export function CResult_PaymentIdPaymentSendFailureZ_free(_res: number): void {
9576 if(!isWasmInitialized) {
9577 throw new Error("initializeWasm() must be awaited first!");
9579 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_free(_res);
9580 // debug statements here
9582 // uintptr_t CResult_PaymentIdPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR arg);
9584 export function CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg: number): number {
9585 if(!isWasmInitialized) {
9586 throw new Error("initializeWasm() must be awaited first!");
9588 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg);
9589 return nativeResponseValue;
9591 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_clone(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR orig);
9593 export function CResult_PaymentIdPaymentSendFailureZ_clone(orig: number): number {
9594 if(!isWasmInitialized) {
9595 throw new Error("initializeWasm() must be awaited first!");
9597 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone(orig);
9598 return nativeResponseValue;
9600 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
9602 export function CResult_NonePaymentSendFailureZ_ok(): number {
9603 if(!isWasmInitialized) {
9604 throw new Error("initializeWasm() must be awaited first!");
9606 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_ok();
9607 return nativeResponseValue;
9609 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
9611 export function CResult_NonePaymentSendFailureZ_err(e: number): number {
9612 if(!isWasmInitialized) {
9613 throw new Error("initializeWasm() must be awaited first!");
9615 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_err(e);
9616 return nativeResponseValue;
9618 // bool CResult_NonePaymentSendFailureZ_is_ok(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR o);
9620 export function CResult_NonePaymentSendFailureZ_is_ok(o: number): boolean {
9621 if(!isWasmInitialized) {
9622 throw new Error("initializeWasm() must be awaited first!");
9624 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_is_ok(o);
9625 return nativeResponseValue;
9627 // void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
9629 export function CResult_NonePaymentSendFailureZ_free(_res: number): void {
9630 if(!isWasmInitialized) {
9631 throw new Error("initializeWasm() must be awaited first!");
9633 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_free(_res);
9634 // debug statements here
9636 // uintptr_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg);
9638 export function CResult_NonePaymentSendFailureZ_clone_ptr(arg: number): number {
9639 if(!isWasmInitialized) {
9640 throw new Error("initializeWasm() must be awaited first!");
9642 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone_ptr(arg);
9643 return nativeResponseValue;
9645 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
9647 export function CResult_NonePaymentSendFailureZ_clone(orig: number): number {
9648 if(!isWasmInitialized) {
9649 throw new Error("initializeWasm() must be awaited first!");
9651 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone(orig);
9652 return nativeResponseValue;
9654 // uintptr_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg);
9656 export function C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg: number): number {
9657 if(!isWasmInitialized) {
9658 throw new Error("initializeWasm() must be awaited first!");
9660 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg);
9661 return nativeResponseValue;
9663 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_clone(const struct LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR orig);
9665 export function C2Tuple_PaymentHashPaymentIdZ_clone(orig: number): number {
9666 if(!isWasmInitialized) {
9667 throw new Error("initializeWasm() must be awaited first!");
9669 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone(orig);
9670 return nativeResponseValue;
9672 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
9674 export function C2Tuple_PaymentHashPaymentIdZ_new(a: number, b: number): number {
9675 if(!isWasmInitialized) {
9676 throw new Error("initializeWasm() must be awaited first!");
9678 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_new(a, b);
9679 return nativeResponseValue;
9681 // void C2Tuple_PaymentHashPaymentIdZ_free(struct LDKC2Tuple_PaymentHashPaymentIdZ _res);
9683 export function C2Tuple_PaymentHashPaymentIdZ_free(_res: number): void {
9684 if(!isWasmInitialized) {
9685 throw new Error("initializeWasm() must be awaited first!");
9687 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_free(_res);
9688 // debug statements here
9690 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(struct LDKC2Tuple_PaymentHashPaymentIdZ o);
9692 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o: number): number {
9693 if(!isWasmInitialized) {
9694 throw new Error("initializeWasm() must be awaited first!");
9696 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o);
9697 return nativeResponseValue;
9699 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
9701 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e: number): number {
9702 if(!isWasmInitialized) {
9703 throw new Error("initializeWasm() must be awaited first!");
9705 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e);
9706 return nativeResponseValue;
9708 // bool CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR o);
9710 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o: number): boolean {
9711 if(!isWasmInitialized) {
9712 throw new Error("initializeWasm() must be awaited first!");
9714 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o);
9715 return nativeResponseValue;
9717 // void CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ _res);
9719 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res: number): void {
9720 if(!isWasmInitialized) {
9721 throw new Error("initializeWasm() must be awaited first!");
9723 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res);
9724 // debug statements here
9726 // uintptr_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg);
9728 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg: number): number {
9729 if(!isWasmInitialized) {
9730 throw new Error("initializeWasm() must be awaited first!");
9732 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg);
9733 return nativeResponseValue;
9735 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR orig);
9737 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig: number): number {
9738 if(!isWasmInitialized) {
9739 throw new Error("initializeWasm() must be awaited first!");
9741 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig);
9742 return nativeResponseValue;
9744 // void CVec_NetAddressZ_free(struct LDKCVec_NetAddressZ _res);
9746 export function CVec_NetAddressZ_free(_res: number): void {
9747 if(!isWasmInitialized) {
9748 throw new Error("initializeWasm() must be awaited first!");
9750 const nativeResponseValue = wasm.TS_CVec_NetAddressZ_free(_res);
9751 // debug statements here
9753 // uintptr_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg);
9755 export function C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg: number): number {
9756 if(!isWasmInitialized) {
9757 throw new Error("initializeWasm() must be awaited first!");
9759 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg);
9760 return nativeResponseValue;
9762 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_clone(const struct LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR orig);
9764 export function C2Tuple_PaymentHashPaymentSecretZ_clone(orig: number): number {
9765 if(!isWasmInitialized) {
9766 throw new Error("initializeWasm() must be awaited first!");
9768 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone(orig);
9769 return nativeResponseValue;
9771 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
9773 export function C2Tuple_PaymentHashPaymentSecretZ_new(a: number, b: number): number {
9774 if(!isWasmInitialized) {
9775 throw new Error("initializeWasm() must be awaited first!");
9777 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_new(a, b);
9778 return nativeResponseValue;
9780 // void C2Tuple_PaymentHashPaymentSecretZ_free(struct LDKC2Tuple_PaymentHashPaymentSecretZ _res);
9782 export function C2Tuple_PaymentHashPaymentSecretZ_free(_res: number): void {
9783 if(!isWasmInitialized) {
9784 throw new Error("initializeWasm() must be awaited first!");
9786 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_free(_res);
9787 // debug statements here
9789 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
9791 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o: number): number {
9792 if(!isWasmInitialized) {
9793 throw new Error("initializeWasm() must be awaited first!");
9795 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o);
9796 return nativeResponseValue;
9798 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(void);
9800 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(): number {
9801 if(!isWasmInitialized) {
9802 throw new Error("initializeWasm() must be awaited first!");
9804 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err();
9805 return nativeResponseValue;
9807 // bool CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR o);
9809 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o: number): boolean {
9810 if(!isWasmInitialized) {
9811 throw new Error("initializeWasm() must be awaited first!");
9813 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o);
9814 return nativeResponseValue;
9816 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ _res);
9818 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res: number): void {
9819 if(!isWasmInitialized) {
9820 throw new Error("initializeWasm() must be awaited first!");
9822 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res);
9823 // debug statements here
9825 // uintptr_t CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR arg);
9827 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg: number): number {
9828 if(!isWasmInitialized) {
9829 throw new Error("initializeWasm() must be awaited first!");
9831 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg);
9832 return nativeResponseValue;
9834 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR orig);
9836 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig: number): number {
9837 if(!isWasmInitialized) {
9838 throw new Error("initializeWasm() must be awaited first!");
9840 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig);
9841 return nativeResponseValue;
9843 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
9845 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o: number): number {
9846 if(!isWasmInitialized) {
9847 throw new Error("initializeWasm() must be awaited first!");
9849 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o);
9850 return nativeResponseValue;
9852 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(struct LDKAPIError e);
9854 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e: number): number {
9855 if(!isWasmInitialized) {
9856 throw new Error("initializeWasm() must be awaited first!");
9858 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e);
9859 return nativeResponseValue;
9861 // bool CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR o);
9863 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o: number): boolean {
9864 if(!isWasmInitialized) {
9865 throw new Error("initializeWasm() must be awaited first!");
9867 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o);
9868 return nativeResponseValue;
9870 // void CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ _res);
9872 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res: number): void {
9873 if(!isWasmInitialized) {
9874 throw new Error("initializeWasm() must be awaited first!");
9876 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res);
9877 // debug statements here
9879 // uintptr_t CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR arg);
9881 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg: number): number {
9882 if(!isWasmInitialized) {
9883 throw new Error("initializeWasm() must be awaited first!");
9885 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg);
9886 return nativeResponseValue;
9888 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR orig);
9890 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig: number): number {
9891 if(!isWasmInitialized) {
9892 throw new Error("initializeWasm() must be awaited first!");
9894 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig);
9895 return nativeResponseValue;
9897 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_ok(struct LDKThirtyTwoBytes o);
9899 export function CResult_PaymentSecretNoneZ_ok(o: number): number {
9900 if(!isWasmInitialized) {
9901 throw new Error("initializeWasm() must be awaited first!");
9903 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_ok(o);
9904 return nativeResponseValue;
9906 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_err(void);
9908 export function CResult_PaymentSecretNoneZ_err(): number {
9909 if(!isWasmInitialized) {
9910 throw new Error("initializeWasm() must be awaited first!");
9912 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_err();
9913 return nativeResponseValue;
9915 // bool CResult_PaymentSecretNoneZ_is_ok(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR o);
9917 export function CResult_PaymentSecretNoneZ_is_ok(o: number): boolean {
9918 if(!isWasmInitialized) {
9919 throw new Error("initializeWasm() must be awaited first!");
9921 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_is_ok(o);
9922 return nativeResponseValue;
9924 // void CResult_PaymentSecretNoneZ_free(struct LDKCResult_PaymentSecretNoneZ _res);
9926 export function CResult_PaymentSecretNoneZ_free(_res: number): void {
9927 if(!isWasmInitialized) {
9928 throw new Error("initializeWasm() must be awaited first!");
9930 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_free(_res);
9931 // debug statements here
9933 // uintptr_t CResult_PaymentSecretNoneZ_clone_ptr(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR arg);
9935 export function CResult_PaymentSecretNoneZ_clone_ptr(arg: number): number {
9936 if(!isWasmInitialized) {
9937 throw new Error("initializeWasm() must be awaited first!");
9939 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone_ptr(arg);
9940 return nativeResponseValue;
9942 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_clone(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR orig);
9944 export function CResult_PaymentSecretNoneZ_clone(orig: number): number {
9945 if(!isWasmInitialized) {
9946 throw new Error("initializeWasm() must be awaited first!");
9948 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone(orig);
9949 return nativeResponseValue;
9951 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
9953 export function CResult_PaymentSecretAPIErrorZ_ok(o: number): number {
9954 if(!isWasmInitialized) {
9955 throw new Error("initializeWasm() must be awaited first!");
9957 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_ok(o);
9958 return nativeResponseValue;
9960 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_err(struct LDKAPIError e);
9962 export function CResult_PaymentSecretAPIErrorZ_err(e: number): number {
9963 if(!isWasmInitialized) {
9964 throw new Error("initializeWasm() must be awaited first!");
9966 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_err(e);
9967 return nativeResponseValue;
9969 // bool CResult_PaymentSecretAPIErrorZ_is_ok(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR o);
9971 export function CResult_PaymentSecretAPIErrorZ_is_ok(o: number): boolean {
9972 if(!isWasmInitialized) {
9973 throw new Error("initializeWasm() must be awaited first!");
9975 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_is_ok(o);
9976 return nativeResponseValue;
9978 // void CResult_PaymentSecretAPIErrorZ_free(struct LDKCResult_PaymentSecretAPIErrorZ _res);
9980 export function CResult_PaymentSecretAPIErrorZ_free(_res: number): void {
9981 if(!isWasmInitialized) {
9982 throw new Error("initializeWasm() must be awaited first!");
9984 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_free(_res);
9985 // debug statements here
9987 // uintptr_t CResult_PaymentSecretAPIErrorZ_clone_ptr(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR arg);
9989 export function CResult_PaymentSecretAPIErrorZ_clone_ptr(arg: number): number {
9990 if(!isWasmInitialized) {
9991 throw new Error("initializeWasm() must be awaited first!");
9993 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone_ptr(arg);
9994 return nativeResponseValue;
9996 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_clone(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR orig);
9998 export function CResult_PaymentSecretAPIErrorZ_clone(orig: number): number {
9999 if(!isWasmInitialized) {
10000 throw new Error("initializeWasm() must be awaited first!");
10002 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone(orig);
10003 return nativeResponseValue;
10005 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
10007 export function CResult_PaymentPreimageAPIErrorZ_ok(o: number): number {
10008 if(!isWasmInitialized) {
10009 throw new Error("initializeWasm() must be awaited first!");
10011 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_ok(o);
10012 return nativeResponseValue;
10014 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_err(struct LDKAPIError e);
10016 export function CResult_PaymentPreimageAPIErrorZ_err(e: number): number {
10017 if(!isWasmInitialized) {
10018 throw new Error("initializeWasm() must be awaited first!");
10020 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_err(e);
10021 return nativeResponseValue;
10023 // bool CResult_PaymentPreimageAPIErrorZ_is_ok(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR o);
10025 export function CResult_PaymentPreimageAPIErrorZ_is_ok(o: number): boolean {
10026 if(!isWasmInitialized) {
10027 throw new Error("initializeWasm() must be awaited first!");
10029 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_is_ok(o);
10030 return nativeResponseValue;
10032 // void CResult_PaymentPreimageAPIErrorZ_free(struct LDKCResult_PaymentPreimageAPIErrorZ _res);
10034 export function CResult_PaymentPreimageAPIErrorZ_free(_res: number): void {
10035 if(!isWasmInitialized) {
10036 throw new Error("initializeWasm() must be awaited first!");
10038 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_free(_res);
10039 // debug statements here
10041 // uintptr_t CResult_PaymentPreimageAPIErrorZ_clone_ptr(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR arg);
10043 export function CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg: number): number {
10044 if(!isWasmInitialized) {
10045 throw new Error("initializeWasm() must be awaited first!");
10047 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg);
10048 return nativeResponseValue;
10050 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_clone(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR orig);
10052 export function CResult_PaymentPreimageAPIErrorZ_clone(orig: number): number {
10053 if(!isWasmInitialized) {
10054 throw new Error("initializeWasm() must be awaited first!");
10056 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone(orig);
10057 return nativeResponseValue;
10059 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(struct LDKCounterpartyForwardingInfo o);
10061 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o: number): number {
10062 if(!isWasmInitialized) {
10063 throw new Error("initializeWasm() must be awaited first!");
10065 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o);
10066 return nativeResponseValue;
10068 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_err(struct LDKDecodeError e);
10070 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e: number): number {
10071 if(!isWasmInitialized) {
10072 throw new Error("initializeWasm() must be awaited first!");
10074 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e);
10075 return nativeResponseValue;
10077 // bool CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR o);
10079 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o: number): boolean {
10080 if(!isWasmInitialized) {
10081 throw new Error("initializeWasm() must be awaited first!");
10083 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o);
10084 return nativeResponseValue;
10086 // void CResult_CounterpartyForwardingInfoDecodeErrorZ_free(struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ _res);
10088 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res: number): void {
10089 if(!isWasmInitialized) {
10090 throw new Error("initializeWasm() must be awaited first!");
10092 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res);
10093 // debug statements here
10095 // uintptr_t CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR arg);
10097 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg: number): number {
10098 if(!isWasmInitialized) {
10099 throw new Error("initializeWasm() must be awaited first!");
10101 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg);
10102 return nativeResponseValue;
10104 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR orig);
10106 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig: number): number {
10107 if(!isWasmInitialized) {
10108 throw new Error("initializeWasm() must be awaited first!");
10110 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig);
10111 return nativeResponseValue;
10113 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_ok(struct LDKChannelCounterparty o);
10115 export function CResult_ChannelCounterpartyDecodeErrorZ_ok(o: number): number {
10116 if(!isWasmInitialized) {
10117 throw new Error("initializeWasm() must be awaited first!");
10119 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_ok(o);
10120 return nativeResponseValue;
10122 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_err(struct LDKDecodeError e);
10124 export function CResult_ChannelCounterpartyDecodeErrorZ_err(e: number): number {
10125 if(!isWasmInitialized) {
10126 throw new Error("initializeWasm() must be awaited first!");
10128 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_err(e);
10129 return nativeResponseValue;
10131 // bool CResult_ChannelCounterpartyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR o);
10133 export function CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o: number): boolean {
10134 if(!isWasmInitialized) {
10135 throw new Error("initializeWasm() must be awaited first!");
10137 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o);
10138 return nativeResponseValue;
10140 // void CResult_ChannelCounterpartyDecodeErrorZ_free(struct LDKCResult_ChannelCounterpartyDecodeErrorZ _res);
10142 export function CResult_ChannelCounterpartyDecodeErrorZ_free(_res: number): void {
10143 if(!isWasmInitialized) {
10144 throw new Error("initializeWasm() must be awaited first!");
10146 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_free(_res);
10147 // debug statements here
10149 // uintptr_t CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR arg);
10151 export function CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg: number): number {
10152 if(!isWasmInitialized) {
10153 throw new Error("initializeWasm() must be awaited first!");
10155 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg);
10156 return nativeResponseValue;
10158 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_clone(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR orig);
10160 export function CResult_ChannelCounterpartyDecodeErrorZ_clone(orig: number): number {
10161 if(!isWasmInitialized) {
10162 throw new Error("initializeWasm() must be awaited first!");
10164 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone(orig);
10165 return nativeResponseValue;
10167 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_ok(struct LDKChannelDetails o);
10169 export function CResult_ChannelDetailsDecodeErrorZ_ok(o: number): number {
10170 if(!isWasmInitialized) {
10171 throw new Error("initializeWasm() must be awaited first!");
10173 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_ok(o);
10174 return nativeResponseValue;
10176 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_err(struct LDKDecodeError e);
10178 export function CResult_ChannelDetailsDecodeErrorZ_err(e: number): number {
10179 if(!isWasmInitialized) {
10180 throw new Error("initializeWasm() must be awaited first!");
10182 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_err(e);
10183 return nativeResponseValue;
10185 // bool CResult_ChannelDetailsDecodeErrorZ_is_ok(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR o);
10187 export function CResult_ChannelDetailsDecodeErrorZ_is_ok(o: number): boolean {
10188 if(!isWasmInitialized) {
10189 throw new Error("initializeWasm() must be awaited first!");
10191 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_is_ok(o);
10192 return nativeResponseValue;
10194 // void CResult_ChannelDetailsDecodeErrorZ_free(struct LDKCResult_ChannelDetailsDecodeErrorZ _res);
10196 export function CResult_ChannelDetailsDecodeErrorZ_free(_res: number): void {
10197 if(!isWasmInitialized) {
10198 throw new Error("initializeWasm() must be awaited first!");
10200 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_free(_res);
10201 // debug statements here
10203 // uintptr_t CResult_ChannelDetailsDecodeErrorZ_clone_ptr(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR arg);
10205 export function CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg: number): number {
10206 if(!isWasmInitialized) {
10207 throw new Error("initializeWasm() must be awaited first!");
10209 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg);
10210 return nativeResponseValue;
10212 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_clone(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR orig);
10214 export function CResult_ChannelDetailsDecodeErrorZ_clone(orig: number): number {
10215 if(!isWasmInitialized) {
10216 throw new Error("initializeWasm() must be awaited first!");
10218 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone(orig);
10219 return nativeResponseValue;
10221 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_ok(struct LDKPhantomRouteHints o);
10223 export function CResult_PhantomRouteHintsDecodeErrorZ_ok(o: number): number {
10224 if(!isWasmInitialized) {
10225 throw new Error("initializeWasm() must be awaited first!");
10227 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_ok(o);
10228 return nativeResponseValue;
10230 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_err(struct LDKDecodeError e);
10232 export function CResult_PhantomRouteHintsDecodeErrorZ_err(e: number): number {
10233 if(!isWasmInitialized) {
10234 throw new Error("initializeWasm() must be awaited first!");
10236 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_err(e);
10237 return nativeResponseValue;
10239 // bool CResult_PhantomRouteHintsDecodeErrorZ_is_ok(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR o);
10241 export function CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o: number): boolean {
10242 if(!isWasmInitialized) {
10243 throw new Error("initializeWasm() must be awaited first!");
10245 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o);
10246 return nativeResponseValue;
10248 // void CResult_PhantomRouteHintsDecodeErrorZ_free(struct LDKCResult_PhantomRouteHintsDecodeErrorZ _res);
10250 export function CResult_PhantomRouteHintsDecodeErrorZ_free(_res: number): void {
10251 if(!isWasmInitialized) {
10252 throw new Error("initializeWasm() must be awaited first!");
10254 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_free(_res);
10255 // debug statements here
10257 // uintptr_t CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR arg);
10259 export function CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg: number): number {
10260 if(!isWasmInitialized) {
10261 throw new Error("initializeWasm() must be awaited first!");
10263 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg);
10264 return nativeResponseValue;
10266 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_clone(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR orig);
10268 export function CResult_PhantomRouteHintsDecodeErrorZ_clone(orig: number): number {
10269 if(!isWasmInitialized) {
10270 throw new Error("initializeWasm() must be awaited first!");
10272 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone(orig);
10273 return nativeResponseValue;
10275 // void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
10277 export function CVec_ChannelMonitorZ_free(_res: number): void {
10278 if(!isWasmInitialized) {
10279 throw new Error("initializeWasm() must be awaited first!");
10281 const nativeResponseValue = wasm.TS_CVec_ChannelMonitorZ_free(_res);
10282 // debug statements here
10284 // struct LDKC2Tuple_BlockHashChannelManagerZ C2Tuple_BlockHashChannelManagerZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelManager b);
10286 export function C2Tuple_BlockHashChannelManagerZ_new(a: number, b: number): number {
10287 if(!isWasmInitialized) {
10288 throw new Error("initializeWasm() must be awaited first!");
10290 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_new(a, b);
10291 return nativeResponseValue;
10293 // void C2Tuple_BlockHashChannelManagerZ_free(struct LDKC2Tuple_BlockHashChannelManagerZ _res);
10295 export function C2Tuple_BlockHashChannelManagerZ_free(_res: number): void {
10296 if(!isWasmInitialized) {
10297 throw new Error("initializeWasm() must be awaited first!");
10299 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_free(_res);
10300 // debug statements here
10302 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelManagerZ o);
10304 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o: number): number {
10305 if(!isWasmInitialized) {
10306 throw new Error("initializeWasm() must be awaited first!");
10308 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o);
10309 return nativeResponseValue;
10311 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
10313 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e: number): number {
10314 if(!isWasmInitialized) {
10315 throw new Error("initializeWasm() must be awaited first!");
10317 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e);
10318 return nativeResponseValue;
10320 // bool CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR o);
10322 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o: number): boolean {
10323 if(!isWasmInitialized) {
10324 throw new Error("initializeWasm() must be awaited first!");
10326 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o);
10327 return nativeResponseValue;
10329 // void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res);
10331 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res: number): void {
10332 if(!isWasmInitialized) {
10333 throw new Error("initializeWasm() must be awaited first!");
10335 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res);
10336 // debug statements here
10338 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
10340 export function CResult_ChannelConfigDecodeErrorZ_ok(o: number): number {
10341 if(!isWasmInitialized) {
10342 throw new Error("initializeWasm() must be awaited first!");
10344 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_ok(o);
10345 return nativeResponseValue;
10347 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
10349 export function CResult_ChannelConfigDecodeErrorZ_err(e: number): number {
10350 if(!isWasmInitialized) {
10351 throw new Error("initializeWasm() must be awaited first!");
10353 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_err(e);
10354 return nativeResponseValue;
10356 // bool CResult_ChannelConfigDecodeErrorZ_is_ok(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR o);
10358 export function CResult_ChannelConfigDecodeErrorZ_is_ok(o: number): boolean {
10359 if(!isWasmInitialized) {
10360 throw new Error("initializeWasm() must be awaited first!");
10362 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_is_ok(o);
10363 return nativeResponseValue;
10365 // void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
10367 export function CResult_ChannelConfigDecodeErrorZ_free(_res: number): void {
10368 if(!isWasmInitialized) {
10369 throw new Error("initializeWasm() must be awaited first!");
10371 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_free(_res);
10372 // debug statements here
10374 // uintptr_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg);
10376 export function CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg: number): number {
10377 if(!isWasmInitialized) {
10378 throw new Error("initializeWasm() must be awaited first!");
10380 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg);
10381 return nativeResponseValue;
10383 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
10385 export function CResult_ChannelConfigDecodeErrorZ_clone(orig: number): number {
10386 if(!isWasmInitialized) {
10387 throw new Error("initializeWasm() must be awaited first!");
10389 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone(orig);
10390 return nativeResponseValue;
10392 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
10394 export function CResult_OutPointDecodeErrorZ_ok(o: number): number {
10395 if(!isWasmInitialized) {
10396 throw new Error("initializeWasm() must be awaited first!");
10398 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_ok(o);
10399 return nativeResponseValue;
10401 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
10403 export function CResult_OutPointDecodeErrorZ_err(e: number): number {
10404 if(!isWasmInitialized) {
10405 throw new Error("initializeWasm() must be awaited first!");
10407 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_err(e);
10408 return nativeResponseValue;
10410 // bool CResult_OutPointDecodeErrorZ_is_ok(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR o);
10412 export function CResult_OutPointDecodeErrorZ_is_ok(o: number): boolean {
10413 if(!isWasmInitialized) {
10414 throw new Error("initializeWasm() must be awaited first!");
10416 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_is_ok(o);
10417 return nativeResponseValue;
10419 // void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
10421 export function CResult_OutPointDecodeErrorZ_free(_res: number): void {
10422 if(!isWasmInitialized) {
10423 throw new Error("initializeWasm() must be awaited first!");
10425 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_free(_res);
10426 // debug statements here
10428 // uintptr_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg);
10430 export function CResult_OutPointDecodeErrorZ_clone_ptr(arg: number): number {
10431 if(!isWasmInitialized) {
10432 throw new Error("initializeWasm() must be awaited first!");
10434 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone_ptr(arg);
10435 return nativeResponseValue;
10437 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
10439 export function CResult_OutPointDecodeErrorZ_clone(orig: number): number {
10440 if(!isWasmInitialized) {
10441 throw new Error("initializeWasm() must be awaited first!");
10443 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone(orig);
10444 return nativeResponseValue;
10446 // struct LDKCOption_TypeZ COption_TypeZ_some(struct LDKType o);
10448 export function COption_TypeZ_some(o: number): number {
10449 if(!isWasmInitialized) {
10450 throw new Error("initializeWasm() must be awaited first!");
10452 const nativeResponseValue = wasm.TS_COption_TypeZ_some(o);
10453 return nativeResponseValue;
10455 // struct LDKCOption_TypeZ COption_TypeZ_none(void);
10457 export function COption_TypeZ_none(): number {
10458 if(!isWasmInitialized) {
10459 throw new Error("initializeWasm() must be awaited first!");
10461 const nativeResponseValue = wasm.TS_COption_TypeZ_none();
10462 return nativeResponseValue;
10464 // void COption_TypeZ_free(struct LDKCOption_TypeZ _res);
10466 export function COption_TypeZ_free(_res: number): void {
10467 if(!isWasmInitialized) {
10468 throw new Error("initializeWasm() must be awaited first!");
10470 const nativeResponseValue = wasm.TS_COption_TypeZ_free(_res);
10471 // debug statements here
10473 // uintptr_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg);
10475 export function COption_TypeZ_clone_ptr(arg: number): number {
10476 if(!isWasmInitialized) {
10477 throw new Error("initializeWasm() must be awaited first!");
10479 const nativeResponseValue = wasm.TS_COption_TypeZ_clone_ptr(arg);
10480 return nativeResponseValue;
10482 // struct LDKCOption_TypeZ COption_TypeZ_clone(const struct LDKCOption_TypeZ *NONNULL_PTR orig);
10484 export function COption_TypeZ_clone(orig: number): number {
10485 if(!isWasmInitialized) {
10486 throw new Error("initializeWasm() must be awaited first!");
10488 const nativeResponseValue = wasm.TS_COption_TypeZ_clone(orig);
10489 return nativeResponseValue;
10491 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_ok(struct LDKCOption_TypeZ o);
10493 export function CResult_COption_TypeZDecodeErrorZ_ok(o: number): number {
10494 if(!isWasmInitialized) {
10495 throw new Error("initializeWasm() must be awaited first!");
10497 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_ok(o);
10498 return nativeResponseValue;
10500 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_err(struct LDKDecodeError e);
10502 export function CResult_COption_TypeZDecodeErrorZ_err(e: number): number {
10503 if(!isWasmInitialized) {
10504 throw new Error("initializeWasm() must be awaited first!");
10506 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_err(e);
10507 return nativeResponseValue;
10509 // bool CResult_COption_TypeZDecodeErrorZ_is_ok(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR o);
10511 export function CResult_COption_TypeZDecodeErrorZ_is_ok(o: number): boolean {
10512 if(!isWasmInitialized) {
10513 throw new Error("initializeWasm() must be awaited first!");
10515 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_is_ok(o);
10516 return nativeResponseValue;
10518 // void CResult_COption_TypeZDecodeErrorZ_free(struct LDKCResult_COption_TypeZDecodeErrorZ _res);
10520 export function CResult_COption_TypeZDecodeErrorZ_free(_res: number): void {
10521 if(!isWasmInitialized) {
10522 throw new Error("initializeWasm() must be awaited first!");
10524 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_free(_res);
10525 // debug statements here
10527 // uintptr_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg);
10529 export function CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg: number): number {
10530 if(!isWasmInitialized) {
10531 throw new Error("initializeWasm() must be awaited first!");
10533 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg);
10534 return nativeResponseValue;
10536 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_clone(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR orig);
10538 export function CResult_COption_TypeZDecodeErrorZ_clone(orig: number): number {
10539 if(!isWasmInitialized) {
10540 throw new Error("initializeWasm() must be awaited first!");
10542 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone(orig);
10543 return nativeResponseValue;
10545 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_ok(struct LDKThirtyTwoBytes o);
10547 export function CResult_PaymentIdPaymentErrorZ_ok(o: number): number {
10548 if(!isWasmInitialized) {
10549 throw new Error("initializeWasm() must be awaited first!");
10551 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_ok(o);
10552 return nativeResponseValue;
10554 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_err(struct LDKPaymentError e);
10556 export function CResult_PaymentIdPaymentErrorZ_err(e: number): number {
10557 if(!isWasmInitialized) {
10558 throw new Error("initializeWasm() must be awaited first!");
10560 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_err(e);
10561 return nativeResponseValue;
10563 // bool CResult_PaymentIdPaymentErrorZ_is_ok(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR o);
10565 export function CResult_PaymentIdPaymentErrorZ_is_ok(o: number): boolean {
10566 if(!isWasmInitialized) {
10567 throw new Error("initializeWasm() must be awaited first!");
10569 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_is_ok(o);
10570 return nativeResponseValue;
10572 // void CResult_PaymentIdPaymentErrorZ_free(struct LDKCResult_PaymentIdPaymentErrorZ _res);
10574 export function CResult_PaymentIdPaymentErrorZ_free(_res: number): void {
10575 if(!isWasmInitialized) {
10576 throw new Error("initializeWasm() must be awaited first!");
10578 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_free(_res);
10579 // debug statements here
10581 // uintptr_t CResult_PaymentIdPaymentErrorZ_clone_ptr(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR arg);
10583 export function CResult_PaymentIdPaymentErrorZ_clone_ptr(arg: number): number {
10584 if(!isWasmInitialized) {
10585 throw new Error("initializeWasm() must be awaited first!");
10587 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone_ptr(arg);
10588 return nativeResponseValue;
10590 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_clone(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR orig);
10592 export function CResult_PaymentIdPaymentErrorZ_clone(orig: number): number {
10593 if(!isWasmInitialized) {
10594 throw new Error("initializeWasm() must be awaited first!");
10596 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone(orig);
10597 return nativeResponseValue;
10599 // struct LDKCResult_SiPrefixNoneZ CResult_SiPrefixNoneZ_ok(enum LDKSiPrefix o);
10601 export function CResult_SiPrefixNoneZ_ok(o: SiPrefix): number {
10602 if(!isWasmInitialized) {
10603 throw new Error("initializeWasm() must be awaited first!");
10605 const nativeResponseValue = wasm.TS_CResult_SiPrefixNoneZ_ok(o);
10606 return nativeResponseValue;
10608 // struct LDKCResult_SiPrefixNoneZ CResult_SiPrefixNoneZ_err(void);
10610 export function CResult_SiPrefixNoneZ_err(): number {
10611 if(!isWasmInitialized) {
10612 throw new Error("initializeWasm() must be awaited first!");
10614 const nativeResponseValue = wasm.TS_CResult_SiPrefixNoneZ_err();
10615 return nativeResponseValue;
10617 // bool CResult_SiPrefixNoneZ_is_ok(const struct LDKCResult_SiPrefixNoneZ *NONNULL_PTR o);
10619 export function CResult_SiPrefixNoneZ_is_ok(o: number): boolean {
10620 if(!isWasmInitialized) {
10621 throw new Error("initializeWasm() must be awaited first!");
10623 const nativeResponseValue = wasm.TS_CResult_SiPrefixNoneZ_is_ok(o);
10624 return nativeResponseValue;
10626 // void CResult_SiPrefixNoneZ_free(struct LDKCResult_SiPrefixNoneZ _res);
10628 export function CResult_SiPrefixNoneZ_free(_res: number): void {
10629 if(!isWasmInitialized) {
10630 throw new Error("initializeWasm() must be awaited first!");
10632 const nativeResponseValue = wasm.TS_CResult_SiPrefixNoneZ_free(_res);
10633 // debug statements here
10635 // uintptr_t CResult_SiPrefixNoneZ_clone_ptr(LDKCResult_SiPrefixNoneZ *NONNULL_PTR arg);
10637 export function CResult_SiPrefixNoneZ_clone_ptr(arg: number): number {
10638 if(!isWasmInitialized) {
10639 throw new Error("initializeWasm() must be awaited first!");
10641 const nativeResponseValue = wasm.TS_CResult_SiPrefixNoneZ_clone_ptr(arg);
10642 return nativeResponseValue;
10644 // struct LDKCResult_SiPrefixNoneZ CResult_SiPrefixNoneZ_clone(const struct LDKCResult_SiPrefixNoneZ *NONNULL_PTR orig);
10646 export function CResult_SiPrefixNoneZ_clone(orig: number): number {
10647 if(!isWasmInitialized) {
10648 throw new Error("initializeWasm() must be awaited first!");
10650 const nativeResponseValue = wasm.TS_CResult_SiPrefixNoneZ_clone(orig);
10651 return nativeResponseValue;
10653 // struct LDKCResult_InvoiceNoneZ CResult_InvoiceNoneZ_ok(struct LDKInvoice o);
10655 export function CResult_InvoiceNoneZ_ok(o: number): number {
10656 if(!isWasmInitialized) {
10657 throw new Error("initializeWasm() must be awaited first!");
10659 const nativeResponseValue = wasm.TS_CResult_InvoiceNoneZ_ok(o);
10660 return nativeResponseValue;
10662 // struct LDKCResult_InvoiceNoneZ CResult_InvoiceNoneZ_err(void);
10664 export function CResult_InvoiceNoneZ_err(): number {
10665 if(!isWasmInitialized) {
10666 throw new Error("initializeWasm() must be awaited first!");
10668 const nativeResponseValue = wasm.TS_CResult_InvoiceNoneZ_err();
10669 return nativeResponseValue;
10671 // bool CResult_InvoiceNoneZ_is_ok(const struct LDKCResult_InvoiceNoneZ *NONNULL_PTR o);
10673 export function CResult_InvoiceNoneZ_is_ok(o: number): boolean {
10674 if(!isWasmInitialized) {
10675 throw new Error("initializeWasm() must be awaited first!");
10677 const nativeResponseValue = wasm.TS_CResult_InvoiceNoneZ_is_ok(o);
10678 return nativeResponseValue;
10680 // void CResult_InvoiceNoneZ_free(struct LDKCResult_InvoiceNoneZ _res);
10682 export function CResult_InvoiceNoneZ_free(_res: number): void {
10683 if(!isWasmInitialized) {
10684 throw new Error("initializeWasm() must be awaited first!");
10686 const nativeResponseValue = wasm.TS_CResult_InvoiceNoneZ_free(_res);
10687 // debug statements here
10689 // uintptr_t CResult_InvoiceNoneZ_clone_ptr(LDKCResult_InvoiceNoneZ *NONNULL_PTR arg);
10691 export function CResult_InvoiceNoneZ_clone_ptr(arg: number): number {
10692 if(!isWasmInitialized) {
10693 throw new Error("initializeWasm() must be awaited first!");
10695 const nativeResponseValue = wasm.TS_CResult_InvoiceNoneZ_clone_ptr(arg);
10696 return nativeResponseValue;
10698 // struct LDKCResult_InvoiceNoneZ CResult_InvoiceNoneZ_clone(const struct LDKCResult_InvoiceNoneZ *NONNULL_PTR orig);
10700 export function CResult_InvoiceNoneZ_clone(orig: number): number {
10701 if(!isWasmInitialized) {
10702 throw new Error("initializeWasm() must be awaited first!");
10704 const nativeResponseValue = wasm.TS_CResult_InvoiceNoneZ_clone(orig);
10705 return nativeResponseValue;
10707 // struct LDKCResult_SignedRawInvoiceNoneZ CResult_SignedRawInvoiceNoneZ_ok(struct LDKSignedRawInvoice o);
10709 export function CResult_SignedRawInvoiceNoneZ_ok(o: number): number {
10710 if(!isWasmInitialized) {
10711 throw new Error("initializeWasm() must be awaited first!");
10713 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceNoneZ_ok(o);
10714 return nativeResponseValue;
10716 // struct LDKCResult_SignedRawInvoiceNoneZ CResult_SignedRawInvoiceNoneZ_err(void);
10718 export function CResult_SignedRawInvoiceNoneZ_err(): number {
10719 if(!isWasmInitialized) {
10720 throw new Error("initializeWasm() must be awaited first!");
10722 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceNoneZ_err();
10723 return nativeResponseValue;
10725 // bool CResult_SignedRawInvoiceNoneZ_is_ok(const struct LDKCResult_SignedRawInvoiceNoneZ *NONNULL_PTR o);
10727 export function CResult_SignedRawInvoiceNoneZ_is_ok(o: number): boolean {
10728 if(!isWasmInitialized) {
10729 throw new Error("initializeWasm() must be awaited first!");
10731 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceNoneZ_is_ok(o);
10732 return nativeResponseValue;
10734 // void CResult_SignedRawInvoiceNoneZ_free(struct LDKCResult_SignedRawInvoiceNoneZ _res);
10736 export function CResult_SignedRawInvoiceNoneZ_free(_res: number): void {
10737 if(!isWasmInitialized) {
10738 throw new Error("initializeWasm() must be awaited first!");
10740 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceNoneZ_free(_res);
10741 // debug statements here
10743 // uintptr_t CResult_SignedRawInvoiceNoneZ_clone_ptr(LDKCResult_SignedRawInvoiceNoneZ *NONNULL_PTR arg);
10745 export function CResult_SignedRawInvoiceNoneZ_clone_ptr(arg: number): number {
10746 if(!isWasmInitialized) {
10747 throw new Error("initializeWasm() must be awaited first!");
10749 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceNoneZ_clone_ptr(arg);
10750 return nativeResponseValue;
10752 // struct LDKCResult_SignedRawInvoiceNoneZ CResult_SignedRawInvoiceNoneZ_clone(const struct LDKCResult_SignedRawInvoiceNoneZ *NONNULL_PTR orig);
10754 export function CResult_SignedRawInvoiceNoneZ_clone(orig: number): number {
10755 if(!isWasmInitialized) {
10756 throw new Error("initializeWasm() must be awaited first!");
10758 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceNoneZ_clone(orig);
10759 return nativeResponseValue;
10761 // uintptr_t C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR arg);
10763 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg: number): number {
10764 if(!isWasmInitialized) {
10765 throw new Error("initializeWasm() must be awaited first!");
10767 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg);
10768 return nativeResponseValue;
10770 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(const struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR orig);
10772 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig: number): number {
10773 if(!isWasmInitialized) {
10774 throw new Error("initializeWasm() must be awaited first!");
10776 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig);
10777 return nativeResponseValue;
10779 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(struct LDKRawInvoice a, struct LDKThirtyTwoBytes b, struct LDKInvoiceSignature c);
10781 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a: number, b: number, c: number): number {
10782 if(!isWasmInitialized) {
10783 throw new Error("initializeWasm() must be awaited first!");
10785 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a, b, c);
10786 return nativeResponseValue;
10788 // void C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ _res);
10790 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res: number): void {
10791 if(!isWasmInitialized) {
10792 throw new Error("initializeWasm() must be awaited first!");
10794 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res);
10795 // debug statements here
10797 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_ok(struct LDKPayeePubKey o);
10799 export function CResult_PayeePubKeyErrorZ_ok(o: number): number {
10800 if(!isWasmInitialized) {
10801 throw new Error("initializeWasm() must be awaited first!");
10803 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_ok(o);
10804 return nativeResponseValue;
10806 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_err(enum LDKSecp256k1Error e);
10808 export function CResult_PayeePubKeyErrorZ_err(e: Secp256k1Error): number {
10809 if(!isWasmInitialized) {
10810 throw new Error("initializeWasm() must be awaited first!");
10812 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_err(e);
10813 return nativeResponseValue;
10815 // bool CResult_PayeePubKeyErrorZ_is_ok(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR o);
10817 export function CResult_PayeePubKeyErrorZ_is_ok(o: number): boolean {
10818 if(!isWasmInitialized) {
10819 throw new Error("initializeWasm() must be awaited first!");
10821 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_is_ok(o);
10822 return nativeResponseValue;
10824 // void CResult_PayeePubKeyErrorZ_free(struct LDKCResult_PayeePubKeyErrorZ _res);
10826 export function CResult_PayeePubKeyErrorZ_free(_res: number): void {
10827 if(!isWasmInitialized) {
10828 throw new Error("initializeWasm() must be awaited first!");
10830 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_free(_res);
10831 // debug statements here
10833 // uintptr_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg);
10835 export function CResult_PayeePubKeyErrorZ_clone_ptr(arg: number): number {
10836 if(!isWasmInitialized) {
10837 throw new Error("initializeWasm() must be awaited first!");
10839 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone_ptr(arg);
10840 return nativeResponseValue;
10842 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_clone(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR orig);
10844 export function CResult_PayeePubKeyErrorZ_clone(orig: number): number {
10845 if(!isWasmInitialized) {
10846 throw new Error("initializeWasm() must be awaited first!");
10848 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone(orig);
10849 return nativeResponseValue;
10851 // void CVec_PrivateRouteZ_free(struct LDKCVec_PrivateRouteZ _res);
10853 export function CVec_PrivateRouteZ_free(_res: number): void {
10854 if(!isWasmInitialized) {
10855 throw new Error("initializeWasm() must be awaited first!");
10857 const nativeResponseValue = wasm.TS_CVec_PrivateRouteZ_free(_res);
10858 // debug statements here
10860 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_ok(struct LDKPositiveTimestamp o);
10862 export function CResult_PositiveTimestampCreationErrorZ_ok(o: number): number {
10863 if(!isWasmInitialized) {
10864 throw new Error("initializeWasm() must be awaited first!");
10866 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_ok(o);
10867 return nativeResponseValue;
10869 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_err(enum LDKCreationError e);
10871 export function CResult_PositiveTimestampCreationErrorZ_err(e: CreationError): number {
10872 if(!isWasmInitialized) {
10873 throw new Error("initializeWasm() must be awaited first!");
10875 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_err(e);
10876 return nativeResponseValue;
10878 // bool CResult_PositiveTimestampCreationErrorZ_is_ok(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR o);
10880 export function CResult_PositiveTimestampCreationErrorZ_is_ok(o: number): boolean {
10881 if(!isWasmInitialized) {
10882 throw new Error("initializeWasm() must be awaited first!");
10884 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_is_ok(o);
10885 return nativeResponseValue;
10887 // void CResult_PositiveTimestampCreationErrorZ_free(struct LDKCResult_PositiveTimestampCreationErrorZ _res);
10889 export function CResult_PositiveTimestampCreationErrorZ_free(_res: number): void {
10890 if(!isWasmInitialized) {
10891 throw new Error("initializeWasm() must be awaited first!");
10893 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_free(_res);
10894 // debug statements here
10896 // uintptr_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg);
10898 export function CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg: number): number {
10899 if(!isWasmInitialized) {
10900 throw new Error("initializeWasm() must be awaited first!");
10902 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg);
10903 return nativeResponseValue;
10905 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_clone(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR orig);
10907 export function CResult_PositiveTimestampCreationErrorZ_clone(orig: number): number {
10908 if(!isWasmInitialized) {
10909 throw new Error("initializeWasm() must be awaited first!");
10911 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone(orig);
10912 return nativeResponseValue;
10914 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_ok(void);
10916 export function CResult_NoneSemanticErrorZ_ok(): number {
10917 if(!isWasmInitialized) {
10918 throw new Error("initializeWasm() must be awaited first!");
10920 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_ok();
10921 return nativeResponseValue;
10923 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_err(enum LDKSemanticError e);
10925 export function CResult_NoneSemanticErrorZ_err(e: SemanticError): number {
10926 if(!isWasmInitialized) {
10927 throw new Error("initializeWasm() must be awaited first!");
10929 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_err(e);
10930 return nativeResponseValue;
10932 // bool CResult_NoneSemanticErrorZ_is_ok(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR o);
10934 export function CResult_NoneSemanticErrorZ_is_ok(o: number): boolean {
10935 if(!isWasmInitialized) {
10936 throw new Error("initializeWasm() must be awaited first!");
10938 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_is_ok(o);
10939 return nativeResponseValue;
10941 // void CResult_NoneSemanticErrorZ_free(struct LDKCResult_NoneSemanticErrorZ _res);
10943 export function CResult_NoneSemanticErrorZ_free(_res: number): void {
10944 if(!isWasmInitialized) {
10945 throw new Error("initializeWasm() must be awaited first!");
10947 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_free(_res);
10948 // debug statements here
10950 // uintptr_t CResult_NoneSemanticErrorZ_clone_ptr(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR arg);
10952 export function CResult_NoneSemanticErrorZ_clone_ptr(arg: number): number {
10953 if(!isWasmInitialized) {
10954 throw new Error("initializeWasm() must be awaited first!");
10956 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone_ptr(arg);
10957 return nativeResponseValue;
10959 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_clone(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR orig);
10961 export function CResult_NoneSemanticErrorZ_clone(orig: number): number {
10962 if(!isWasmInitialized) {
10963 throw new Error("initializeWasm() must be awaited first!");
10965 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone(orig);
10966 return nativeResponseValue;
10968 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_ok(struct LDKInvoice o);
10970 export function CResult_InvoiceSemanticErrorZ_ok(o: number): number {
10971 if(!isWasmInitialized) {
10972 throw new Error("initializeWasm() must be awaited first!");
10974 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_ok(o);
10975 return nativeResponseValue;
10977 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_err(enum LDKSemanticError e);
10979 export function CResult_InvoiceSemanticErrorZ_err(e: SemanticError): number {
10980 if(!isWasmInitialized) {
10981 throw new Error("initializeWasm() must be awaited first!");
10983 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_err(e);
10984 return nativeResponseValue;
10986 // bool CResult_InvoiceSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR o);
10988 export function CResult_InvoiceSemanticErrorZ_is_ok(o: number): boolean {
10989 if(!isWasmInitialized) {
10990 throw new Error("initializeWasm() must be awaited first!");
10992 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_is_ok(o);
10993 return nativeResponseValue;
10995 // void CResult_InvoiceSemanticErrorZ_free(struct LDKCResult_InvoiceSemanticErrorZ _res);
10997 export function CResult_InvoiceSemanticErrorZ_free(_res: number): void {
10998 if(!isWasmInitialized) {
10999 throw new Error("initializeWasm() must be awaited first!");
11001 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_free(_res);
11002 // debug statements here
11004 // uintptr_t CResult_InvoiceSemanticErrorZ_clone_ptr(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR arg);
11006 export function CResult_InvoiceSemanticErrorZ_clone_ptr(arg: number): number {
11007 if(!isWasmInitialized) {
11008 throw new Error("initializeWasm() must be awaited first!");
11010 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone_ptr(arg);
11011 return nativeResponseValue;
11013 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_clone(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR orig);
11015 export function CResult_InvoiceSemanticErrorZ_clone(orig: number): number {
11016 if(!isWasmInitialized) {
11017 throw new Error("initializeWasm() must be awaited first!");
11019 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone(orig);
11020 return nativeResponseValue;
11022 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_ok(struct LDKDescription o);
11024 export function CResult_DescriptionCreationErrorZ_ok(o: number): number {
11025 if(!isWasmInitialized) {
11026 throw new Error("initializeWasm() must be awaited first!");
11028 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_ok(o);
11029 return nativeResponseValue;
11031 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_err(enum LDKCreationError e);
11033 export function CResult_DescriptionCreationErrorZ_err(e: CreationError): number {
11034 if(!isWasmInitialized) {
11035 throw new Error("initializeWasm() must be awaited first!");
11037 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_err(e);
11038 return nativeResponseValue;
11040 // bool CResult_DescriptionCreationErrorZ_is_ok(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR o);
11042 export function CResult_DescriptionCreationErrorZ_is_ok(o: number): boolean {
11043 if(!isWasmInitialized) {
11044 throw new Error("initializeWasm() must be awaited first!");
11046 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_is_ok(o);
11047 return nativeResponseValue;
11049 // void CResult_DescriptionCreationErrorZ_free(struct LDKCResult_DescriptionCreationErrorZ _res);
11051 export function CResult_DescriptionCreationErrorZ_free(_res: number): void {
11052 if(!isWasmInitialized) {
11053 throw new Error("initializeWasm() must be awaited first!");
11055 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_free(_res);
11056 // debug statements here
11058 // uintptr_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg);
11060 export function CResult_DescriptionCreationErrorZ_clone_ptr(arg: number): number {
11061 if(!isWasmInitialized) {
11062 throw new Error("initializeWasm() must be awaited first!");
11064 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone_ptr(arg);
11065 return nativeResponseValue;
11067 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_clone(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR orig);
11069 export function CResult_DescriptionCreationErrorZ_clone(orig: number): number {
11070 if(!isWasmInitialized) {
11071 throw new Error("initializeWasm() must be awaited first!");
11073 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone(orig);
11074 return nativeResponseValue;
11076 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_ok(struct LDKPrivateRoute o);
11078 export function CResult_PrivateRouteCreationErrorZ_ok(o: number): number {
11079 if(!isWasmInitialized) {
11080 throw new Error("initializeWasm() must be awaited first!");
11082 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_ok(o);
11083 return nativeResponseValue;
11085 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_err(enum LDKCreationError e);
11087 export function CResult_PrivateRouteCreationErrorZ_err(e: CreationError): number {
11088 if(!isWasmInitialized) {
11089 throw new Error("initializeWasm() must be awaited first!");
11091 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_err(e);
11092 return nativeResponseValue;
11094 // bool CResult_PrivateRouteCreationErrorZ_is_ok(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR o);
11096 export function CResult_PrivateRouteCreationErrorZ_is_ok(o: number): boolean {
11097 if(!isWasmInitialized) {
11098 throw new Error("initializeWasm() must be awaited first!");
11100 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_is_ok(o);
11101 return nativeResponseValue;
11103 // void CResult_PrivateRouteCreationErrorZ_free(struct LDKCResult_PrivateRouteCreationErrorZ _res);
11105 export function CResult_PrivateRouteCreationErrorZ_free(_res: number): void {
11106 if(!isWasmInitialized) {
11107 throw new Error("initializeWasm() must be awaited first!");
11109 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_free(_res);
11110 // debug statements here
11112 // uintptr_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg);
11114 export function CResult_PrivateRouteCreationErrorZ_clone_ptr(arg: number): number {
11115 if(!isWasmInitialized) {
11116 throw new Error("initializeWasm() must be awaited first!");
11118 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(arg);
11119 return nativeResponseValue;
11121 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_clone(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR orig);
11123 export function CResult_PrivateRouteCreationErrorZ_clone(orig: number): number {
11124 if(!isWasmInitialized) {
11125 throw new Error("initializeWasm() must be awaited first!");
11127 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone(orig);
11128 return nativeResponseValue;
11130 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_ok(struct LDKStr o);
11132 export function CResult_StringErrorZ_ok(o: number): number {
11133 if(!isWasmInitialized) {
11134 throw new Error("initializeWasm() must be awaited first!");
11136 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_ok(o);
11137 return nativeResponseValue;
11139 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_err(enum LDKSecp256k1Error e);
11141 export function CResult_StringErrorZ_err(e: Secp256k1Error): number {
11142 if(!isWasmInitialized) {
11143 throw new Error("initializeWasm() must be awaited first!");
11145 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_err(e);
11146 return nativeResponseValue;
11148 // bool CResult_StringErrorZ_is_ok(const struct LDKCResult_StringErrorZ *NONNULL_PTR o);
11150 export function CResult_StringErrorZ_is_ok(o: number): boolean {
11151 if(!isWasmInitialized) {
11152 throw new Error("initializeWasm() must be awaited first!");
11154 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_is_ok(o);
11155 return nativeResponseValue;
11157 // void CResult_StringErrorZ_free(struct LDKCResult_StringErrorZ _res);
11159 export function CResult_StringErrorZ_free(_res: number): void {
11160 if(!isWasmInitialized) {
11161 throw new Error("initializeWasm() must be awaited first!");
11163 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_free(_res);
11164 // debug statements here
11166 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
11168 export function CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: number): number {
11169 if(!isWasmInitialized) {
11170 throw new Error("initializeWasm() must be awaited first!");
11172 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o);
11173 return nativeResponseValue;
11175 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
11177 export function CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: number): number {
11178 if(!isWasmInitialized) {
11179 throw new Error("initializeWasm() must be awaited first!");
11181 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(e);
11182 return nativeResponseValue;
11184 // bool CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR o);
11186 export function CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o: number): boolean {
11187 if(!isWasmInitialized) {
11188 throw new Error("initializeWasm() must be awaited first!");
11190 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o);
11191 return nativeResponseValue;
11193 // void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
11195 export function CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: number): void {
11196 if(!isWasmInitialized) {
11197 throw new Error("initializeWasm() must be awaited first!");
11199 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res);
11200 // debug statements here
11202 // uintptr_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg);
11204 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg: number): number {
11205 if(!isWasmInitialized) {
11206 throw new Error("initializeWasm() must be awaited first!");
11208 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg);
11209 return nativeResponseValue;
11211 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
11213 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: number): number {
11214 if(!isWasmInitialized) {
11215 throw new Error("initializeWasm() must be awaited first!");
11217 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig);
11218 return nativeResponseValue;
11220 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_some(struct LDKMonitorEvent o);
11222 export function COption_MonitorEventZ_some(o: number): number {
11223 if(!isWasmInitialized) {
11224 throw new Error("initializeWasm() must be awaited first!");
11226 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_some(o);
11227 return nativeResponseValue;
11229 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_none(void);
11231 export function COption_MonitorEventZ_none(): number {
11232 if(!isWasmInitialized) {
11233 throw new Error("initializeWasm() must be awaited first!");
11235 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_none();
11236 return nativeResponseValue;
11238 // void COption_MonitorEventZ_free(struct LDKCOption_MonitorEventZ _res);
11240 export function COption_MonitorEventZ_free(_res: number): void {
11241 if(!isWasmInitialized) {
11242 throw new Error("initializeWasm() must be awaited first!");
11244 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_free(_res);
11245 // debug statements here
11247 // uintptr_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg);
11249 export function COption_MonitorEventZ_clone_ptr(arg: number): number {
11250 if(!isWasmInitialized) {
11251 throw new Error("initializeWasm() must be awaited first!");
11253 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone_ptr(arg);
11254 return nativeResponseValue;
11256 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_clone(const struct LDKCOption_MonitorEventZ *NONNULL_PTR orig);
11258 export function COption_MonitorEventZ_clone(orig: number): number {
11259 if(!isWasmInitialized) {
11260 throw new Error("initializeWasm() must be awaited first!");
11262 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone(orig);
11263 return nativeResponseValue;
11265 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_ok(struct LDKCOption_MonitorEventZ o);
11267 export function CResult_COption_MonitorEventZDecodeErrorZ_ok(o: number): number {
11268 if(!isWasmInitialized) {
11269 throw new Error("initializeWasm() must be awaited first!");
11271 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(o);
11272 return nativeResponseValue;
11274 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_err(struct LDKDecodeError e);
11276 export function CResult_COption_MonitorEventZDecodeErrorZ_err(e: number): number {
11277 if(!isWasmInitialized) {
11278 throw new Error("initializeWasm() must be awaited first!");
11280 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_err(e);
11281 return nativeResponseValue;
11283 // bool CResult_COption_MonitorEventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR o);
11285 export function CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o: number): boolean {
11286 if(!isWasmInitialized) {
11287 throw new Error("initializeWasm() must be awaited first!");
11289 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o);
11290 return nativeResponseValue;
11292 // void CResult_COption_MonitorEventZDecodeErrorZ_free(struct LDKCResult_COption_MonitorEventZDecodeErrorZ _res);
11294 export function CResult_COption_MonitorEventZDecodeErrorZ_free(_res: number): void {
11295 if(!isWasmInitialized) {
11296 throw new Error("initializeWasm() must be awaited first!");
11298 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_free(_res);
11299 // debug statements here
11301 // uintptr_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg);
11303 export function CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg: number): number {
11304 if(!isWasmInitialized) {
11305 throw new Error("initializeWasm() must be awaited first!");
11307 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg);
11308 return nativeResponseValue;
11310 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_clone(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR orig);
11312 export function CResult_COption_MonitorEventZDecodeErrorZ_clone(orig: number): number {
11313 if(!isWasmInitialized) {
11314 throw new Error("initializeWasm() must be awaited first!");
11316 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(orig);
11317 return nativeResponseValue;
11319 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
11321 export function CResult_HTLCUpdateDecodeErrorZ_ok(o: number): number {
11322 if(!isWasmInitialized) {
11323 throw new Error("initializeWasm() must be awaited first!");
11325 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_ok(o);
11326 return nativeResponseValue;
11328 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
11330 export function CResult_HTLCUpdateDecodeErrorZ_err(e: number): number {
11331 if(!isWasmInitialized) {
11332 throw new Error("initializeWasm() must be awaited first!");
11334 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_err(e);
11335 return nativeResponseValue;
11337 // bool CResult_HTLCUpdateDecodeErrorZ_is_ok(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR o);
11339 export function CResult_HTLCUpdateDecodeErrorZ_is_ok(o: number): boolean {
11340 if(!isWasmInitialized) {
11341 throw new Error("initializeWasm() must be awaited first!");
11343 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(o);
11344 return nativeResponseValue;
11346 // void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
11348 export function CResult_HTLCUpdateDecodeErrorZ_free(_res: number): void {
11349 if(!isWasmInitialized) {
11350 throw new Error("initializeWasm() must be awaited first!");
11352 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_free(_res);
11353 // debug statements here
11355 // uintptr_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg);
11357 export function CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg: number): number {
11358 if(!isWasmInitialized) {
11359 throw new Error("initializeWasm() must be awaited first!");
11361 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg);
11362 return nativeResponseValue;
11364 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
11366 export function CResult_HTLCUpdateDecodeErrorZ_clone(orig: number): number {
11367 if(!isWasmInitialized) {
11368 throw new Error("initializeWasm() must be awaited first!");
11370 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone(orig);
11371 return nativeResponseValue;
11373 // uintptr_t C2Tuple_OutPointScriptZ_clone_ptr(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR arg);
11375 export function C2Tuple_OutPointScriptZ_clone_ptr(arg: number): number {
11376 if(!isWasmInitialized) {
11377 throw new Error("initializeWasm() must be awaited first!");
11379 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone_ptr(arg);
11380 return nativeResponseValue;
11382 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_clone(const struct LDKC2Tuple_OutPointScriptZ *NONNULL_PTR orig);
11384 export function C2Tuple_OutPointScriptZ_clone(orig: number): number {
11385 if(!isWasmInitialized) {
11386 throw new Error("initializeWasm() must be awaited first!");
11388 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone(orig);
11389 return nativeResponseValue;
11391 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
11393 export function C2Tuple_OutPointScriptZ_new(a: number, b: number): number {
11394 if(!isWasmInitialized) {
11395 throw new Error("initializeWasm() must be awaited first!");
11397 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_new(a, b);
11398 return nativeResponseValue;
11400 // void C2Tuple_OutPointScriptZ_free(struct LDKC2Tuple_OutPointScriptZ _res);
11402 export function C2Tuple_OutPointScriptZ_free(_res: number): void {
11403 if(!isWasmInitialized) {
11404 throw new Error("initializeWasm() must be awaited first!");
11406 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_free(_res);
11407 // debug statements here
11409 // uintptr_t C2Tuple_u32ScriptZ_clone_ptr(LDKC2Tuple_u32ScriptZ *NONNULL_PTR arg);
11411 export function C2Tuple_u32ScriptZ_clone_ptr(arg: number): number {
11412 if(!isWasmInitialized) {
11413 throw new Error("initializeWasm() must be awaited first!");
11415 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone_ptr(arg);
11416 return nativeResponseValue;
11418 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_clone(const struct LDKC2Tuple_u32ScriptZ *NONNULL_PTR orig);
11420 export function C2Tuple_u32ScriptZ_clone(orig: number): number {
11421 if(!isWasmInitialized) {
11422 throw new Error("initializeWasm() must be awaited first!");
11424 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone(orig);
11425 return nativeResponseValue;
11427 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_new(uint32_t a, struct LDKCVec_u8Z b);
11429 export function C2Tuple_u32ScriptZ_new(a: number, b: number): number {
11430 if(!isWasmInitialized) {
11431 throw new Error("initializeWasm() must be awaited first!");
11433 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_new(a, b);
11434 return nativeResponseValue;
11436 // void C2Tuple_u32ScriptZ_free(struct LDKC2Tuple_u32ScriptZ _res);
11438 export function C2Tuple_u32ScriptZ_free(_res: number): void {
11439 if(!isWasmInitialized) {
11440 throw new Error("initializeWasm() must be awaited first!");
11442 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_free(_res);
11443 // debug statements here
11445 // void CVec_C2Tuple_u32ScriptZZ_free(struct LDKCVec_C2Tuple_u32ScriptZZ _res);
11447 export function CVec_C2Tuple_u32ScriptZZ_free(_res: number): void {
11448 if(!isWasmInitialized) {
11449 throw new Error("initializeWasm() must be awaited first!");
11451 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32ScriptZZ_free(_res);
11452 // debug statements here
11454 // uintptr_t C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR arg);
11456 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_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_u32ScriptZZZ_clone_ptr(arg);
11461 return nativeResponseValue;
11463 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR orig);
11465 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig: number): number {
11466 if(!isWasmInitialized) {
11467 throw new Error("initializeWasm() must be awaited first!");
11469 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig);
11470 return nativeResponseValue;
11472 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32ScriptZZ b);
11474 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_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_u32ScriptZZZ_new(a, b);
11479 return nativeResponseValue;
11481 // void C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res);
11483 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res: number): void {
11484 if(!isWasmInitialized) {
11485 throw new Error("initializeWasm() must be awaited first!");
11487 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res);
11488 // debug statements here
11490 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res);
11492 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_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_u32ScriptZZZZ_free(_res);
11497 // debug statements here
11499 // void CVec_EventZ_free(struct LDKCVec_EventZ _res);
11501 export function CVec_EventZ_free(_res: number): void {
11502 if(!isWasmInitialized) {
11503 throw new Error("initializeWasm() must be awaited first!");
11505 const nativeResponseValue = wasm.TS_CVec_EventZ_free(_res);
11506 // debug statements here
11508 // void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
11510 export function CVec_TransactionZ_free(_res: number): void {
11511 if(!isWasmInitialized) {
11512 throw new Error("initializeWasm() must be awaited first!");
11514 const nativeResponseValue = wasm.TS_CVec_TransactionZ_free(_res);
11515 // debug statements here
11517 // uintptr_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg);
11519 export function C2Tuple_u32TxOutZ_clone_ptr(arg: number): number {
11520 if(!isWasmInitialized) {
11521 throw new Error("initializeWasm() must be awaited first!");
11523 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone_ptr(arg);
11524 return nativeResponseValue;
11526 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
11528 export function C2Tuple_u32TxOutZ_clone(orig: number): number {
11529 if(!isWasmInitialized) {
11530 throw new Error("initializeWasm() must be awaited first!");
11532 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone(orig);
11533 return nativeResponseValue;
11535 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
11537 export function C2Tuple_u32TxOutZ_new(a: number, b: number): number {
11538 if(!isWasmInitialized) {
11539 throw new Error("initializeWasm() must be awaited first!");
11541 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_new(a, b);
11542 return nativeResponseValue;
11544 // void C2Tuple_u32TxOutZ_free(struct LDKC2Tuple_u32TxOutZ _res);
11546 export function C2Tuple_u32TxOutZ_free(_res: number): void {
11547 if(!isWasmInitialized) {
11548 throw new Error("initializeWasm() must be awaited first!");
11550 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_free(_res);
11551 // debug statements here
11553 // void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
11555 export function CVec_C2Tuple_u32TxOutZZ_free(_res: number): void {
11556 if(!isWasmInitialized) {
11557 throw new Error("initializeWasm() must be awaited first!");
11559 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32TxOutZZ_free(_res);
11560 // debug statements here
11562 // uintptr_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg);
11564 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg: number): number {
11565 if(!isWasmInitialized) {
11566 throw new Error("initializeWasm() must be awaited first!");
11568 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg);
11569 return nativeResponseValue;
11571 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR orig);
11573 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig: number): number {
11574 if(!isWasmInitialized) {
11575 throw new Error("initializeWasm() must be awaited first!");
11577 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig);
11578 return nativeResponseValue;
11580 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
11582 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a: number, b: number): number {
11583 if(!isWasmInitialized) {
11584 throw new Error("initializeWasm() must be awaited first!");
11586 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a, b);
11587 return nativeResponseValue;
11589 // void C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res);
11591 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res: number): void {
11592 if(!isWasmInitialized) {
11593 throw new Error("initializeWasm() must be awaited first!");
11595 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res);
11596 // debug statements here
11598 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res);
11600 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res: number): void {
11601 if(!isWasmInitialized) {
11602 throw new Error("initializeWasm() must be awaited first!");
11604 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res);
11605 // debug statements here
11607 // void CVec_BalanceZ_free(struct LDKCVec_BalanceZ _res);
11609 export function CVec_BalanceZ_free(_res: number): void {
11610 if(!isWasmInitialized) {
11611 throw new Error("initializeWasm() must be awaited first!");
11613 const nativeResponseValue = wasm.TS_CVec_BalanceZ_free(_res);
11614 // debug statements here
11616 // uintptr_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg);
11618 export function C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg: number): number {
11619 if(!isWasmInitialized) {
11620 throw new Error("initializeWasm() must be awaited first!");
11622 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg);
11623 return nativeResponseValue;
11625 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_clone(const struct LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR orig);
11627 export function C2Tuple_BlockHashChannelMonitorZ_clone(orig: number): number {
11628 if(!isWasmInitialized) {
11629 throw new Error("initializeWasm() must be awaited first!");
11631 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone(orig);
11632 return nativeResponseValue;
11634 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
11636 export function C2Tuple_BlockHashChannelMonitorZ_new(a: number, b: number): number {
11637 if(!isWasmInitialized) {
11638 throw new Error("initializeWasm() must be awaited first!");
11640 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_new(a, b);
11641 return nativeResponseValue;
11643 // void C2Tuple_BlockHashChannelMonitorZ_free(struct LDKC2Tuple_BlockHashChannelMonitorZ _res);
11645 export function C2Tuple_BlockHashChannelMonitorZ_free(_res: number): void {
11646 if(!isWasmInitialized) {
11647 throw new Error("initializeWasm() must be awaited first!");
11649 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_free(_res);
11650 // debug statements here
11652 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelMonitorZ o);
11654 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o: number): number {
11655 if(!isWasmInitialized) {
11656 throw new Error("initializeWasm() must be awaited first!");
11658 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o);
11659 return nativeResponseValue;
11661 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
11663 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e: number): number {
11664 if(!isWasmInitialized) {
11665 throw new Error("initializeWasm() must be awaited first!");
11667 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e);
11668 return nativeResponseValue;
11670 // bool CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR o);
11672 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o: number): boolean {
11673 if(!isWasmInitialized) {
11674 throw new Error("initializeWasm() must be awaited first!");
11676 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o);
11677 return nativeResponseValue;
11679 // void CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res);
11681 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res: number): void {
11682 if(!isWasmInitialized) {
11683 throw new Error("initializeWasm() must be awaited first!");
11685 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res);
11686 // debug statements here
11688 // uintptr_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg);
11690 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg: number): number {
11691 if(!isWasmInitialized) {
11692 throw new Error("initializeWasm() must be awaited first!");
11694 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg);
11695 return nativeResponseValue;
11697 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR orig);
11699 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig: number): number {
11700 if(!isWasmInitialized) {
11701 throw new Error("initializeWasm() must be awaited first!");
11703 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig);
11704 return nativeResponseValue;
11706 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
11708 export function CResult_NoneLightningErrorZ_ok(): number {
11709 if(!isWasmInitialized) {
11710 throw new Error("initializeWasm() must be awaited first!");
11712 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_ok();
11713 return nativeResponseValue;
11715 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
11717 export function CResult_NoneLightningErrorZ_err(e: number): number {
11718 if(!isWasmInitialized) {
11719 throw new Error("initializeWasm() must be awaited first!");
11721 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_err(e);
11722 return nativeResponseValue;
11724 // bool CResult_NoneLightningErrorZ_is_ok(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR o);
11726 export function CResult_NoneLightningErrorZ_is_ok(o: number): boolean {
11727 if(!isWasmInitialized) {
11728 throw new Error("initializeWasm() must be awaited first!");
11730 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_is_ok(o);
11731 return nativeResponseValue;
11733 // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
11735 export function CResult_NoneLightningErrorZ_free(_res: number): void {
11736 if(!isWasmInitialized) {
11737 throw new Error("initializeWasm() must be awaited first!");
11739 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_free(_res);
11740 // debug statements here
11742 // uintptr_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg);
11744 export function CResult_NoneLightningErrorZ_clone_ptr(arg: number): number {
11745 if(!isWasmInitialized) {
11746 throw new Error("initializeWasm() must be awaited first!");
11748 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone_ptr(arg);
11749 return nativeResponseValue;
11751 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
11753 export function CResult_NoneLightningErrorZ_clone(orig: number): number {
11754 if(!isWasmInitialized) {
11755 throw new Error("initializeWasm() must be awaited first!");
11757 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone(orig);
11758 return nativeResponseValue;
11760 // uintptr_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg);
11762 export function C2Tuple_PublicKeyTypeZ_clone_ptr(arg: number): number {
11763 if(!isWasmInitialized) {
11764 throw new Error("initializeWasm() must be awaited first!");
11766 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone_ptr(arg);
11767 return nativeResponseValue;
11769 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_clone(const struct LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR orig);
11771 export function C2Tuple_PublicKeyTypeZ_clone(orig: number): number {
11772 if(!isWasmInitialized) {
11773 throw new Error("initializeWasm() must be awaited first!");
11775 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone(orig);
11776 return nativeResponseValue;
11778 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_new(struct LDKPublicKey a, struct LDKType b);
11780 export function C2Tuple_PublicKeyTypeZ_new(a: number, b: number): number {
11781 if(!isWasmInitialized) {
11782 throw new Error("initializeWasm() must be awaited first!");
11784 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_new(a, b);
11785 return nativeResponseValue;
11787 // void C2Tuple_PublicKeyTypeZ_free(struct LDKC2Tuple_PublicKeyTypeZ _res);
11789 export function C2Tuple_PublicKeyTypeZ_free(_res: number): void {
11790 if(!isWasmInitialized) {
11791 throw new Error("initializeWasm() must be awaited first!");
11793 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_free(_res);
11794 // debug statements here
11796 // void CVec_C2Tuple_PublicKeyTypeZZ_free(struct LDKCVec_C2Tuple_PublicKeyTypeZZ _res);
11798 export function CVec_C2Tuple_PublicKeyTypeZZ_free(_res: number): void {
11799 if(!isWasmInitialized) {
11800 throw new Error("initializeWasm() must be awaited first!");
11802 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyTypeZZ_free(_res);
11803 // debug statements here
11805 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
11807 export function CResult_boolLightningErrorZ_ok(o: boolean): number {
11808 if(!isWasmInitialized) {
11809 throw new Error("initializeWasm() must be awaited first!");
11811 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_ok(o);
11812 return nativeResponseValue;
11814 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
11816 export function CResult_boolLightningErrorZ_err(e: number): number {
11817 if(!isWasmInitialized) {
11818 throw new Error("initializeWasm() must be awaited first!");
11820 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_err(e);
11821 return nativeResponseValue;
11823 // bool CResult_boolLightningErrorZ_is_ok(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR o);
11825 export function CResult_boolLightningErrorZ_is_ok(o: number): boolean {
11826 if(!isWasmInitialized) {
11827 throw new Error("initializeWasm() must be awaited first!");
11829 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_is_ok(o);
11830 return nativeResponseValue;
11832 // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
11834 export function CResult_boolLightningErrorZ_free(_res: number): void {
11835 if(!isWasmInitialized) {
11836 throw new Error("initializeWasm() must be awaited first!");
11838 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_free(_res);
11839 // debug statements here
11841 // uintptr_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg);
11843 export function CResult_boolLightningErrorZ_clone_ptr(arg: number): number {
11844 if(!isWasmInitialized) {
11845 throw new Error("initializeWasm() must be awaited first!");
11847 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone_ptr(arg);
11848 return nativeResponseValue;
11850 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
11852 export function CResult_boolLightningErrorZ_clone(orig: number): number {
11853 if(!isWasmInitialized) {
11854 throw new Error("initializeWasm() must be awaited first!");
11856 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone(orig);
11857 return nativeResponseValue;
11859 // uintptr_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg);
11861 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg: number): number {
11862 if(!isWasmInitialized) {
11863 throw new Error("initializeWasm() must be awaited first!");
11865 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg);
11866 return nativeResponseValue;
11868 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
11870 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: number): number {
11871 if(!isWasmInitialized) {
11872 throw new Error("initializeWasm() must be awaited first!");
11874 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig);
11875 return nativeResponseValue;
11877 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
11879 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: number, b: number, c: number): number {
11880 if(!isWasmInitialized) {
11881 throw new Error("initializeWasm() must be awaited first!");
11883 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c);
11884 return nativeResponseValue;
11886 // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
11888 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: number): void {
11889 if(!isWasmInitialized) {
11890 throw new Error("initializeWasm() must be awaited first!");
11892 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res);
11893 // debug statements here
11895 // void CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
11897 export function CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: number): void {
11898 if(!isWasmInitialized) {
11899 throw new Error("initializeWasm() must be awaited first!");
11901 const nativeResponseValue = wasm.TS_CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res);
11902 // debug statements here
11904 // void CVec_NodeAnnouncementZ_free(struct LDKCVec_NodeAnnouncementZ _res);
11906 export function CVec_NodeAnnouncementZ_free(_res: number): void {
11907 if(!isWasmInitialized) {
11908 throw new Error("initializeWasm() must be awaited first!");
11910 const nativeResponseValue = wasm.TS_CVec_NodeAnnouncementZ_free(_res);
11911 // debug statements here
11913 // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
11915 export function CVec_PublicKeyZ_free(_res: number): void {
11916 if(!isWasmInitialized) {
11917 throw new Error("initializeWasm() must be awaited first!");
11919 const nativeResponseValue = wasm.TS_CVec_PublicKeyZ_free(_res);
11920 // debug statements here
11922 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
11924 export function CResult_CVec_u8ZPeerHandleErrorZ_ok(o: number): number {
11925 if(!isWasmInitialized) {
11926 throw new Error("initializeWasm() must be awaited first!");
11928 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(o);
11929 return nativeResponseValue;
11931 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
11933 export function CResult_CVec_u8ZPeerHandleErrorZ_err(e: number): number {
11934 if(!isWasmInitialized) {
11935 throw new Error("initializeWasm() must be awaited first!");
11937 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_err(e);
11938 return nativeResponseValue;
11940 // bool CResult_CVec_u8ZPeerHandleErrorZ_is_ok(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR o);
11942 export function CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o: number): boolean {
11943 if(!isWasmInitialized) {
11944 throw new Error("initializeWasm() must be awaited first!");
11946 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o);
11947 return nativeResponseValue;
11949 // void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
11951 export function CResult_CVec_u8ZPeerHandleErrorZ_free(_res: number): void {
11952 if(!isWasmInitialized) {
11953 throw new Error("initializeWasm() must be awaited first!");
11955 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_free(_res);
11956 // debug statements here
11958 // uintptr_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg);
11960 export function CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg: number): number {
11961 if(!isWasmInitialized) {
11962 throw new Error("initializeWasm() must be awaited first!");
11964 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg);
11965 return nativeResponseValue;
11967 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
11969 export function CResult_CVec_u8ZPeerHandleErrorZ_clone(orig: number): number {
11970 if(!isWasmInitialized) {
11971 throw new Error("initializeWasm() must be awaited first!");
11973 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(orig);
11974 return nativeResponseValue;
11976 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
11978 export function CResult_NonePeerHandleErrorZ_ok(): number {
11979 if(!isWasmInitialized) {
11980 throw new Error("initializeWasm() must be awaited first!");
11982 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_ok();
11983 return nativeResponseValue;
11985 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
11987 export function CResult_NonePeerHandleErrorZ_err(e: number): number {
11988 if(!isWasmInitialized) {
11989 throw new Error("initializeWasm() must be awaited first!");
11991 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_err(e);
11992 return nativeResponseValue;
11994 // bool CResult_NonePeerHandleErrorZ_is_ok(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR o);
11996 export function CResult_NonePeerHandleErrorZ_is_ok(o: number): boolean {
11997 if(!isWasmInitialized) {
11998 throw new Error("initializeWasm() must be awaited first!");
12000 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_is_ok(o);
12001 return nativeResponseValue;
12003 // void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
12005 export function CResult_NonePeerHandleErrorZ_free(_res: number): void {
12006 if(!isWasmInitialized) {
12007 throw new Error("initializeWasm() must be awaited first!");
12009 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_free(_res);
12010 // debug statements here
12012 // uintptr_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg);
12014 export function CResult_NonePeerHandleErrorZ_clone_ptr(arg: number): number {
12015 if(!isWasmInitialized) {
12016 throw new Error("initializeWasm() must be awaited first!");
12018 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone_ptr(arg);
12019 return nativeResponseValue;
12021 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
12023 export function CResult_NonePeerHandleErrorZ_clone(orig: number): number {
12024 if(!isWasmInitialized) {
12025 throw new Error("initializeWasm() must be awaited first!");
12027 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone(orig);
12028 return nativeResponseValue;
12030 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
12032 export function CResult_boolPeerHandleErrorZ_ok(o: boolean): number {
12033 if(!isWasmInitialized) {
12034 throw new Error("initializeWasm() must be awaited first!");
12036 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_ok(o);
12037 return nativeResponseValue;
12039 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
12041 export function CResult_boolPeerHandleErrorZ_err(e: number): number {
12042 if(!isWasmInitialized) {
12043 throw new Error("initializeWasm() must be awaited first!");
12045 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_err(e);
12046 return nativeResponseValue;
12048 // bool CResult_boolPeerHandleErrorZ_is_ok(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR o);
12050 export function CResult_boolPeerHandleErrorZ_is_ok(o: number): boolean {
12051 if(!isWasmInitialized) {
12052 throw new Error("initializeWasm() must be awaited first!");
12054 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_is_ok(o);
12055 return nativeResponseValue;
12057 // void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
12059 export function CResult_boolPeerHandleErrorZ_free(_res: number): void {
12060 if(!isWasmInitialized) {
12061 throw new Error("initializeWasm() must be awaited first!");
12063 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_free(_res);
12064 // debug statements here
12066 // uintptr_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg);
12068 export function CResult_boolPeerHandleErrorZ_clone_ptr(arg: number): number {
12069 if(!isWasmInitialized) {
12070 throw new Error("initializeWasm() must be awaited first!");
12072 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone_ptr(arg);
12073 return nativeResponseValue;
12075 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
12077 export function CResult_boolPeerHandleErrorZ_clone(orig: number): number {
12078 if(!isWasmInitialized) {
12079 throw new Error("initializeWasm() must be awaited first!");
12081 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone(orig);
12082 return nativeResponseValue;
12084 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_ok(struct LDKNodeId o);
12086 export function CResult_NodeIdDecodeErrorZ_ok(o: number): number {
12087 if(!isWasmInitialized) {
12088 throw new Error("initializeWasm() must be awaited first!");
12090 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_ok(o);
12091 return nativeResponseValue;
12093 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_err(struct LDKDecodeError e);
12095 export function CResult_NodeIdDecodeErrorZ_err(e: number): number {
12096 if(!isWasmInitialized) {
12097 throw new Error("initializeWasm() must be awaited first!");
12099 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_err(e);
12100 return nativeResponseValue;
12102 // bool CResult_NodeIdDecodeErrorZ_is_ok(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR o);
12104 export function CResult_NodeIdDecodeErrorZ_is_ok(o: number): boolean {
12105 if(!isWasmInitialized) {
12106 throw new Error("initializeWasm() must be awaited first!");
12108 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_is_ok(o);
12109 return nativeResponseValue;
12111 // void CResult_NodeIdDecodeErrorZ_free(struct LDKCResult_NodeIdDecodeErrorZ _res);
12113 export function CResult_NodeIdDecodeErrorZ_free(_res: number): void {
12114 if(!isWasmInitialized) {
12115 throw new Error("initializeWasm() must be awaited first!");
12117 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_free(_res);
12118 // debug statements here
12120 // uintptr_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg);
12122 export function CResult_NodeIdDecodeErrorZ_clone_ptr(arg: number): number {
12123 if(!isWasmInitialized) {
12124 throw new Error("initializeWasm() must be awaited first!");
12126 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone_ptr(arg);
12127 return nativeResponseValue;
12129 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_clone(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR orig);
12131 export function CResult_NodeIdDecodeErrorZ_clone(orig: number): number {
12132 if(!isWasmInitialized) {
12133 throw new Error("initializeWasm() must be awaited first!");
12135 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone(orig);
12136 return nativeResponseValue;
12138 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_ok(struct LDKCOption_NetworkUpdateZ o);
12140 export function CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o: number): number {
12141 if(!isWasmInitialized) {
12142 throw new Error("initializeWasm() must be awaited first!");
12144 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o);
12145 return nativeResponseValue;
12147 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_err(struct LDKDecodeError e);
12149 export function CResult_COption_NetworkUpdateZDecodeErrorZ_err(e: number): number {
12150 if(!isWasmInitialized) {
12151 throw new Error("initializeWasm() must be awaited first!");
12153 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(e);
12154 return nativeResponseValue;
12156 // bool CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR o);
12158 export function CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o: number): boolean {
12159 if(!isWasmInitialized) {
12160 throw new Error("initializeWasm() must be awaited first!");
12162 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o);
12163 return nativeResponseValue;
12165 // void CResult_COption_NetworkUpdateZDecodeErrorZ_free(struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res);
12167 export function CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res: number): void {
12168 if(!isWasmInitialized) {
12169 throw new Error("initializeWasm() must be awaited first!");
12171 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res);
12172 // debug statements here
12174 // uintptr_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg);
12176 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg: number): number {
12177 if(!isWasmInitialized) {
12178 throw new Error("initializeWasm() must be awaited first!");
12180 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg);
12181 return nativeResponseValue;
12183 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_clone(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR orig);
12185 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig: number): number {
12186 if(!isWasmInitialized) {
12187 throw new Error("initializeWasm() must be awaited first!");
12189 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig);
12190 return nativeResponseValue;
12192 // struct LDKCOption_AccessZ COption_AccessZ_some(struct LDKAccess o);
12194 export function COption_AccessZ_some(o: number): number {
12195 if(!isWasmInitialized) {
12196 throw new Error("initializeWasm() must be awaited first!");
12198 const nativeResponseValue = wasm.TS_COption_AccessZ_some(o);
12199 return nativeResponseValue;
12201 // struct LDKCOption_AccessZ COption_AccessZ_none(void);
12203 export function COption_AccessZ_none(): number {
12204 if(!isWasmInitialized) {
12205 throw new Error("initializeWasm() must be awaited first!");
12207 const nativeResponseValue = wasm.TS_COption_AccessZ_none();
12208 return nativeResponseValue;
12210 // void COption_AccessZ_free(struct LDKCOption_AccessZ _res);
12212 export function COption_AccessZ_free(_res: number): void {
12213 if(!isWasmInitialized) {
12214 throw new Error("initializeWasm() must be awaited first!");
12216 const nativeResponseValue = wasm.TS_COption_AccessZ_free(_res);
12217 // debug statements here
12219 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_ok(struct LDKChannelUpdateInfo o);
12221 export function CResult_ChannelUpdateInfoDecodeErrorZ_ok(o: number): number {
12222 if(!isWasmInitialized) {
12223 throw new Error("initializeWasm() must be awaited first!");
12225 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok(o);
12226 return nativeResponseValue;
12228 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_err(struct LDKDecodeError e);
12230 export function CResult_ChannelUpdateInfoDecodeErrorZ_err(e: number): number {
12231 if(!isWasmInitialized) {
12232 throw new Error("initializeWasm() must be awaited first!");
12234 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_err(e);
12235 return nativeResponseValue;
12237 // bool CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR o);
12239 export function CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o: number): boolean {
12240 if(!isWasmInitialized) {
12241 throw new Error("initializeWasm() must be awaited first!");
12243 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o);
12244 return nativeResponseValue;
12246 // void CResult_ChannelUpdateInfoDecodeErrorZ_free(struct LDKCResult_ChannelUpdateInfoDecodeErrorZ _res);
12248 export function CResult_ChannelUpdateInfoDecodeErrorZ_free(_res: number): void {
12249 if(!isWasmInitialized) {
12250 throw new Error("initializeWasm() must be awaited first!");
12252 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_free(_res);
12253 // debug statements here
12255 // uintptr_t CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR arg);
12257 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg: number): number {
12258 if(!isWasmInitialized) {
12259 throw new Error("initializeWasm() must be awaited first!");
12261 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg);
12262 return nativeResponseValue;
12264 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR orig);
12266 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig: number): number {
12267 if(!isWasmInitialized) {
12268 throw new Error("initializeWasm() must be awaited first!");
12270 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig);
12271 return nativeResponseValue;
12273 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
12275 export function CResult_ChannelInfoDecodeErrorZ_ok(o: number): number {
12276 if(!isWasmInitialized) {
12277 throw new Error("initializeWasm() must be awaited first!");
12279 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_ok(o);
12280 return nativeResponseValue;
12282 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
12284 export function CResult_ChannelInfoDecodeErrorZ_err(e: number): number {
12285 if(!isWasmInitialized) {
12286 throw new Error("initializeWasm() must be awaited first!");
12288 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_err(e);
12289 return nativeResponseValue;
12291 // bool CResult_ChannelInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR o);
12293 export function CResult_ChannelInfoDecodeErrorZ_is_ok(o: number): boolean {
12294 if(!isWasmInitialized) {
12295 throw new Error("initializeWasm() must be awaited first!");
12297 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_is_ok(o);
12298 return nativeResponseValue;
12300 // void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
12302 export function CResult_ChannelInfoDecodeErrorZ_free(_res: number): void {
12303 if(!isWasmInitialized) {
12304 throw new Error("initializeWasm() must be awaited first!");
12306 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_free(_res);
12307 // debug statements here
12309 // uintptr_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg);
12311 export function CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg: number): number {
12312 if(!isWasmInitialized) {
12313 throw new Error("initializeWasm() must be awaited first!");
12315 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg);
12316 return nativeResponseValue;
12318 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
12320 export function CResult_ChannelInfoDecodeErrorZ_clone(orig: number): number {
12321 if(!isWasmInitialized) {
12322 throw new Error("initializeWasm() must be awaited first!");
12324 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone(orig);
12325 return nativeResponseValue;
12327 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
12329 export function CResult_RoutingFeesDecodeErrorZ_ok(o: number): number {
12330 if(!isWasmInitialized) {
12331 throw new Error("initializeWasm() must be awaited first!");
12333 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_ok(o);
12334 return nativeResponseValue;
12336 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
12338 export function CResult_RoutingFeesDecodeErrorZ_err(e: number): number {
12339 if(!isWasmInitialized) {
12340 throw new Error("initializeWasm() must be awaited first!");
12342 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_err(e);
12343 return nativeResponseValue;
12345 // bool CResult_RoutingFeesDecodeErrorZ_is_ok(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR o);
12347 export function CResult_RoutingFeesDecodeErrorZ_is_ok(o: number): boolean {
12348 if(!isWasmInitialized) {
12349 throw new Error("initializeWasm() must be awaited first!");
12351 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_is_ok(o);
12352 return nativeResponseValue;
12354 // void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
12356 export function CResult_RoutingFeesDecodeErrorZ_free(_res: number): void {
12357 if(!isWasmInitialized) {
12358 throw new Error("initializeWasm() must be awaited first!");
12360 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_free(_res);
12361 // debug statements here
12363 // uintptr_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg);
12365 export function CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg: number): number {
12366 if(!isWasmInitialized) {
12367 throw new Error("initializeWasm() must be awaited first!");
12369 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg);
12370 return nativeResponseValue;
12372 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
12374 export function CResult_RoutingFeesDecodeErrorZ_clone(orig: number): number {
12375 if(!isWasmInitialized) {
12376 throw new Error("initializeWasm() must be awaited first!");
12378 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone(orig);
12379 return nativeResponseValue;
12381 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
12383 export function CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o: number): number {
12384 if(!isWasmInitialized) {
12385 throw new Error("initializeWasm() must be awaited first!");
12387 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o);
12388 return nativeResponseValue;
12390 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
12392 export function CResult_NodeAnnouncementInfoDecodeErrorZ_err(e: number): number {
12393 if(!isWasmInitialized) {
12394 throw new Error("initializeWasm() must be awaited first!");
12396 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(e);
12397 return nativeResponseValue;
12399 // bool CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR o);
12401 export function CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o: number): boolean {
12402 if(!isWasmInitialized) {
12403 throw new Error("initializeWasm() must be awaited first!");
12405 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o);
12406 return nativeResponseValue;
12408 // void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
12410 export function CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res: number): void {
12411 if(!isWasmInitialized) {
12412 throw new Error("initializeWasm() must be awaited first!");
12414 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res);
12415 // debug statements here
12417 // uintptr_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg);
12419 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg: number): number {
12420 if(!isWasmInitialized) {
12421 throw new Error("initializeWasm() must be awaited first!");
12423 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg);
12424 return nativeResponseValue;
12426 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
12428 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: number): number {
12429 if(!isWasmInitialized) {
12430 throw new Error("initializeWasm() must be awaited first!");
12432 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig);
12433 return nativeResponseValue;
12435 // void CVec_u64Z_free(struct LDKCVec_u64Z _res);
12437 export function CVec_u64Z_free(_res: number): void {
12438 if(!isWasmInitialized) {
12439 throw new Error("initializeWasm() must be awaited first!");
12441 const nativeResponseValue = wasm.TS_CVec_u64Z_free(_res);
12442 // debug statements here
12444 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_ok(struct LDKNodeInfo o);
12446 export function CResult_NodeInfoDecodeErrorZ_ok(o: number): number {
12447 if(!isWasmInitialized) {
12448 throw new Error("initializeWasm() must be awaited first!");
12450 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_ok(o);
12451 return nativeResponseValue;
12453 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
12455 export function CResult_NodeInfoDecodeErrorZ_err(e: number): number {
12456 if(!isWasmInitialized) {
12457 throw new Error("initializeWasm() must be awaited first!");
12459 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_err(e);
12460 return nativeResponseValue;
12462 // bool CResult_NodeInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR o);
12464 export function CResult_NodeInfoDecodeErrorZ_is_ok(o: number): boolean {
12465 if(!isWasmInitialized) {
12466 throw new Error("initializeWasm() must be awaited first!");
12468 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_is_ok(o);
12469 return nativeResponseValue;
12471 // void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
12473 export function CResult_NodeInfoDecodeErrorZ_free(_res: number): void {
12474 if(!isWasmInitialized) {
12475 throw new Error("initializeWasm() must be awaited first!");
12477 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_free(_res);
12478 // debug statements here
12480 // uintptr_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg);
12482 export function CResult_NodeInfoDecodeErrorZ_clone_ptr(arg: number): number {
12483 if(!isWasmInitialized) {
12484 throw new Error("initializeWasm() must be awaited first!");
12486 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(arg);
12487 return nativeResponseValue;
12489 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
12491 export function CResult_NodeInfoDecodeErrorZ_clone(orig: number): number {
12492 if(!isWasmInitialized) {
12493 throw new Error("initializeWasm() must be awaited first!");
12495 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone(orig);
12496 return nativeResponseValue;
12498 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
12500 export function CResult_NetworkGraphDecodeErrorZ_ok(o: number): number {
12501 if(!isWasmInitialized) {
12502 throw new Error("initializeWasm() must be awaited first!");
12504 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_ok(o);
12505 return nativeResponseValue;
12507 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
12509 export function CResult_NetworkGraphDecodeErrorZ_err(e: number): number {
12510 if(!isWasmInitialized) {
12511 throw new Error("initializeWasm() must be awaited first!");
12513 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_err(e);
12514 return nativeResponseValue;
12516 // bool CResult_NetworkGraphDecodeErrorZ_is_ok(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR o);
12518 export function CResult_NetworkGraphDecodeErrorZ_is_ok(o: number): boolean {
12519 if(!isWasmInitialized) {
12520 throw new Error("initializeWasm() must be awaited first!");
12522 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_is_ok(o);
12523 return nativeResponseValue;
12525 // void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
12527 export function CResult_NetworkGraphDecodeErrorZ_free(_res: number): void {
12528 if(!isWasmInitialized) {
12529 throw new Error("initializeWasm() must be awaited first!");
12531 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_free(_res);
12532 // debug statements here
12534 // uintptr_t CResult_NetworkGraphDecodeErrorZ_clone_ptr(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR arg);
12536 export function CResult_NetworkGraphDecodeErrorZ_clone_ptr(arg: number): number {
12537 if(!isWasmInitialized) {
12538 throw new Error("initializeWasm() must be awaited first!");
12540 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_clone_ptr(arg);
12541 return nativeResponseValue;
12543 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_clone(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR orig);
12545 export function CResult_NetworkGraphDecodeErrorZ_clone(orig: number): number {
12546 if(!isWasmInitialized) {
12547 throw new Error("initializeWasm() must be awaited first!");
12549 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_clone(orig);
12550 return nativeResponseValue;
12552 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_some(struct LDKCVec_NetAddressZ o);
12554 export function COption_CVec_NetAddressZZ_some(o: number): number {
12555 if(!isWasmInitialized) {
12556 throw new Error("initializeWasm() must be awaited first!");
12558 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_some(o);
12559 return nativeResponseValue;
12561 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_none(void);
12563 export function COption_CVec_NetAddressZZ_none(): number {
12564 if(!isWasmInitialized) {
12565 throw new Error("initializeWasm() must be awaited first!");
12567 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_none();
12568 return nativeResponseValue;
12570 // void COption_CVec_NetAddressZZ_free(struct LDKCOption_CVec_NetAddressZZ _res);
12572 export function COption_CVec_NetAddressZZ_free(_res: number): void {
12573 if(!isWasmInitialized) {
12574 throw new Error("initializeWasm() must be awaited first!");
12576 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_free(_res);
12577 // debug statements here
12579 // uintptr_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg);
12581 export function COption_CVec_NetAddressZZ_clone_ptr(arg: number): number {
12582 if(!isWasmInitialized) {
12583 throw new Error("initializeWasm() must be awaited first!");
12585 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone_ptr(arg);
12586 return nativeResponseValue;
12588 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_clone(const struct LDKCOption_CVec_NetAddressZZ *NONNULL_PTR orig);
12590 export function COption_CVec_NetAddressZZ_clone(orig: number): number {
12591 if(!isWasmInitialized) {
12592 throw new Error("initializeWasm() must be awaited first!");
12594 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone(orig);
12595 return nativeResponseValue;
12597 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_ok(struct LDKNetAddress o);
12599 export function CResult_NetAddressDecodeErrorZ_ok(o: number): number {
12600 if(!isWasmInitialized) {
12601 throw new Error("initializeWasm() must be awaited first!");
12603 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_ok(o);
12604 return nativeResponseValue;
12606 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_err(struct LDKDecodeError e);
12608 export function CResult_NetAddressDecodeErrorZ_err(e: number): number {
12609 if(!isWasmInitialized) {
12610 throw new Error("initializeWasm() must be awaited first!");
12612 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_err(e);
12613 return nativeResponseValue;
12615 // bool CResult_NetAddressDecodeErrorZ_is_ok(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR o);
12617 export function CResult_NetAddressDecodeErrorZ_is_ok(o: number): boolean {
12618 if(!isWasmInitialized) {
12619 throw new Error("initializeWasm() must be awaited first!");
12621 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_is_ok(o);
12622 return nativeResponseValue;
12624 // void CResult_NetAddressDecodeErrorZ_free(struct LDKCResult_NetAddressDecodeErrorZ _res);
12626 export function CResult_NetAddressDecodeErrorZ_free(_res: number): void {
12627 if(!isWasmInitialized) {
12628 throw new Error("initializeWasm() must be awaited first!");
12630 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_free(_res);
12631 // debug statements here
12633 // uintptr_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg);
12635 export function CResult_NetAddressDecodeErrorZ_clone_ptr(arg: number): number {
12636 if(!isWasmInitialized) {
12637 throw new Error("initializeWasm() must be awaited first!");
12639 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone_ptr(arg);
12640 return nativeResponseValue;
12642 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_clone(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR orig);
12644 export function CResult_NetAddressDecodeErrorZ_clone(orig: number): number {
12645 if(!isWasmInitialized) {
12646 throw new Error("initializeWasm() must be awaited first!");
12648 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone(orig);
12649 return nativeResponseValue;
12651 // void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
12653 export function CVec_UpdateAddHTLCZ_free(_res: number): void {
12654 if(!isWasmInitialized) {
12655 throw new Error("initializeWasm() must be awaited first!");
12657 const nativeResponseValue = wasm.TS_CVec_UpdateAddHTLCZ_free(_res);
12658 // debug statements here
12660 // void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
12662 export function CVec_UpdateFulfillHTLCZ_free(_res: number): void {
12663 if(!isWasmInitialized) {
12664 throw new Error("initializeWasm() must be awaited first!");
12666 const nativeResponseValue = wasm.TS_CVec_UpdateFulfillHTLCZ_free(_res);
12667 // debug statements here
12669 // void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
12671 export function CVec_UpdateFailHTLCZ_free(_res: number): void {
12672 if(!isWasmInitialized) {
12673 throw new Error("initializeWasm() must be awaited first!");
12675 const nativeResponseValue = wasm.TS_CVec_UpdateFailHTLCZ_free(_res);
12676 // debug statements here
12678 // void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
12680 export function CVec_UpdateFailMalformedHTLCZ_free(_res: number): void {
12681 if(!isWasmInitialized) {
12682 throw new Error("initializeWasm() must be awaited first!");
12684 const nativeResponseValue = wasm.TS_CVec_UpdateFailMalformedHTLCZ_free(_res);
12685 // debug statements here
12687 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
12689 export function CResult_AcceptChannelDecodeErrorZ_ok(o: number): number {
12690 if(!isWasmInitialized) {
12691 throw new Error("initializeWasm() must be awaited first!");
12693 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_ok(o);
12694 return nativeResponseValue;
12696 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
12698 export function CResult_AcceptChannelDecodeErrorZ_err(e: number): number {
12699 if(!isWasmInitialized) {
12700 throw new Error("initializeWasm() must be awaited first!");
12702 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_err(e);
12703 return nativeResponseValue;
12705 // bool CResult_AcceptChannelDecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR o);
12707 export function CResult_AcceptChannelDecodeErrorZ_is_ok(o: number): boolean {
12708 if(!isWasmInitialized) {
12709 throw new Error("initializeWasm() must be awaited first!");
12711 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_is_ok(o);
12712 return nativeResponseValue;
12714 // void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
12716 export function CResult_AcceptChannelDecodeErrorZ_free(_res: number): void {
12717 if(!isWasmInitialized) {
12718 throw new Error("initializeWasm() must be awaited first!");
12720 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_free(_res);
12721 // debug statements here
12723 // uintptr_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg);
12725 export function CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg: number): number {
12726 if(!isWasmInitialized) {
12727 throw new Error("initializeWasm() must be awaited first!");
12729 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg);
12730 return nativeResponseValue;
12732 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
12734 export function CResult_AcceptChannelDecodeErrorZ_clone(orig: number): number {
12735 if(!isWasmInitialized) {
12736 throw new Error("initializeWasm() must be awaited first!");
12738 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone(orig);
12739 return nativeResponseValue;
12741 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
12743 export function CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: number): number {
12744 if(!isWasmInitialized) {
12745 throw new Error("initializeWasm() must be awaited first!");
12747 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(o);
12748 return nativeResponseValue;
12750 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
12752 export function CResult_AnnouncementSignaturesDecodeErrorZ_err(e: number): number {
12753 if(!isWasmInitialized) {
12754 throw new Error("initializeWasm() must be awaited first!");
12756 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(e);
12757 return nativeResponseValue;
12759 // bool CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR o);
12761 export function CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o: number): boolean {
12762 if(!isWasmInitialized) {
12763 throw new Error("initializeWasm() must be awaited first!");
12765 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o);
12766 return nativeResponseValue;
12768 // void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
12770 export function CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: number): void {
12771 if(!isWasmInitialized) {
12772 throw new Error("initializeWasm() must be awaited first!");
12774 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(_res);
12775 // debug statements here
12777 // uintptr_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg);
12779 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg: number): number {
12780 if(!isWasmInitialized) {
12781 throw new Error("initializeWasm() must be awaited first!");
12783 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg);
12784 return nativeResponseValue;
12786 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
12788 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: number): number {
12789 if(!isWasmInitialized) {
12790 throw new Error("initializeWasm() must be awaited first!");
12792 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig);
12793 return nativeResponseValue;
12795 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
12797 export function CResult_ChannelReestablishDecodeErrorZ_ok(o: number): number {
12798 if(!isWasmInitialized) {
12799 throw new Error("initializeWasm() must be awaited first!");
12801 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_ok(o);
12802 return nativeResponseValue;
12804 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
12806 export function CResult_ChannelReestablishDecodeErrorZ_err(e: number): number {
12807 if(!isWasmInitialized) {
12808 throw new Error("initializeWasm() must be awaited first!");
12810 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_err(e);
12811 return nativeResponseValue;
12813 // bool CResult_ChannelReestablishDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR o);
12815 export function CResult_ChannelReestablishDecodeErrorZ_is_ok(o: number): boolean {
12816 if(!isWasmInitialized) {
12817 throw new Error("initializeWasm() must be awaited first!");
12819 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(o);
12820 return nativeResponseValue;
12822 // void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
12824 export function CResult_ChannelReestablishDecodeErrorZ_free(_res: number): void {
12825 if(!isWasmInitialized) {
12826 throw new Error("initializeWasm() must be awaited first!");
12828 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_free(_res);
12829 // debug statements here
12831 // uintptr_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg);
12833 export function CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg: number): number {
12834 if(!isWasmInitialized) {
12835 throw new Error("initializeWasm() must be awaited first!");
12837 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg);
12838 return nativeResponseValue;
12840 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
12842 export function CResult_ChannelReestablishDecodeErrorZ_clone(orig: number): number {
12843 if(!isWasmInitialized) {
12844 throw new Error("initializeWasm() must be awaited first!");
12846 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone(orig);
12847 return nativeResponseValue;
12849 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
12851 export function CResult_ClosingSignedDecodeErrorZ_ok(o: number): number {
12852 if(!isWasmInitialized) {
12853 throw new Error("initializeWasm() must be awaited first!");
12855 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_ok(o);
12856 return nativeResponseValue;
12858 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
12860 export function CResult_ClosingSignedDecodeErrorZ_err(e: number): number {
12861 if(!isWasmInitialized) {
12862 throw new Error("initializeWasm() must be awaited first!");
12864 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_err(e);
12865 return nativeResponseValue;
12867 // bool CResult_ClosingSignedDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR o);
12869 export function CResult_ClosingSignedDecodeErrorZ_is_ok(o: number): boolean {
12870 if(!isWasmInitialized) {
12871 throw new Error("initializeWasm() must be awaited first!");
12873 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_is_ok(o);
12874 return nativeResponseValue;
12876 // void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
12878 export function CResult_ClosingSignedDecodeErrorZ_free(_res: number): void {
12879 if(!isWasmInitialized) {
12880 throw new Error("initializeWasm() must be awaited first!");
12882 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_free(_res);
12883 // debug statements here
12885 // uintptr_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg);
12887 export function CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg: number): number {
12888 if(!isWasmInitialized) {
12889 throw new Error("initializeWasm() must be awaited first!");
12891 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg);
12892 return nativeResponseValue;
12894 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
12896 export function CResult_ClosingSignedDecodeErrorZ_clone(orig: number): number {
12897 if(!isWasmInitialized) {
12898 throw new Error("initializeWasm() must be awaited first!");
12900 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone(orig);
12901 return nativeResponseValue;
12903 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(struct LDKClosingSignedFeeRange o);
12905 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o: number): number {
12906 if(!isWasmInitialized) {
12907 throw new Error("initializeWasm() must be awaited first!");
12909 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o);
12910 return nativeResponseValue;
12912 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_err(struct LDKDecodeError e);
12914 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e: number): number {
12915 if(!isWasmInitialized) {
12916 throw new Error("initializeWasm() must be awaited first!");
12918 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e);
12919 return nativeResponseValue;
12921 // bool CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR o);
12923 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o: number): boolean {
12924 if(!isWasmInitialized) {
12925 throw new Error("initializeWasm() must be awaited first!");
12927 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o);
12928 return nativeResponseValue;
12930 // void CResult_ClosingSignedFeeRangeDecodeErrorZ_free(struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res);
12932 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res: number): void {
12933 if(!isWasmInitialized) {
12934 throw new Error("initializeWasm() must be awaited first!");
12936 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res);
12937 // debug statements here
12939 // uintptr_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg);
12941 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg: number): number {
12942 if(!isWasmInitialized) {
12943 throw new Error("initializeWasm() must be awaited first!");
12945 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg);
12946 return nativeResponseValue;
12948 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR orig);
12950 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig: number): number {
12951 if(!isWasmInitialized) {
12952 throw new Error("initializeWasm() must be awaited first!");
12954 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig);
12955 return nativeResponseValue;
12957 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
12959 export function CResult_CommitmentSignedDecodeErrorZ_ok(o: number): number {
12960 if(!isWasmInitialized) {
12961 throw new Error("initializeWasm() must be awaited first!");
12963 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_ok(o);
12964 return nativeResponseValue;
12966 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
12968 export function CResult_CommitmentSignedDecodeErrorZ_err(e: number): number {
12969 if(!isWasmInitialized) {
12970 throw new Error("initializeWasm() must be awaited first!");
12972 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_err(e);
12973 return nativeResponseValue;
12975 // bool CResult_CommitmentSignedDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR o);
12977 export function CResult_CommitmentSignedDecodeErrorZ_is_ok(o: number): boolean {
12978 if(!isWasmInitialized) {
12979 throw new Error("initializeWasm() must be awaited first!");
12981 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(o);
12982 return nativeResponseValue;
12984 // void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
12986 export function CResult_CommitmentSignedDecodeErrorZ_free(_res: number): void {
12987 if(!isWasmInitialized) {
12988 throw new Error("initializeWasm() must be awaited first!");
12990 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_free(_res);
12991 // debug statements here
12993 // uintptr_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg);
12995 export function CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg: number): number {
12996 if(!isWasmInitialized) {
12997 throw new Error("initializeWasm() must be awaited first!");
12999 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg);
13000 return nativeResponseValue;
13002 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
13004 export function CResult_CommitmentSignedDecodeErrorZ_clone(orig: number): number {
13005 if(!isWasmInitialized) {
13006 throw new Error("initializeWasm() must be awaited first!");
13008 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone(orig);
13009 return nativeResponseValue;
13011 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
13013 export function CResult_FundingCreatedDecodeErrorZ_ok(o: number): number {
13014 if(!isWasmInitialized) {
13015 throw new Error("initializeWasm() must be awaited first!");
13017 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_ok(o);
13018 return nativeResponseValue;
13020 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
13022 export function CResult_FundingCreatedDecodeErrorZ_err(e: number): number {
13023 if(!isWasmInitialized) {
13024 throw new Error("initializeWasm() must be awaited first!");
13026 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_err(e);
13027 return nativeResponseValue;
13029 // bool CResult_FundingCreatedDecodeErrorZ_is_ok(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR o);
13031 export function CResult_FundingCreatedDecodeErrorZ_is_ok(o: number): boolean {
13032 if(!isWasmInitialized) {
13033 throw new Error("initializeWasm() must be awaited first!");
13035 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_is_ok(o);
13036 return nativeResponseValue;
13038 // void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
13040 export function CResult_FundingCreatedDecodeErrorZ_free(_res: number): void {
13041 if(!isWasmInitialized) {
13042 throw new Error("initializeWasm() must be awaited first!");
13044 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_free(_res);
13045 // debug statements here
13047 // uintptr_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg);
13049 export function CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg: number): number {
13050 if(!isWasmInitialized) {
13051 throw new Error("initializeWasm() must be awaited first!");
13053 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg);
13054 return nativeResponseValue;
13056 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
13058 export function CResult_FundingCreatedDecodeErrorZ_clone(orig: number): number {
13059 if(!isWasmInitialized) {
13060 throw new Error("initializeWasm() must be awaited first!");
13062 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone(orig);
13063 return nativeResponseValue;
13065 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
13067 export function CResult_FundingSignedDecodeErrorZ_ok(o: number): number {
13068 if(!isWasmInitialized) {
13069 throw new Error("initializeWasm() must be awaited first!");
13071 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_ok(o);
13072 return nativeResponseValue;
13074 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
13076 export function CResult_FundingSignedDecodeErrorZ_err(e: number): number {
13077 if(!isWasmInitialized) {
13078 throw new Error("initializeWasm() must be awaited first!");
13080 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_err(e);
13081 return nativeResponseValue;
13083 // bool CResult_FundingSignedDecodeErrorZ_is_ok(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR o);
13085 export function CResult_FundingSignedDecodeErrorZ_is_ok(o: number): boolean {
13086 if(!isWasmInitialized) {
13087 throw new Error("initializeWasm() must be awaited first!");
13089 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_is_ok(o);
13090 return nativeResponseValue;
13092 // void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
13094 export function CResult_FundingSignedDecodeErrorZ_free(_res: number): void {
13095 if(!isWasmInitialized) {
13096 throw new Error("initializeWasm() must be awaited first!");
13098 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_free(_res);
13099 // debug statements here
13101 // uintptr_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg);
13103 export function CResult_FundingSignedDecodeErrorZ_clone_ptr(arg: number): number {
13104 if(!isWasmInitialized) {
13105 throw new Error("initializeWasm() must be awaited first!");
13107 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(arg);
13108 return nativeResponseValue;
13110 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
13112 export function CResult_FundingSignedDecodeErrorZ_clone(orig: number): number {
13113 if(!isWasmInitialized) {
13114 throw new Error("initializeWasm() must be awaited first!");
13116 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone(orig);
13117 return nativeResponseValue;
13119 // struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_ok(struct LDKFundingLocked o);
13121 export function CResult_FundingLockedDecodeErrorZ_ok(o: number): number {
13122 if(!isWasmInitialized) {
13123 throw new Error("initializeWasm() must be awaited first!");
13125 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_ok(o);
13126 return nativeResponseValue;
13128 // struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_err(struct LDKDecodeError e);
13130 export function CResult_FundingLockedDecodeErrorZ_err(e: number): number {
13131 if(!isWasmInitialized) {
13132 throw new Error("initializeWasm() must be awaited first!");
13134 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_err(e);
13135 return nativeResponseValue;
13137 // bool CResult_FundingLockedDecodeErrorZ_is_ok(const struct LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR o);
13139 export function CResult_FundingLockedDecodeErrorZ_is_ok(o: number): boolean {
13140 if(!isWasmInitialized) {
13141 throw new Error("initializeWasm() must be awaited first!");
13143 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_is_ok(o);
13144 return nativeResponseValue;
13146 // void CResult_FundingLockedDecodeErrorZ_free(struct LDKCResult_FundingLockedDecodeErrorZ _res);
13148 export function CResult_FundingLockedDecodeErrorZ_free(_res: number): void {
13149 if(!isWasmInitialized) {
13150 throw new Error("initializeWasm() must be awaited first!");
13152 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_free(_res);
13153 // debug statements here
13155 // uintptr_t CResult_FundingLockedDecodeErrorZ_clone_ptr(LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR arg);
13157 export function CResult_FundingLockedDecodeErrorZ_clone_ptr(arg: number): number {
13158 if(!isWasmInitialized) {
13159 throw new Error("initializeWasm() must be awaited first!");
13161 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_clone_ptr(arg);
13162 return nativeResponseValue;
13164 // struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_clone(const struct LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR orig);
13166 export function CResult_FundingLockedDecodeErrorZ_clone(orig: number): number {
13167 if(!isWasmInitialized) {
13168 throw new Error("initializeWasm() must be awaited first!");
13170 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_clone(orig);
13171 return nativeResponseValue;
13173 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
13175 export function CResult_InitDecodeErrorZ_ok(o: number): number {
13176 if(!isWasmInitialized) {
13177 throw new Error("initializeWasm() must be awaited first!");
13179 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_ok(o);
13180 return nativeResponseValue;
13182 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
13184 export function CResult_InitDecodeErrorZ_err(e: number): number {
13185 if(!isWasmInitialized) {
13186 throw new Error("initializeWasm() must be awaited first!");
13188 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_err(e);
13189 return nativeResponseValue;
13191 // bool CResult_InitDecodeErrorZ_is_ok(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR o);
13193 export function CResult_InitDecodeErrorZ_is_ok(o: number): boolean {
13194 if(!isWasmInitialized) {
13195 throw new Error("initializeWasm() must be awaited first!");
13197 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_is_ok(o);
13198 return nativeResponseValue;
13200 // void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
13202 export function CResult_InitDecodeErrorZ_free(_res: number): void {
13203 if(!isWasmInitialized) {
13204 throw new Error("initializeWasm() must be awaited first!");
13206 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_free(_res);
13207 // debug statements here
13209 // uintptr_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg);
13211 export function CResult_InitDecodeErrorZ_clone_ptr(arg: number): number {
13212 if(!isWasmInitialized) {
13213 throw new Error("initializeWasm() must be awaited first!");
13215 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone_ptr(arg);
13216 return nativeResponseValue;
13218 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
13220 export function CResult_InitDecodeErrorZ_clone(orig: number): number {
13221 if(!isWasmInitialized) {
13222 throw new Error("initializeWasm() must be awaited first!");
13224 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone(orig);
13225 return nativeResponseValue;
13227 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
13229 export function CResult_OpenChannelDecodeErrorZ_ok(o: number): number {
13230 if(!isWasmInitialized) {
13231 throw new Error("initializeWasm() must be awaited first!");
13233 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_ok(o);
13234 return nativeResponseValue;
13236 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
13238 export function CResult_OpenChannelDecodeErrorZ_err(e: number): number {
13239 if(!isWasmInitialized) {
13240 throw new Error("initializeWasm() must be awaited first!");
13242 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_err(e);
13243 return nativeResponseValue;
13245 // bool CResult_OpenChannelDecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR o);
13247 export function CResult_OpenChannelDecodeErrorZ_is_ok(o: number): boolean {
13248 if(!isWasmInitialized) {
13249 throw new Error("initializeWasm() must be awaited first!");
13251 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_is_ok(o);
13252 return nativeResponseValue;
13254 // void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
13256 export function CResult_OpenChannelDecodeErrorZ_free(_res: number): void {
13257 if(!isWasmInitialized) {
13258 throw new Error("initializeWasm() must be awaited first!");
13260 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_free(_res);
13261 // debug statements here
13263 // uintptr_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg);
13265 export function CResult_OpenChannelDecodeErrorZ_clone_ptr(arg: number): number {
13266 if(!isWasmInitialized) {
13267 throw new Error("initializeWasm() must be awaited first!");
13269 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(arg);
13270 return nativeResponseValue;
13272 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
13274 export function CResult_OpenChannelDecodeErrorZ_clone(orig: number): number {
13275 if(!isWasmInitialized) {
13276 throw new Error("initializeWasm() must be awaited first!");
13278 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone(orig);
13279 return nativeResponseValue;
13281 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
13283 export function CResult_RevokeAndACKDecodeErrorZ_ok(o: number): number {
13284 if(!isWasmInitialized) {
13285 throw new Error("initializeWasm() must be awaited first!");
13287 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_ok(o);
13288 return nativeResponseValue;
13290 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
13292 export function CResult_RevokeAndACKDecodeErrorZ_err(e: number): number {
13293 if(!isWasmInitialized) {
13294 throw new Error("initializeWasm() must be awaited first!");
13296 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_err(e);
13297 return nativeResponseValue;
13299 // bool CResult_RevokeAndACKDecodeErrorZ_is_ok(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR o);
13301 export function CResult_RevokeAndACKDecodeErrorZ_is_ok(o: number): boolean {
13302 if(!isWasmInitialized) {
13303 throw new Error("initializeWasm() must be awaited first!");
13305 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(o);
13306 return nativeResponseValue;
13308 // void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
13310 export function CResult_RevokeAndACKDecodeErrorZ_free(_res: number): void {
13311 if(!isWasmInitialized) {
13312 throw new Error("initializeWasm() must be awaited first!");
13314 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_free(_res);
13315 // debug statements here
13317 // uintptr_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg);
13319 export function CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg: number): number {
13320 if(!isWasmInitialized) {
13321 throw new Error("initializeWasm() must be awaited first!");
13323 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg);
13324 return nativeResponseValue;
13326 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
13328 export function CResult_RevokeAndACKDecodeErrorZ_clone(orig: number): number {
13329 if(!isWasmInitialized) {
13330 throw new Error("initializeWasm() must be awaited first!");
13332 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone(orig);
13333 return nativeResponseValue;
13335 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
13337 export function CResult_ShutdownDecodeErrorZ_ok(o: number): number {
13338 if(!isWasmInitialized) {
13339 throw new Error("initializeWasm() must be awaited first!");
13341 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_ok(o);
13342 return nativeResponseValue;
13344 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
13346 export function CResult_ShutdownDecodeErrorZ_err(e: number): number {
13347 if(!isWasmInitialized) {
13348 throw new Error("initializeWasm() must be awaited first!");
13350 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_err(e);
13351 return nativeResponseValue;
13353 // bool CResult_ShutdownDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR o);
13355 export function CResult_ShutdownDecodeErrorZ_is_ok(o: number): boolean {
13356 if(!isWasmInitialized) {
13357 throw new Error("initializeWasm() must be awaited first!");
13359 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_is_ok(o);
13360 return nativeResponseValue;
13362 // void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
13364 export function CResult_ShutdownDecodeErrorZ_free(_res: number): void {
13365 if(!isWasmInitialized) {
13366 throw new Error("initializeWasm() must be awaited first!");
13368 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_free(_res);
13369 // debug statements here
13371 // uintptr_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg);
13373 export function CResult_ShutdownDecodeErrorZ_clone_ptr(arg: number): number {
13374 if(!isWasmInitialized) {
13375 throw new Error("initializeWasm() must be awaited first!");
13377 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone_ptr(arg);
13378 return nativeResponseValue;
13380 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
13382 export function CResult_ShutdownDecodeErrorZ_clone(orig: number): number {
13383 if(!isWasmInitialized) {
13384 throw new Error("initializeWasm() must be awaited first!");
13386 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone(orig);
13387 return nativeResponseValue;
13389 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
13391 export function CResult_UpdateFailHTLCDecodeErrorZ_ok(o: number): number {
13392 if(!isWasmInitialized) {
13393 throw new Error("initializeWasm() must be awaited first!");
13395 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(o);
13396 return nativeResponseValue;
13398 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
13400 export function CResult_UpdateFailHTLCDecodeErrorZ_err(e: number): number {
13401 if(!isWasmInitialized) {
13402 throw new Error("initializeWasm() must be awaited first!");
13404 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_err(e);
13405 return nativeResponseValue;
13407 // bool CResult_UpdateFailHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR o);
13409 export function CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o: number): boolean {
13410 if(!isWasmInitialized) {
13411 throw new Error("initializeWasm() must be awaited first!");
13413 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o);
13414 return nativeResponseValue;
13416 // void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
13418 export function CResult_UpdateFailHTLCDecodeErrorZ_free(_res: number): void {
13419 if(!isWasmInitialized) {
13420 throw new Error("initializeWasm() must be awaited first!");
13422 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_free(_res);
13423 // debug statements here
13425 // uintptr_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg);
13427 export function CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg: number): number {
13428 if(!isWasmInitialized) {
13429 throw new Error("initializeWasm() must be awaited first!");
13431 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg);
13432 return nativeResponseValue;
13434 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
13436 export function CResult_UpdateFailHTLCDecodeErrorZ_clone(orig: number): number {
13437 if(!isWasmInitialized) {
13438 throw new Error("initializeWasm() must be awaited first!");
13440 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(orig);
13441 return nativeResponseValue;
13443 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
13445 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o: number): number {
13446 if(!isWasmInitialized) {
13447 throw new Error("initializeWasm() must be awaited first!");
13449 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o);
13450 return nativeResponseValue;
13452 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
13454 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e: number): number {
13455 if(!isWasmInitialized) {
13456 throw new Error("initializeWasm() must be awaited first!");
13458 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e);
13459 return nativeResponseValue;
13461 // bool CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR o);
13463 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o: number): boolean {
13464 if(!isWasmInitialized) {
13465 throw new Error("initializeWasm() must be awaited first!");
13467 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o);
13468 return nativeResponseValue;
13470 // void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
13472 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res: number): void {
13473 if(!isWasmInitialized) {
13474 throw new Error("initializeWasm() must be awaited first!");
13476 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res);
13477 // debug statements here
13479 // uintptr_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg);
13481 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg: number): number {
13482 if(!isWasmInitialized) {
13483 throw new Error("initializeWasm() must be awaited first!");
13485 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg);
13486 return nativeResponseValue;
13488 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
13490 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig: number): number {
13491 if(!isWasmInitialized) {
13492 throw new Error("initializeWasm() must be awaited first!");
13494 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig);
13495 return nativeResponseValue;
13497 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
13499 export function CResult_UpdateFeeDecodeErrorZ_ok(o: number): number {
13500 if(!isWasmInitialized) {
13501 throw new Error("initializeWasm() must be awaited first!");
13503 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_ok(o);
13504 return nativeResponseValue;
13506 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
13508 export function CResult_UpdateFeeDecodeErrorZ_err(e: number): number {
13509 if(!isWasmInitialized) {
13510 throw new Error("initializeWasm() must be awaited first!");
13512 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_err(e);
13513 return nativeResponseValue;
13515 // bool CResult_UpdateFeeDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR o);
13517 export function CResult_UpdateFeeDecodeErrorZ_is_ok(o: number): boolean {
13518 if(!isWasmInitialized) {
13519 throw new Error("initializeWasm() must be awaited first!");
13521 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_is_ok(o);
13522 return nativeResponseValue;
13524 // void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
13526 export function CResult_UpdateFeeDecodeErrorZ_free(_res: number): void {
13527 if(!isWasmInitialized) {
13528 throw new Error("initializeWasm() must be awaited first!");
13530 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_free(_res);
13531 // debug statements here
13533 // uintptr_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg);
13535 export function CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg: number): number {
13536 if(!isWasmInitialized) {
13537 throw new Error("initializeWasm() must be awaited first!");
13539 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg);
13540 return nativeResponseValue;
13542 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
13544 export function CResult_UpdateFeeDecodeErrorZ_clone(orig: number): number {
13545 if(!isWasmInitialized) {
13546 throw new Error("initializeWasm() must be awaited first!");
13548 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone(orig);
13549 return nativeResponseValue;
13551 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
13553 export function CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o: number): number {
13554 if(!isWasmInitialized) {
13555 throw new Error("initializeWasm() must be awaited first!");
13557 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o);
13558 return nativeResponseValue;
13560 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
13562 export function CResult_UpdateFulfillHTLCDecodeErrorZ_err(e: number): number {
13563 if(!isWasmInitialized) {
13564 throw new Error("initializeWasm() must be awaited first!");
13566 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(e);
13567 return nativeResponseValue;
13569 // bool CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR o);
13571 export function CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o: number): boolean {
13572 if(!isWasmInitialized) {
13573 throw new Error("initializeWasm() must be awaited first!");
13575 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o);
13576 return nativeResponseValue;
13578 // void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
13580 export function CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res: number): void {
13581 if(!isWasmInitialized) {
13582 throw new Error("initializeWasm() must be awaited first!");
13584 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res);
13585 // debug statements here
13587 // uintptr_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg);
13589 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg: number): number {
13590 if(!isWasmInitialized) {
13591 throw new Error("initializeWasm() must be awaited first!");
13593 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg);
13594 return nativeResponseValue;
13596 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
13598 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig: number): number {
13599 if(!isWasmInitialized) {
13600 throw new Error("initializeWasm() must be awaited first!");
13602 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig);
13603 return nativeResponseValue;
13605 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
13607 export function CResult_UpdateAddHTLCDecodeErrorZ_ok(o: number): number {
13608 if(!isWasmInitialized) {
13609 throw new Error("initializeWasm() must be awaited first!");
13611 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(o);
13612 return nativeResponseValue;
13614 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
13616 export function CResult_UpdateAddHTLCDecodeErrorZ_err(e: number): number {
13617 if(!isWasmInitialized) {
13618 throw new Error("initializeWasm() must be awaited first!");
13620 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_err(e);
13621 return nativeResponseValue;
13623 // bool CResult_UpdateAddHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR o);
13625 export function CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o: number): boolean {
13626 if(!isWasmInitialized) {
13627 throw new Error("initializeWasm() must be awaited first!");
13629 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o);
13630 return nativeResponseValue;
13632 // void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
13634 export function CResult_UpdateAddHTLCDecodeErrorZ_free(_res: number): void {
13635 if(!isWasmInitialized) {
13636 throw new Error("initializeWasm() must be awaited first!");
13638 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_free(_res);
13639 // debug statements here
13641 // uintptr_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg);
13643 export function CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg: number): number {
13644 if(!isWasmInitialized) {
13645 throw new Error("initializeWasm() must be awaited first!");
13647 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg);
13648 return nativeResponseValue;
13650 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
13652 export function CResult_UpdateAddHTLCDecodeErrorZ_clone(orig: number): number {
13653 if(!isWasmInitialized) {
13654 throw new Error("initializeWasm() must be awaited first!");
13656 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(orig);
13657 return nativeResponseValue;
13659 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
13661 export function CResult_PingDecodeErrorZ_ok(o: number): number {
13662 if(!isWasmInitialized) {
13663 throw new Error("initializeWasm() must be awaited first!");
13665 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_ok(o);
13666 return nativeResponseValue;
13668 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
13670 export function CResult_PingDecodeErrorZ_err(e: number): number {
13671 if(!isWasmInitialized) {
13672 throw new Error("initializeWasm() must be awaited first!");
13674 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_err(e);
13675 return nativeResponseValue;
13677 // bool CResult_PingDecodeErrorZ_is_ok(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR o);
13679 export function CResult_PingDecodeErrorZ_is_ok(o: number): boolean {
13680 if(!isWasmInitialized) {
13681 throw new Error("initializeWasm() must be awaited first!");
13683 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_is_ok(o);
13684 return nativeResponseValue;
13686 // void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
13688 export function CResult_PingDecodeErrorZ_free(_res: number): void {
13689 if(!isWasmInitialized) {
13690 throw new Error("initializeWasm() must be awaited first!");
13692 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_free(_res);
13693 // debug statements here
13695 // uintptr_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg);
13697 export function CResult_PingDecodeErrorZ_clone_ptr(arg: number): number {
13698 if(!isWasmInitialized) {
13699 throw new Error("initializeWasm() must be awaited first!");
13701 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone_ptr(arg);
13702 return nativeResponseValue;
13704 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
13706 export function CResult_PingDecodeErrorZ_clone(orig: number): number {
13707 if(!isWasmInitialized) {
13708 throw new Error("initializeWasm() must be awaited first!");
13710 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone(orig);
13711 return nativeResponseValue;
13713 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
13715 export function CResult_PongDecodeErrorZ_ok(o: number): number {
13716 if(!isWasmInitialized) {
13717 throw new Error("initializeWasm() must be awaited first!");
13719 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_ok(o);
13720 return nativeResponseValue;
13722 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
13724 export function CResult_PongDecodeErrorZ_err(e: number): number {
13725 if(!isWasmInitialized) {
13726 throw new Error("initializeWasm() must be awaited first!");
13728 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_err(e);
13729 return nativeResponseValue;
13731 // bool CResult_PongDecodeErrorZ_is_ok(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR o);
13733 export function CResult_PongDecodeErrorZ_is_ok(o: number): boolean {
13734 if(!isWasmInitialized) {
13735 throw new Error("initializeWasm() must be awaited first!");
13737 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_is_ok(o);
13738 return nativeResponseValue;
13740 // void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
13742 export function CResult_PongDecodeErrorZ_free(_res: number): void {
13743 if(!isWasmInitialized) {
13744 throw new Error("initializeWasm() must be awaited first!");
13746 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_free(_res);
13747 // debug statements here
13749 // uintptr_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg);
13751 export function CResult_PongDecodeErrorZ_clone_ptr(arg: number): number {
13752 if(!isWasmInitialized) {
13753 throw new Error("initializeWasm() must be awaited first!");
13755 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone_ptr(arg);
13756 return nativeResponseValue;
13758 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
13760 export function CResult_PongDecodeErrorZ_clone(orig: number): number {
13761 if(!isWasmInitialized) {
13762 throw new Error("initializeWasm() must be awaited first!");
13764 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone(orig);
13765 return nativeResponseValue;
13767 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
13769 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o: number): number {
13770 if(!isWasmInitialized) {
13771 throw new Error("initializeWasm() must be awaited first!");
13773 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o);
13774 return nativeResponseValue;
13776 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
13778 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e: number): number {
13779 if(!isWasmInitialized) {
13780 throw new Error("initializeWasm() must be awaited first!");
13782 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e);
13783 return nativeResponseValue;
13785 // bool CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
13787 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
13788 if(!isWasmInitialized) {
13789 throw new Error("initializeWasm() must be awaited first!");
13791 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o);
13792 return nativeResponseValue;
13794 // void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
13796 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res: number): void {
13797 if(!isWasmInitialized) {
13798 throw new Error("initializeWasm() must be awaited first!");
13800 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res);
13801 // debug statements here
13803 // uintptr_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
13805 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
13806 if(!isWasmInitialized) {
13807 throw new Error("initializeWasm() must be awaited first!");
13809 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
13810 return nativeResponseValue;
13812 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
13814 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
13815 if(!isWasmInitialized) {
13816 throw new Error("initializeWasm() must be awaited first!");
13818 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig);
13819 return nativeResponseValue;
13821 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
13823 export function CResult_ChannelAnnouncementDecodeErrorZ_ok(o: number): number {
13824 if(!isWasmInitialized) {
13825 throw new Error("initializeWasm() must be awaited first!");
13827 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(o);
13828 return nativeResponseValue;
13830 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
13832 export function CResult_ChannelAnnouncementDecodeErrorZ_err(e: number): number {
13833 if(!isWasmInitialized) {
13834 throw new Error("initializeWasm() must be awaited first!");
13836 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_err(e);
13837 return nativeResponseValue;
13839 // bool CResult_ChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
13841 export function CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
13842 if(!isWasmInitialized) {
13843 throw new Error("initializeWasm() must be awaited first!");
13845 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o);
13846 return nativeResponseValue;
13848 // void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
13850 export function CResult_ChannelAnnouncementDecodeErrorZ_free(_res: number): void {
13851 if(!isWasmInitialized) {
13852 throw new Error("initializeWasm() must be awaited first!");
13854 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_free(_res);
13855 // debug statements here
13857 // uintptr_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
13859 export function CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
13860 if(!isWasmInitialized) {
13861 throw new Error("initializeWasm() must be awaited first!");
13863 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
13864 return nativeResponseValue;
13866 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
13868 export function CResult_ChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
13869 if(!isWasmInitialized) {
13870 throw new Error("initializeWasm() must be awaited first!");
13872 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(orig);
13873 return nativeResponseValue;
13875 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
13877 export function CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o: number): number {
13878 if(!isWasmInitialized) {
13879 throw new Error("initializeWasm() must be awaited first!");
13881 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o);
13882 return nativeResponseValue;
13884 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
13886 export function CResult_UnsignedChannelUpdateDecodeErrorZ_err(e: number): number {
13887 if(!isWasmInitialized) {
13888 throw new Error("initializeWasm() must be awaited first!");
13890 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(e);
13891 return nativeResponseValue;
13893 // bool CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR o);
13895 export function CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o: number): boolean {
13896 if(!isWasmInitialized) {
13897 throw new Error("initializeWasm() must be awaited first!");
13899 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o);
13900 return nativeResponseValue;
13902 // void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
13904 export function CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res: number): void {
13905 if(!isWasmInitialized) {
13906 throw new Error("initializeWasm() must be awaited first!");
13908 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res);
13909 // debug statements here
13911 // uintptr_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
13913 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg: number): number {
13914 if(!isWasmInitialized) {
13915 throw new Error("initializeWasm() must be awaited first!");
13917 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg);
13918 return nativeResponseValue;
13920 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
13922 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig: number): number {
13923 if(!isWasmInitialized) {
13924 throw new Error("initializeWasm() must be awaited first!");
13926 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig);
13927 return nativeResponseValue;
13929 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
13931 export function CResult_ChannelUpdateDecodeErrorZ_ok(o: number): number {
13932 if(!isWasmInitialized) {
13933 throw new Error("initializeWasm() must be awaited first!");
13935 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_ok(o);
13936 return nativeResponseValue;
13938 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
13940 export function CResult_ChannelUpdateDecodeErrorZ_err(e: number): number {
13941 if(!isWasmInitialized) {
13942 throw new Error("initializeWasm() must be awaited first!");
13944 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_err(e);
13945 return nativeResponseValue;
13947 // bool CResult_ChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR o);
13949 export function CResult_ChannelUpdateDecodeErrorZ_is_ok(o: number): boolean {
13950 if(!isWasmInitialized) {
13951 throw new Error("initializeWasm() must be awaited first!");
13953 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(o);
13954 return nativeResponseValue;
13956 // void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
13958 export function CResult_ChannelUpdateDecodeErrorZ_free(_res: number): void {
13959 if(!isWasmInitialized) {
13960 throw new Error("initializeWasm() must be awaited first!");
13962 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_free(_res);
13963 // debug statements here
13965 // uintptr_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
13967 export function CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg: number): number {
13968 if(!isWasmInitialized) {
13969 throw new Error("initializeWasm() must be awaited first!");
13971 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg);
13972 return nativeResponseValue;
13974 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
13976 export function CResult_ChannelUpdateDecodeErrorZ_clone(orig: number): number {
13977 if(!isWasmInitialized) {
13978 throw new Error("initializeWasm() must be awaited first!");
13980 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone(orig);
13981 return nativeResponseValue;
13983 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
13985 export function CResult_ErrorMessageDecodeErrorZ_ok(o: number): number {
13986 if(!isWasmInitialized) {
13987 throw new Error("initializeWasm() must be awaited first!");
13989 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_ok(o);
13990 return nativeResponseValue;
13992 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
13994 export function CResult_ErrorMessageDecodeErrorZ_err(e: number): number {
13995 if(!isWasmInitialized) {
13996 throw new Error("initializeWasm() must be awaited first!");
13998 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_err(e);
13999 return nativeResponseValue;
14001 // bool CResult_ErrorMessageDecodeErrorZ_is_ok(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR o);
14003 export function CResult_ErrorMessageDecodeErrorZ_is_ok(o: number): boolean {
14004 if(!isWasmInitialized) {
14005 throw new Error("initializeWasm() must be awaited first!");
14007 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_is_ok(o);
14008 return nativeResponseValue;
14010 // void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
14012 export function CResult_ErrorMessageDecodeErrorZ_free(_res: number): void {
14013 if(!isWasmInitialized) {
14014 throw new Error("initializeWasm() must be awaited first!");
14016 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_free(_res);
14017 // debug statements here
14019 // uintptr_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg);
14021 export function CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg: number): number {
14022 if(!isWasmInitialized) {
14023 throw new Error("initializeWasm() must be awaited first!");
14025 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg);
14026 return nativeResponseValue;
14028 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
14030 export function CResult_ErrorMessageDecodeErrorZ_clone(orig: number): number {
14031 if(!isWasmInitialized) {
14032 throw new Error("initializeWasm() must be awaited first!");
14034 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone(orig);
14035 return nativeResponseValue;
14037 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_ok(struct LDKWarningMessage o);
14039 export function CResult_WarningMessageDecodeErrorZ_ok(o: number): number {
14040 if(!isWasmInitialized) {
14041 throw new Error("initializeWasm() must be awaited first!");
14043 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_ok(o);
14044 return nativeResponseValue;
14046 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_err(struct LDKDecodeError e);
14048 export function CResult_WarningMessageDecodeErrorZ_err(e: number): number {
14049 if(!isWasmInitialized) {
14050 throw new Error("initializeWasm() must be awaited first!");
14052 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_err(e);
14053 return nativeResponseValue;
14055 // bool CResult_WarningMessageDecodeErrorZ_is_ok(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR o);
14057 export function CResult_WarningMessageDecodeErrorZ_is_ok(o: number): boolean {
14058 if(!isWasmInitialized) {
14059 throw new Error("initializeWasm() must be awaited first!");
14061 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_is_ok(o);
14062 return nativeResponseValue;
14064 // void CResult_WarningMessageDecodeErrorZ_free(struct LDKCResult_WarningMessageDecodeErrorZ _res);
14066 export function CResult_WarningMessageDecodeErrorZ_free(_res: number): void {
14067 if(!isWasmInitialized) {
14068 throw new Error("initializeWasm() must be awaited first!");
14070 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_free(_res);
14071 // debug statements here
14073 // uintptr_t CResult_WarningMessageDecodeErrorZ_clone_ptr(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR arg);
14075 export function CResult_WarningMessageDecodeErrorZ_clone_ptr(arg: number): number {
14076 if(!isWasmInitialized) {
14077 throw new Error("initializeWasm() must be awaited first!");
14079 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone_ptr(arg);
14080 return nativeResponseValue;
14082 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_clone(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR orig);
14084 export function CResult_WarningMessageDecodeErrorZ_clone(orig: number): number {
14085 if(!isWasmInitialized) {
14086 throw new Error("initializeWasm() must be awaited first!");
14088 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone(orig);
14089 return nativeResponseValue;
14091 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
14093 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o: number): number {
14094 if(!isWasmInitialized) {
14095 throw new Error("initializeWasm() must be awaited first!");
14097 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o);
14098 return nativeResponseValue;
14100 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
14102 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e: number): number {
14103 if(!isWasmInitialized) {
14104 throw new Error("initializeWasm() must be awaited first!");
14106 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e);
14107 return nativeResponseValue;
14109 // bool CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
14111 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
14112 if(!isWasmInitialized) {
14113 throw new Error("initializeWasm() must be awaited first!");
14115 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o);
14116 return nativeResponseValue;
14118 // void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
14120 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res: number): void {
14121 if(!isWasmInitialized) {
14122 throw new Error("initializeWasm() must be awaited first!");
14124 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res);
14125 // debug statements here
14127 // uintptr_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14129 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
14130 if(!isWasmInitialized) {
14131 throw new Error("initializeWasm() must be awaited first!");
14133 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg);
14134 return nativeResponseValue;
14136 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14138 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig: number): number {
14139 if(!isWasmInitialized) {
14140 throw new Error("initializeWasm() must be awaited first!");
14142 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig);
14143 return nativeResponseValue;
14145 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
14147 export function CResult_NodeAnnouncementDecodeErrorZ_ok(o: number): number {
14148 if(!isWasmInitialized) {
14149 throw new Error("initializeWasm() must be awaited first!");
14151 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_ok(o);
14152 return nativeResponseValue;
14154 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
14156 export function CResult_NodeAnnouncementDecodeErrorZ_err(e: number): number {
14157 if(!isWasmInitialized) {
14158 throw new Error("initializeWasm() must be awaited first!");
14160 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_err(e);
14161 return nativeResponseValue;
14163 // bool CResult_NodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
14165 export function CResult_NodeAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
14166 if(!isWasmInitialized) {
14167 throw new Error("initializeWasm() must be awaited first!");
14169 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(o);
14170 return nativeResponseValue;
14172 // void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
14174 export function CResult_NodeAnnouncementDecodeErrorZ_free(_res: number): void {
14175 if(!isWasmInitialized) {
14176 throw new Error("initializeWasm() must be awaited first!");
14178 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_free(_res);
14179 // debug statements here
14181 // uintptr_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14183 export function CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
14184 if(!isWasmInitialized) {
14185 throw new Error("initializeWasm() must be awaited first!");
14187 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg);
14188 return nativeResponseValue;
14190 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14192 export function CResult_NodeAnnouncementDecodeErrorZ_clone(orig: number): number {
14193 if(!isWasmInitialized) {
14194 throw new Error("initializeWasm() must be awaited first!");
14196 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone(orig);
14197 return nativeResponseValue;
14199 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
14201 export function CResult_QueryShortChannelIdsDecodeErrorZ_ok(o: number): number {
14202 if(!isWasmInitialized) {
14203 throw new Error("initializeWasm() must be awaited first!");
14205 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(o);
14206 return nativeResponseValue;
14208 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
14210 export function CResult_QueryShortChannelIdsDecodeErrorZ_err(e: number): number {
14211 if(!isWasmInitialized) {
14212 throw new Error("initializeWasm() must be awaited first!");
14214 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(e);
14215 return nativeResponseValue;
14217 // bool CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR o);
14219 export function CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o: number): boolean {
14220 if(!isWasmInitialized) {
14221 throw new Error("initializeWasm() must be awaited first!");
14223 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o);
14224 return nativeResponseValue;
14226 // void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
14228 export function CResult_QueryShortChannelIdsDecodeErrorZ_free(_res: number): void {
14229 if(!isWasmInitialized) {
14230 throw new Error("initializeWasm() must be awaited first!");
14232 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(_res);
14233 // debug statements here
14235 // uintptr_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg);
14237 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg: number): number {
14238 if(!isWasmInitialized) {
14239 throw new Error("initializeWasm() must be awaited first!");
14241 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg);
14242 return nativeResponseValue;
14244 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
14246 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig: number): number {
14247 if(!isWasmInitialized) {
14248 throw new Error("initializeWasm() must be awaited first!");
14250 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig);
14251 return nativeResponseValue;
14253 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
14255 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o: number): number {
14256 if(!isWasmInitialized) {
14257 throw new Error("initializeWasm() must be awaited first!");
14259 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o);
14260 return nativeResponseValue;
14262 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
14264 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e: number): number {
14265 if(!isWasmInitialized) {
14266 throw new Error("initializeWasm() must be awaited first!");
14268 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e);
14269 return nativeResponseValue;
14271 // bool CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR o);
14273 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o: number): boolean {
14274 if(!isWasmInitialized) {
14275 throw new Error("initializeWasm() must be awaited first!");
14277 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o);
14278 return nativeResponseValue;
14280 // void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
14282 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res: number): void {
14283 if(!isWasmInitialized) {
14284 throw new Error("initializeWasm() must be awaited first!");
14286 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res);
14287 // debug statements here
14289 // uintptr_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg);
14291 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg: number): number {
14292 if(!isWasmInitialized) {
14293 throw new Error("initializeWasm() must be awaited first!");
14295 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg);
14296 return nativeResponseValue;
14298 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
14300 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig: number): number {
14301 if(!isWasmInitialized) {
14302 throw new Error("initializeWasm() must be awaited first!");
14304 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig);
14305 return nativeResponseValue;
14307 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
14309 export function CResult_QueryChannelRangeDecodeErrorZ_ok(o: number): number {
14310 if(!isWasmInitialized) {
14311 throw new Error("initializeWasm() must be awaited first!");
14313 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_ok(o);
14314 return nativeResponseValue;
14316 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
14318 export function CResult_QueryChannelRangeDecodeErrorZ_err(e: number): number {
14319 if(!isWasmInitialized) {
14320 throw new Error("initializeWasm() must be awaited first!");
14322 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_err(e);
14323 return nativeResponseValue;
14325 // bool CResult_QueryChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR o);
14327 export function CResult_QueryChannelRangeDecodeErrorZ_is_ok(o: number): boolean {
14328 if(!isWasmInitialized) {
14329 throw new Error("initializeWasm() must be awaited first!");
14331 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(o);
14332 return nativeResponseValue;
14334 // void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
14336 export function CResult_QueryChannelRangeDecodeErrorZ_free(_res: number): void {
14337 if(!isWasmInitialized) {
14338 throw new Error("initializeWasm() must be awaited first!");
14340 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_free(_res);
14341 // debug statements here
14343 // uintptr_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg);
14345 export function CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg: number): number {
14346 if(!isWasmInitialized) {
14347 throw new Error("initializeWasm() must be awaited first!");
14349 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg);
14350 return nativeResponseValue;
14352 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
14354 export function CResult_QueryChannelRangeDecodeErrorZ_clone(orig: number): number {
14355 if(!isWasmInitialized) {
14356 throw new Error("initializeWasm() must be awaited first!");
14358 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone(orig);
14359 return nativeResponseValue;
14361 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
14363 export function CResult_ReplyChannelRangeDecodeErrorZ_ok(o: number): number {
14364 if(!isWasmInitialized) {
14365 throw new Error("initializeWasm() must be awaited first!");
14367 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(o);
14368 return nativeResponseValue;
14370 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
14372 export function CResult_ReplyChannelRangeDecodeErrorZ_err(e: number): number {
14373 if(!isWasmInitialized) {
14374 throw new Error("initializeWasm() must be awaited first!");
14376 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_err(e);
14377 return nativeResponseValue;
14379 // bool CResult_ReplyChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR o);
14381 export function CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o: number): boolean {
14382 if(!isWasmInitialized) {
14383 throw new Error("initializeWasm() must be awaited first!");
14385 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o);
14386 return nativeResponseValue;
14388 // void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
14390 export function CResult_ReplyChannelRangeDecodeErrorZ_free(_res: number): void {
14391 if(!isWasmInitialized) {
14392 throw new Error("initializeWasm() must be awaited first!");
14394 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_free(_res);
14395 // debug statements here
14397 // uintptr_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg);
14399 export function CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg: number): number {
14400 if(!isWasmInitialized) {
14401 throw new Error("initializeWasm() must be awaited first!");
14403 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg);
14404 return nativeResponseValue;
14406 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
14408 export function CResult_ReplyChannelRangeDecodeErrorZ_clone(orig: number): number {
14409 if(!isWasmInitialized) {
14410 throw new Error("initializeWasm() must be awaited first!");
14412 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(orig);
14413 return nativeResponseValue;
14415 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
14417 export function CResult_GossipTimestampFilterDecodeErrorZ_ok(o: number): number {
14418 if(!isWasmInitialized) {
14419 throw new Error("initializeWasm() must be awaited first!");
14421 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(o);
14422 return nativeResponseValue;
14424 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
14426 export function CResult_GossipTimestampFilterDecodeErrorZ_err(e: number): number {
14427 if(!isWasmInitialized) {
14428 throw new Error("initializeWasm() must be awaited first!");
14430 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_err(e);
14431 return nativeResponseValue;
14433 // bool CResult_GossipTimestampFilterDecodeErrorZ_is_ok(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR o);
14435 export function CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o: number): boolean {
14436 if(!isWasmInitialized) {
14437 throw new Error("initializeWasm() must be awaited first!");
14439 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o);
14440 return nativeResponseValue;
14442 // void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
14444 export function CResult_GossipTimestampFilterDecodeErrorZ_free(_res: number): void {
14445 if(!isWasmInitialized) {
14446 throw new Error("initializeWasm() must be awaited first!");
14448 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_free(_res);
14449 // debug statements here
14451 // uintptr_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg);
14453 export function CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg: number): number {
14454 if(!isWasmInitialized) {
14455 throw new Error("initializeWasm() must be awaited first!");
14457 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg);
14458 return nativeResponseValue;
14460 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
14462 export function CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: number): number {
14463 if(!isWasmInitialized) {
14464 throw new Error("initializeWasm() must be awaited first!");
14466 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(orig);
14467 return nativeResponseValue;
14469 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_ok(struct LDKInvoice o);
14471 export function CResult_InvoiceSignOrCreationErrorZ_ok(o: number): number {
14472 if(!isWasmInitialized) {
14473 throw new Error("initializeWasm() must be awaited first!");
14475 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_ok(o);
14476 return nativeResponseValue;
14478 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_err(struct LDKSignOrCreationError e);
14480 export function CResult_InvoiceSignOrCreationErrorZ_err(e: number): number {
14481 if(!isWasmInitialized) {
14482 throw new Error("initializeWasm() must be awaited first!");
14484 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_err(e);
14485 return nativeResponseValue;
14487 // bool CResult_InvoiceSignOrCreationErrorZ_is_ok(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR o);
14489 export function CResult_InvoiceSignOrCreationErrorZ_is_ok(o: number): boolean {
14490 if(!isWasmInitialized) {
14491 throw new Error("initializeWasm() must be awaited first!");
14493 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_is_ok(o);
14494 return nativeResponseValue;
14496 // void CResult_InvoiceSignOrCreationErrorZ_free(struct LDKCResult_InvoiceSignOrCreationErrorZ _res);
14498 export function CResult_InvoiceSignOrCreationErrorZ_free(_res: number): void {
14499 if(!isWasmInitialized) {
14500 throw new Error("initializeWasm() must be awaited first!");
14502 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_free(_res);
14503 // debug statements here
14505 // uintptr_t CResult_InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR arg);
14507 export function CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg: number): number {
14508 if(!isWasmInitialized) {
14509 throw new Error("initializeWasm() must be awaited first!");
14511 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg);
14512 return nativeResponseValue;
14514 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_clone(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR orig);
14516 export function CResult_InvoiceSignOrCreationErrorZ_clone(orig: number): number {
14517 if(!isWasmInitialized) {
14518 throw new Error("initializeWasm() must be awaited first!");
14520 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone(orig);
14521 return nativeResponseValue;
14523 // struct LDKCOption_FilterZ COption_FilterZ_some(struct LDKFilter o);
14525 export function COption_FilterZ_some(o: number): number {
14526 if(!isWasmInitialized) {
14527 throw new Error("initializeWasm() must be awaited first!");
14529 const nativeResponseValue = wasm.TS_COption_FilterZ_some(o);
14530 return nativeResponseValue;
14532 // struct LDKCOption_FilterZ COption_FilterZ_none(void);
14534 export function COption_FilterZ_none(): number {
14535 if(!isWasmInitialized) {
14536 throw new Error("initializeWasm() must be awaited first!");
14538 const nativeResponseValue = wasm.TS_COption_FilterZ_none();
14539 return nativeResponseValue;
14541 // void COption_FilterZ_free(struct LDKCOption_FilterZ _res);
14543 export function COption_FilterZ_free(_res: number): void {
14544 if(!isWasmInitialized) {
14545 throw new Error("initializeWasm() must be awaited first!");
14547 const nativeResponseValue = wasm.TS_COption_FilterZ_free(_res);
14548 // debug statements here
14550 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_ok(struct LDKLockedChannelMonitor o);
14552 export function CResult_LockedChannelMonitorNoneZ_ok(o: number): number {
14553 if(!isWasmInitialized) {
14554 throw new Error("initializeWasm() must be awaited first!");
14556 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_ok(o);
14557 return nativeResponseValue;
14559 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_err(void);
14561 export function CResult_LockedChannelMonitorNoneZ_err(): number {
14562 if(!isWasmInitialized) {
14563 throw new Error("initializeWasm() must be awaited first!");
14565 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_err();
14566 return nativeResponseValue;
14568 // bool CResult_LockedChannelMonitorNoneZ_is_ok(const struct LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR o);
14570 export function CResult_LockedChannelMonitorNoneZ_is_ok(o: number): boolean {
14571 if(!isWasmInitialized) {
14572 throw new Error("initializeWasm() must be awaited first!");
14574 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_is_ok(o);
14575 return nativeResponseValue;
14577 // void CResult_LockedChannelMonitorNoneZ_free(struct LDKCResult_LockedChannelMonitorNoneZ _res);
14579 export function CResult_LockedChannelMonitorNoneZ_free(_res: number): void {
14580 if(!isWasmInitialized) {
14581 throw new Error("initializeWasm() must be awaited first!");
14583 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_free(_res);
14584 // debug statements here
14586 // void CVec_OutPointZ_free(struct LDKCVec_OutPointZ _res);
14588 export function CVec_OutPointZ_free(_res: number): void {
14589 if(!isWasmInitialized) {
14590 throw new Error("initializeWasm() must be awaited first!");
14592 const nativeResponseValue = wasm.TS_CVec_OutPointZ_free(_res);
14593 // debug statements here
14595 // void PaymentPurpose_free(struct LDKPaymentPurpose this_ptr);
14597 export function PaymentPurpose_free(this_ptr: number): void {
14598 if(!isWasmInitialized) {
14599 throw new Error("initializeWasm() must be awaited first!");
14601 const nativeResponseValue = wasm.TS_PaymentPurpose_free(this_ptr);
14602 // debug statements here
14604 // uintptr_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg);
14606 export function PaymentPurpose_clone_ptr(arg: number): number {
14607 if(!isWasmInitialized) {
14608 throw new Error("initializeWasm() must be awaited first!");
14610 const nativeResponseValue = wasm.TS_PaymentPurpose_clone_ptr(arg);
14611 return nativeResponseValue;
14613 // struct LDKPaymentPurpose PaymentPurpose_clone(const struct LDKPaymentPurpose *NONNULL_PTR orig);
14615 export function PaymentPurpose_clone(orig: number): number {
14616 if(!isWasmInitialized) {
14617 throw new Error("initializeWasm() must be awaited first!");
14619 const nativeResponseValue = wasm.TS_PaymentPurpose_clone(orig);
14620 return nativeResponseValue;
14622 // struct LDKPaymentPurpose PaymentPurpose_invoice_payment(struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_secret);
14624 export function PaymentPurpose_invoice_payment(payment_preimage: number, payment_secret: number): number {
14625 if(!isWasmInitialized) {
14626 throw new Error("initializeWasm() must be awaited first!");
14628 const nativeResponseValue = wasm.TS_PaymentPurpose_invoice_payment(payment_preimage, payment_secret);
14629 return nativeResponseValue;
14631 // struct LDKPaymentPurpose PaymentPurpose_spontaneous_payment(struct LDKThirtyTwoBytes a);
14633 export function PaymentPurpose_spontaneous_payment(a: number): number {
14634 if(!isWasmInitialized) {
14635 throw new Error("initializeWasm() must be awaited first!");
14637 const nativeResponseValue = wasm.TS_PaymentPurpose_spontaneous_payment(a);
14638 return nativeResponseValue;
14640 // void ClosureReason_free(struct LDKClosureReason this_ptr);
14642 export function ClosureReason_free(this_ptr: number): void {
14643 if(!isWasmInitialized) {
14644 throw new Error("initializeWasm() must be awaited first!");
14646 const nativeResponseValue = wasm.TS_ClosureReason_free(this_ptr);
14647 // debug statements here
14649 // uintptr_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg);
14651 export function ClosureReason_clone_ptr(arg: number): number {
14652 if(!isWasmInitialized) {
14653 throw new Error("initializeWasm() must be awaited first!");
14655 const nativeResponseValue = wasm.TS_ClosureReason_clone_ptr(arg);
14656 return nativeResponseValue;
14658 // struct LDKClosureReason ClosureReason_clone(const struct LDKClosureReason *NONNULL_PTR orig);
14660 export function ClosureReason_clone(orig: number): number {
14661 if(!isWasmInitialized) {
14662 throw new Error("initializeWasm() must be awaited first!");
14664 const nativeResponseValue = wasm.TS_ClosureReason_clone(orig);
14665 return nativeResponseValue;
14667 // struct LDKClosureReason ClosureReason_counterparty_force_closed(struct LDKStr peer_msg);
14669 export function ClosureReason_counterparty_force_closed(peer_msg: number): number {
14670 if(!isWasmInitialized) {
14671 throw new Error("initializeWasm() must be awaited first!");
14673 const nativeResponseValue = wasm.TS_ClosureReason_counterparty_force_closed(peer_msg);
14674 return nativeResponseValue;
14676 // struct LDKClosureReason ClosureReason_holder_force_closed(void);
14678 export function ClosureReason_holder_force_closed(): number {
14679 if(!isWasmInitialized) {
14680 throw new Error("initializeWasm() must be awaited first!");
14682 const nativeResponseValue = wasm.TS_ClosureReason_holder_force_closed();
14683 return nativeResponseValue;
14685 // struct LDKClosureReason ClosureReason_cooperative_closure(void);
14687 export function ClosureReason_cooperative_closure(): number {
14688 if(!isWasmInitialized) {
14689 throw new Error("initializeWasm() must be awaited first!");
14691 const nativeResponseValue = wasm.TS_ClosureReason_cooperative_closure();
14692 return nativeResponseValue;
14694 // struct LDKClosureReason ClosureReason_commitment_tx_confirmed(void);
14696 export function ClosureReason_commitment_tx_confirmed(): number {
14697 if(!isWasmInitialized) {
14698 throw new Error("initializeWasm() must be awaited first!");
14700 const nativeResponseValue = wasm.TS_ClosureReason_commitment_tx_confirmed();
14701 return nativeResponseValue;
14703 // struct LDKClosureReason ClosureReason_funding_timed_out(void);
14705 export function ClosureReason_funding_timed_out(): number {
14706 if(!isWasmInitialized) {
14707 throw new Error("initializeWasm() must be awaited first!");
14709 const nativeResponseValue = wasm.TS_ClosureReason_funding_timed_out();
14710 return nativeResponseValue;
14712 // struct LDKClosureReason ClosureReason_processing_error(struct LDKStr err);
14714 export function ClosureReason_processing_error(err: number): number {
14715 if(!isWasmInitialized) {
14716 throw new Error("initializeWasm() must be awaited first!");
14718 const nativeResponseValue = wasm.TS_ClosureReason_processing_error(err);
14719 return nativeResponseValue;
14721 // struct LDKClosureReason ClosureReason_disconnected_peer(void);
14723 export function ClosureReason_disconnected_peer(): number {
14724 if(!isWasmInitialized) {
14725 throw new Error("initializeWasm() must be awaited first!");
14727 const nativeResponseValue = wasm.TS_ClosureReason_disconnected_peer();
14728 return nativeResponseValue;
14730 // struct LDKClosureReason ClosureReason_outdated_channel_manager(void);
14732 export function ClosureReason_outdated_channel_manager(): number {
14733 if(!isWasmInitialized) {
14734 throw new Error("initializeWasm() must be awaited first!");
14736 const nativeResponseValue = wasm.TS_ClosureReason_outdated_channel_manager();
14737 return nativeResponseValue;
14739 // struct LDKCVec_u8Z ClosureReason_write(const struct LDKClosureReason *NONNULL_PTR obj);
14741 export function ClosureReason_write(obj: number): number {
14742 if(!isWasmInitialized) {
14743 throw new Error("initializeWasm() must be awaited first!");
14745 const nativeResponseValue = wasm.TS_ClosureReason_write(obj);
14746 return nativeResponseValue;
14748 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ ClosureReason_read(struct LDKu8slice ser);
14750 export function ClosureReason_read(ser: number): number {
14751 if(!isWasmInitialized) {
14752 throw new Error("initializeWasm() must be awaited first!");
14754 const nativeResponseValue = wasm.TS_ClosureReason_read(ser);
14755 return nativeResponseValue;
14757 // void Event_free(struct LDKEvent this_ptr);
14759 export function Event_free(this_ptr: number): void {
14760 if(!isWasmInitialized) {
14761 throw new Error("initializeWasm() must be awaited first!");
14763 const nativeResponseValue = wasm.TS_Event_free(this_ptr);
14764 // debug statements here
14766 // uintptr_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg);
14768 export function Event_clone_ptr(arg: number): number {
14769 if(!isWasmInitialized) {
14770 throw new Error("initializeWasm() must be awaited first!");
14772 const nativeResponseValue = wasm.TS_Event_clone_ptr(arg);
14773 return nativeResponseValue;
14775 // struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
14777 export function Event_clone(orig: number): number {
14778 if(!isWasmInitialized) {
14779 throw new Error("initializeWasm() must be awaited first!");
14781 const nativeResponseValue = wasm.TS_Event_clone(orig);
14782 return nativeResponseValue;
14784 // 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);
14786 export function Event_funding_generation_ready(temporary_channel_id: number, channel_value_satoshis: bigint, output_script: number, user_channel_id: bigint): number {
14787 if(!isWasmInitialized) {
14788 throw new Error("initializeWasm() must be awaited first!");
14790 const nativeResponseValue = wasm.TS_Event_funding_generation_ready(temporary_channel_id, channel_value_satoshis, output_script, user_channel_id);
14791 return nativeResponseValue;
14793 // struct LDKEvent Event_payment_received(struct LDKThirtyTwoBytes payment_hash, uint64_t amt, struct LDKPaymentPurpose purpose);
14795 export function Event_payment_received(payment_hash: number, amt: bigint, purpose: number): number {
14796 if(!isWasmInitialized) {
14797 throw new Error("initializeWasm() must be awaited first!");
14799 const nativeResponseValue = wasm.TS_Event_payment_received(payment_hash, amt, purpose);
14800 return nativeResponseValue;
14802 // struct LDKEvent Event_payment_sent(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z fee_paid_msat);
14804 export function Event_payment_sent(payment_id: number, payment_preimage: number, payment_hash: number, fee_paid_msat: number): number {
14805 if(!isWasmInitialized) {
14806 throw new Error("initializeWasm() must be awaited first!");
14808 const nativeResponseValue = wasm.TS_Event_payment_sent(payment_id, payment_preimage, payment_hash, fee_paid_msat);
14809 return nativeResponseValue;
14811 // 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);
14813 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 {
14814 if(!isWasmInitialized) {
14815 throw new Error("initializeWasm() must be awaited first!");
14817 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);
14818 return nativeResponseValue;
14820 // struct LDKEvent Event_payment_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash);
14822 export function Event_payment_failed(payment_id: number, payment_hash: number): number {
14823 if(!isWasmInitialized) {
14824 throw new Error("initializeWasm() must be awaited first!");
14826 const nativeResponseValue = wasm.TS_Event_payment_failed(payment_id, payment_hash);
14827 return nativeResponseValue;
14829 // struct LDKEvent Event_pending_htlcs_forwardable(uint64_t time_forwardable);
14831 export function Event_pending_htlcs_forwardable(time_forwardable: bigint): number {
14832 if(!isWasmInitialized) {
14833 throw new Error("initializeWasm() must be awaited first!");
14835 const nativeResponseValue = wasm.TS_Event_pending_htlcs_forwardable(time_forwardable);
14836 return nativeResponseValue;
14838 // struct LDKEvent Event_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ outputs);
14840 export function Event_spendable_outputs(outputs: number): number {
14841 if(!isWasmInitialized) {
14842 throw new Error("initializeWasm() must be awaited first!");
14844 const nativeResponseValue = wasm.TS_Event_spendable_outputs(outputs);
14845 return nativeResponseValue;
14847 // struct LDKEvent Event_payment_forwarded(struct LDKCOption_u64Z fee_earned_msat, bool claim_from_onchain_tx);
14849 export function Event_payment_forwarded(fee_earned_msat: number, claim_from_onchain_tx: boolean): number {
14850 if(!isWasmInitialized) {
14851 throw new Error("initializeWasm() must be awaited first!");
14853 const nativeResponseValue = wasm.TS_Event_payment_forwarded(fee_earned_msat, claim_from_onchain_tx);
14854 return nativeResponseValue;
14856 // struct LDKEvent Event_channel_closed(struct LDKThirtyTwoBytes channel_id, uint64_t user_channel_id, struct LDKClosureReason reason);
14858 export function Event_channel_closed(channel_id: number, user_channel_id: bigint, reason: number): number {
14859 if(!isWasmInitialized) {
14860 throw new Error("initializeWasm() must be awaited first!");
14862 const nativeResponseValue = wasm.TS_Event_channel_closed(channel_id, user_channel_id, reason);
14863 return nativeResponseValue;
14865 // struct LDKEvent Event_discard_funding(struct LDKThirtyTwoBytes channel_id, struct LDKTransaction transaction);
14867 export function Event_discard_funding(channel_id: number, transaction: number): number {
14868 if(!isWasmInitialized) {
14869 throw new Error("initializeWasm() must be awaited first!");
14871 const nativeResponseValue = wasm.TS_Event_discard_funding(channel_id, transaction);
14872 return nativeResponseValue;
14874 // struct LDKEvent Event_payment_path_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path);
14876 export function Event_payment_path_successful(payment_id: number, payment_hash: number, path: number): number {
14877 if(!isWasmInitialized) {
14878 throw new Error("initializeWasm() must be awaited first!");
14880 const nativeResponseValue = wasm.TS_Event_payment_path_successful(payment_id, payment_hash, path);
14881 return nativeResponseValue;
14883 // struct LDKEvent Event_open_channel_request(struct LDKThirtyTwoBytes temporary_channel_id, struct LDKPublicKey counterparty_node_id, uint64_t funding_satoshis, uint64_t push_msat);
14885 export function Event_open_channel_request(temporary_channel_id: number, counterparty_node_id: number, funding_satoshis: bigint, push_msat: bigint): number {
14886 if(!isWasmInitialized) {
14887 throw new Error("initializeWasm() must be awaited first!");
14889 const nativeResponseValue = wasm.TS_Event_open_channel_request(temporary_channel_id, counterparty_node_id, funding_satoshis, push_msat);
14890 return nativeResponseValue;
14892 // struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
14894 export function Event_write(obj: number): number {
14895 if(!isWasmInitialized) {
14896 throw new Error("initializeWasm() must be awaited first!");
14898 const nativeResponseValue = wasm.TS_Event_write(obj);
14899 return nativeResponseValue;
14901 // struct LDKCResult_COption_EventZDecodeErrorZ Event_read(struct LDKu8slice ser);
14903 export function Event_read(ser: number): number {
14904 if(!isWasmInitialized) {
14905 throw new Error("initializeWasm() must be awaited first!");
14907 const nativeResponseValue = wasm.TS_Event_read(ser);
14908 return nativeResponseValue;
14910 // void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
14912 export function MessageSendEvent_free(this_ptr: number): void {
14913 if(!isWasmInitialized) {
14914 throw new Error("initializeWasm() must be awaited first!");
14916 const nativeResponseValue = wasm.TS_MessageSendEvent_free(this_ptr);
14917 // debug statements here
14919 // uintptr_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg);
14921 export function MessageSendEvent_clone_ptr(arg: number): number {
14922 if(!isWasmInitialized) {
14923 throw new Error("initializeWasm() must be awaited first!");
14925 const nativeResponseValue = wasm.TS_MessageSendEvent_clone_ptr(arg);
14926 return nativeResponseValue;
14928 // struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
14930 export function MessageSendEvent_clone(orig: number): number {
14931 if(!isWasmInitialized) {
14932 throw new Error("initializeWasm() must be awaited first!");
14934 const nativeResponseValue = wasm.TS_MessageSendEvent_clone(orig);
14935 return nativeResponseValue;
14937 // struct LDKMessageSendEvent MessageSendEvent_send_accept_channel(struct LDKPublicKey node_id, struct LDKAcceptChannel msg);
14939 export function MessageSendEvent_send_accept_channel(node_id: number, msg: number): number {
14940 if(!isWasmInitialized) {
14941 throw new Error("initializeWasm() must be awaited first!");
14943 const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel(node_id, msg);
14944 return nativeResponseValue;
14946 // struct LDKMessageSendEvent MessageSendEvent_send_open_channel(struct LDKPublicKey node_id, struct LDKOpenChannel msg);
14948 export function MessageSendEvent_send_open_channel(node_id: number, msg: number): number {
14949 if(!isWasmInitialized) {
14950 throw new Error("initializeWasm() must be awaited first!");
14952 const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel(node_id, msg);
14953 return nativeResponseValue;
14955 // struct LDKMessageSendEvent MessageSendEvent_send_funding_created(struct LDKPublicKey node_id, struct LDKFundingCreated msg);
14957 export function MessageSendEvent_send_funding_created(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_funding_created(node_id, msg);
14962 return nativeResponseValue;
14964 // struct LDKMessageSendEvent MessageSendEvent_send_funding_signed(struct LDKPublicKey node_id, struct LDKFundingSigned msg);
14966 export function MessageSendEvent_send_funding_signed(node_id: number, msg: number): number {
14967 if(!isWasmInitialized) {
14968 throw new Error("initializeWasm() must be awaited first!");
14970 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_signed(node_id, msg);
14971 return nativeResponseValue;
14973 // struct LDKMessageSendEvent MessageSendEvent_send_funding_locked(struct LDKPublicKey node_id, struct LDKFundingLocked msg);
14975 export function MessageSendEvent_send_funding_locked(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_funding_locked(node_id, msg);
14980 return nativeResponseValue;
14982 // struct LDKMessageSendEvent MessageSendEvent_send_announcement_signatures(struct LDKPublicKey node_id, struct LDKAnnouncementSignatures msg);
14984 export function MessageSendEvent_send_announcement_signatures(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_announcement_signatures(node_id, msg);
14989 return nativeResponseValue;
14991 // struct LDKMessageSendEvent MessageSendEvent_update_htlcs(struct LDKPublicKey node_id, struct LDKCommitmentUpdate updates);
14993 export function MessageSendEvent_update_htlcs(node_id: number, updates: number): number {
14994 if(!isWasmInitialized) {
14995 throw new Error("initializeWasm() must be awaited first!");
14997 const nativeResponseValue = wasm.TS_MessageSendEvent_update_htlcs(node_id, updates);
14998 return nativeResponseValue;
15000 // struct LDKMessageSendEvent MessageSendEvent_send_revoke_and_ack(struct LDKPublicKey node_id, struct LDKRevokeAndACK msg);
15002 export function MessageSendEvent_send_revoke_and_ack(node_id: number, msg: number): number {
15003 if(!isWasmInitialized) {
15004 throw new Error("initializeWasm() must be awaited first!");
15006 const nativeResponseValue = wasm.TS_MessageSendEvent_send_revoke_and_ack(node_id, msg);
15007 return nativeResponseValue;
15009 // struct LDKMessageSendEvent MessageSendEvent_send_closing_signed(struct LDKPublicKey node_id, struct LDKClosingSigned msg);
15011 export function MessageSendEvent_send_closing_signed(node_id: number, msg: number): number {
15012 if(!isWasmInitialized) {
15013 throw new Error("initializeWasm() must be awaited first!");
15015 const nativeResponseValue = wasm.TS_MessageSendEvent_send_closing_signed(node_id, msg);
15016 return nativeResponseValue;
15018 // struct LDKMessageSendEvent MessageSendEvent_send_shutdown(struct LDKPublicKey node_id, struct LDKShutdown msg);
15020 export function MessageSendEvent_send_shutdown(node_id: number, msg: number): number {
15021 if(!isWasmInitialized) {
15022 throw new Error("initializeWasm() must be awaited first!");
15024 const nativeResponseValue = wasm.TS_MessageSendEvent_send_shutdown(node_id, msg);
15025 return nativeResponseValue;
15027 // struct LDKMessageSendEvent MessageSendEvent_send_channel_reestablish(struct LDKPublicKey node_id, struct LDKChannelReestablish msg);
15029 export function MessageSendEvent_send_channel_reestablish(node_id: number, msg: number): number {
15030 if(!isWasmInitialized) {
15031 throw new Error("initializeWasm() must be awaited first!");
15033 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_reestablish(node_id, msg);
15034 return nativeResponseValue;
15036 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_announcement(struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
15038 export function MessageSendEvent_broadcast_channel_announcement(msg: number, update_msg: number): number {
15039 if(!isWasmInitialized) {
15040 throw new Error("initializeWasm() must be awaited first!");
15042 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_announcement(msg, update_msg);
15043 return nativeResponseValue;
15045 // struct LDKMessageSendEvent MessageSendEvent_broadcast_node_announcement(struct LDKNodeAnnouncement msg);
15047 export function MessageSendEvent_broadcast_node_announcement(msg: number): number {
15048 if(!isWasmInitialized) {
15049 throw new Error("initializeWasm() must be awaited first!");
15051 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_node_announcement(msg);
15052 return nativeResponseValue;
15054 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_update(struct LDKChannelUpdate msg);
15056 export function MessageSendEvent_broadcast_channel_update(msg: number): number {
15057 if(!isWasmInitialized) {
15058 throw new Error("initializeWasm() must be awaited first!");
15060 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_update(msg);
15061 return nativeResponseValue;
15063 // struct LDKMessageSendEvent MessageSendEvent_send_channel_update(struct LDKPublicKey node_id, struct LDKChannelUpdate msg);
15065 export function MessageSendEvent_send_channel_update(node_id: number, msg: number): number {
15066 if(!isWasmInitialized) {
15067 throw new Error("initializeWasm() must be awaited first!");
15069 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_update(node_id, msg);
15070 return nativeResponseValue;
15072 // struct LDKMessageSendEvent MessageSendEvent_handle_error(struct LDKPublicKey node_id, struct LDKErrorAction action);
15074 export function MessageSendEvent_handle_error(node_id: number, action: number): number {
15075 if(!isWasmInitialized) {
15076 throw new Error("initializeWasm() must be awaited first!");
15078 const nativeResponseValue = wasm.TS_MessageSendEvent_handle_error(node_id, action);
15079 return nativeResponseValue;
15081 // struct LDKMessageSendEvent MessageSendEvent_send_channel_range_query(struct LDKPublicKey node_id, struct LDKQueryChannelRange msg);
15083 export function MessageSendEvent_send_channel_range_query(node_id: number, msg: number): number {
15084 if(!isWasmInitialized) {
15085 throw new Error("initializeWasm() must be awaited first!");
15087 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_range_query(node_id, msg);
15088 return nativeResponseValue;
15090 // struct LDKMessageSendEvent MessageSendEvent_send_short_ids_query(struct LDKPublicKey node_id, struct LDKQueryShortChannelIds msg);
15092 export function MessageSendEvent_send_short_ids_query(node_id: number, msg: number): number {
15093 if(!isWasmInitialized) {
15094 throw new Error("initializeWasm() must be awaited first!");
15096 const nativeResponseValue = wasm.TS_MessageSendEvent_send_short_ids_query(node_id, msg);
15097 return nativeResponseValue;
15099 // struct LDKMessageSendEvent MessageSendEvent_send_reply_channel_range(struct LDKPublicKey node_id, struct LDKReplyChannelRange msg);
15101 export function MessageSendEvent_send_reply_channel_range(node_id: number, msg: number): number {
15102 if(!isWasmInitialized) {
15103 throw new Error("initializeWasm() must be awaited first!");
15105 const nativeResponseValue = wasm.TS_MessageSendEvent_send_reply_channel_range(node_id, msg);
15106 return nativeResponseValue;
15108 // void MessageSendEventsProvider_free(struct LDKMessageSendEventsProvider this_ptr);
15110 export function MessageSendEventsProvider_free(this_ptr: number): void {
15111 if(!isWasmInitialized) {
15112 throw new Error("initializeWasm() must be awaited first!");
15114 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_free(this_ptr);
15115 // debug statements here
15117 // void EventsProvider_free(struct LDKEventsProvider this_ptr);
15119 export function EventsProvider_free(this_ptr: number): void {
15120 if(!isWasmInitialized) {
15121 throw new Error("initializeWasm() must be awaited first!");
15123 const nativeResponseValue = wasm.TS_EventsProvider_free(this_ptr);
15124 // debug statements here
15126 // void EventHandler_free(struct LDKEventHandler this_ptr);
15128 export function EventHandler_free(this_ptr: number): void {
15129 if(!isWasmInitialized) {
15130 throw new Error("initializeWasm() must be awaited first!");
15132 const nativeResponseValue = wasm.TS_EventHandler_free(this_ptr);
15133 // debug statements here
15135 // void APIError_free(struct LDKAPIError this_ptr);
15137 export function APIError_free(this_ptr: number): void {
15138 if(!isWasmInitialized) {
15139 throw new Error("initializeWasm() must be awaited first!");
15141 const nativeResponseValue = wasm.TS_APIError_free(this_ptr);
15142 // debug statements here
15144 // uintptr_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg);
15146 export function APIError_clone_ptr(arg: number): number {
15147 if(!isWasmInitialized) {
15148 throw new Error("initializeWasm() must be awaited first!");
15150 const nativeResponseValue = wasm.TS_APIError_clone_ptr(arg);
15151 return nativeResponseValue;
15153 // struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
15155 export function APIError_clone(orig: number): number {
15156 if(!isWasmInitialized) {
15157 throw new Error("initializeWasm() must be awaited first!");
15159 const nativeResponseValue = wasm.TS_APIError_clone(orig);
15160 return nativeResponseValue;
15162 // struct LDKAPIError APIError_apimisuse_error(struct LDKStr err);
15164 export function APIError_apimisuse_error(err: number): number {
15165 if(!isWasmInitialized) {
15166 throw new Error("initializeWasm() must be awaited first!");
15168 const nativeResponseValue = wasm.TS_APIError_apimisuse_error(err);
15169 return nativeResponseValue;
15171 // struct LDKAPIError APIError_fee_rate_too_high(struct LDKStr err, uint32_t feerate);
15173 export function APIError_fee_rate_too_high(err: number, feerate: number): number {
15174 if(!isWasmInitialized) {
15175 throw new Error("initializeWasm() must be awaited first!");
15177 const nativeResponseValue = wasm.TS_APIError_fee_rate_too_high(err, feerate);
15178 return nativeResponseValue;
15180 // struct LDKAPIError APIError_route_error(struct LDKStr err);
15182 export function APIError_route_error(err: number): number {
15183 if(!isWasmInitialized) {
15184 throw new Error("initializeWasm() must be awaited first!");
15186 const nativeResponseValue = wasm.TS_APIError_route_error(err);
15187 return nativeResponseValue;
15189 // struct LDKAPIError APIError_channel_unavailable(struct LDKStr err);
15191 export function APIError_channel_unavailable(err: number): number {
15192 if(!isWasmInitialized) {
15193 throw new Error("initializeWasm() must be awaited first!");
15195 const nativeResponseValue = wasm.TS_APIError_channel_unavailable(err);
15196 return nativeResponseValue;
15198 // struct LDKAPIError APIError_monitor_update_failed(void);
15200 export function APIError_monitor_update_failed(): number {
15201 if(!isWasmInitialized) {
15202 throw new Error("initializeWasm() must be awaited first!");
15204 const nativeResponseValue = wasm.TS_APIError_monitor_update_failed();
15205 return nativeResponseValue;
15207 // struct LDKAPIError APIError_incompatible_shutdown_script(struct LDKShutdownScript script);
15209 export function APIError_incompatible_shutdown_script(script: number): number {
15210 if(!isWasmInitialized) {
15211 throw new Error("initializeWasm() must be awaited first!");
15213 const nativeResponseValue = wasm.TS_APIError_incompatible_shutdown_script(script);
15214 return nativeResponseValue;
15216 // struct LDKCResult_StringErrorZ sign(struct LDKu8slice msg, const uint8_t (*sk)[32]);
15218 export function sign(msg: number, sk: number): number {
15219 if(!isWasmInitialized) {
15220 throw new Error("initializeWasm() must be awaited first!");
15222 const nativeResponseValue = wasm.TS_sign(msg, sk);
15223 return nativeResponseValue;
15225 // struct LDKCResult_PublicKeyErrorZ recover_pk(struct LDKu8slice msg, struct LDKStr sig);
15227 export function recover_pk(msg: number, sig: number): number {
15228 if(!isWasmInitialized) {
15229 throw new Error("initializeWasm() must be awaited first!");
15231 const nativeResponseValue = wasm.TS_recover_pk(msg, sig);
15232 return nativeResponseValue;
15234 // bool verify(struct LDKu8slice msg, struct LDKStr sig, struct LDKPublicKey pk);
15236 export function verify(msg: number, sig: number, pk: number): boolean {
15237 if(!isWasmInitialized) {
15238 throw new Error("initializeWasm() must be awaited first!");
15240 const nativeResponseValue = wasm.TS_verify(msg, sig, pk);
15241 return nativeResponseValue;
15243 // struct LDKCVec_u8Z construct_invoice_preimage(struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z data_without_signature);
15245 export function construct_invoice_preimage(hrp_bytes: number, data_without_signature: number): number {
15246 if(!isWasmInitialized) {
15247 throw new Error("initializeWasm() must be awaited first!");
15249 const nativeResponseValue = wasm.TS_construct_invoice_preimage(hrp_bytes, data_without_signature);
15250 return nativeResponseValue;
15252 // enum LDKLevel Level_clone(const enum LDKLevel *NONNULL_PTR orig);
15254 export function Level_clone(orig: number): Level {
15255 if(!isWasmInitialized) {
15256 throw new Error("initializeWasm() must be awaited first!");
15258 const nativeResponseValue = wasm.TS_Level_clone(orig);
15259 return nativeResponseValue;
15261 // enum LDKLevel Level_gossip(void);
15263 export function Level_gossip(): Level {
15264 if(!isWasmInitialized) {
15265 throw new Error("initializeWasm() must be awaited first!");
15267 const nativeResponseValue = wasm.TS_Level_gossip();
15268 return nativeResponseValue;
15270 // enum LDKLevel Level_trace(void);
15272 export function Level_trace(): Level {
15273 if(!isWasmInitialized) {
15274 throw new Error("initializeWasm() must be awaited first!");
15276 const nativeResponseValue = wasm.TS_Level_trace();
15277 return nativeResponseValue;
15279 // enum LDKLevel Level_debug(void);
15281 export function Level_debug(): Level {
15282 if(!isWasmInitialized) {
15283 throw new Error("initializeWasm() must be awaited first!");
15285 const nativeResponseValue = wasm.TS_Level_debug();
15286 return nativeResponseValue;
15288 // enum LDKLevel Level_info(void);
15290 export function Level_info(): Level {
15291 if(!isWasmInitialized) {
15292 throw new Error("initializeWasm() must be awaited first!");
15294 const nativeResponseValue = wasm.TS_Level_info();
15295 return nativeResponseValue;
15297 // enum LDKLevel Level_warn(void);
15299 export function Level_warn(): Level {
15300 if(!isWasmInitialized) {
15301 throw new Error("initializeWasm() must be awaited first!");
15303 const nativeResponseValue = wasm.TS_Level_warn();
15304 return nativeResponseValue;
15306 // enum LDKLevel Level_error(void);
15308 export function Level_error(): Level {
15309 if(!isWasmInitialized) {
15310 throw new Error("initializeWasm() must be awaited first!");
15312 const nativeResponseValue = wasm.TS_Level_error();
15313 return nativeResponseValue;
15315 // bool Level_eq(const enum LDKLevel *NONNULL_PTR a, const enum LDKLevel *NONNULL_PTR b);
15317 export function Level_eq(a: number, b: number): boolean {
15318 if(!isWasmInitialized) {
15319 throw new Error("initializeWasm() must be awaited first!");
15321 const nativeResponseValue = wasm.TS_Level_eq(a, b);
15322 return nativeResponseValue;
15324 // uint64_t Level_hash(const enum LDKLevel *NONNULL_PTR o);
15326 export function Level_hash(o: number): bigint {
15327 if(!isWasmInitialized) {
15328 throw new Error("initializeWasm() must be awaited first!");
15330 const nativeResponseValue = wasm.TS_Level_hash(o);
15331 return nativeResponseValue;
15333 // MUST_USE_RES enum LDKLevel Level_max(void);
15335 export function Level_max(): Level {
15336 if(!isWasmInitialized) {
15337 throw new Error("initializeWasm() must be awaited first!");
15339 const nativeResponseValue = wasm.TS_Level_max();
15340 return nativeResponseValue;
15342 // void Record_free(struct LDKRecord this_obj);
15344 export function Record_free(this_obj: number): void {
15345 if(!isWasmInitialized) {
15346 throw new Error("initializeWasm() must be awaited first!");
15348 const nativeResponseValue = wasm.TS_Record_free(this_obj);
15349 // debug statements here
15351 // enum LDKLevel Record_get_level(const struct LDKRecord *NONNULL_PTR this_ptr);
15353 export function Record_get_level(this_ptr: number): Level {
15354 if(!isWasmInitialized) {
15355 throw new Error("initializeWasm() must be awaited first!");
15357 const nativeResponseValue = wasm.TS_Record_get_level(this_ptr);
15358 return nativeResponseValue;
15360 // void Record_set_level(struct LDKRecord *NONNULL_PTR this_ptr, enum LDKLevel val);
15362 export function Record_set_level(this_ptr: number, val: Level): void {
15363 if(!isWasmInitialized) {
15364 throw new Error("initializeWasm() must be awaited first!");
15366 const nativeResponseValue = wasm.TS_Record_set_level(this_ptr, val);
15367 // debug statements here
15369 // struct LDKStr Record_get_args(const struct LDKRecord *NONNULL_PTR this_ptr);
15371 export function Record_get_args(this_ptr: number): number {
15372 if(!isWasmInitialized) {
15373 throw new Error("initializeWasm() must be awaited first!");
15375 const nativeResponseValue = wasm.TS_Record_get_args(this_ptr);
15376 return nativeResponseValue;
15378 // void Record_set_args(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
15380 export function Record_set_args(this_ptr: number, val: number): void {
15381 if(!isWasmInitialized) {
15382 throw new Error("initializeWasm() must be awaited first!");
15384 const nativeResponseValue = wasm.TS_Record_set_args(this_ptr, val);
15385 // debug statements here
15387 // struct LDKStr Record_get_module_path(const struct LDKRecord *NONNULL_PTR this_ptr);
15389 export function Record_get_module_path(this_ptr: number): number {
15390 if(!isWasmInitialized) {
15391 throw new Error("initializeWasm() must be awaited first!");
15393 const nativeResponseValue = wasm.TS_Record_get_module_path(this_ptr);
15394 return nativeResponseValue;
15396 // void Record_set_module_path(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
15398 export function Record_set_module_path(this_ptr: number, val: number): void {
15399 if(!isWasmInitialized) {
15400 throw new Error("initializeWasm() must be awaited first!");
15402 const nativeResponseValue = wasm.TS_Record_set_module_path(this_ptr, val);
15403 // debug statements here
15405 // struct LDKStr Record_get_file(const struct LDKRecord *NONNULL_PTR this_ptr);
15407 export function Record_get_file(this_ptr: number): number {
15408 if(!isWasmInitialized) {
15409 throw new Error("initializeWasm() must be awaited first!");
15411 const nativeResponseValue = wasm.TS_Record_get_file(this_ptr);
15412 return nativeResponseValue;
15414 // void Record_set_file(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
15416 export function Record_set_file(this_ptr: number, val: number): void {
15417 if(!isWasmInitialized) {
15418 throw new Error("initializeWasm() must be awaited first!");
15420 const nativeResponseValue = wasm.TS_Record_set_file(this_ptr, val);
15421 // debug statements here
15423 // uint32_t Record_get_line(const struct LDKRecord *NONNULL_PTR this_ptr);
15425 export function Record_get_line(this_ptr: number): number {
15426 if(!isWasmInitialized) {
15427 throw new Error("initializeWasm() must be awaited first!");
15429 const nativeResponseValue = wasm.TS_Record_get_line(this_ptr);
15430 return nativeResponseValue;
15432 // void Record_set_line(struct LDKRecord *NONNULL_PTR this_ptr, uint32_t val);
15434 export function Record_set_line(this_ptr: number, val: number): void {
15435 if(!isWasmInitialized) {
15436 throw new Error("initializeWasm() must be awaited first!");
15438 const nativeResponseValue = wasm.TS_Record_set_line(this_ptr, val);
15439 // debug statements here
15441 // uintptr_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg);
15443 export function Record_clone_ptr(arg: number): number {
15444 if(!isWasmInitialized) {
15445 throw new Error("initializeWasm() must be awaited first!");
15447 const nativeResponseValue = wasm.TS_Record_clone_ptr(arg);
15448 return nativeResponseValue;
15450 // struct LDKRecord Record_clone(const struct LDKRecord *NONNULL_PTR orig);
15452 export function Record_clone(orig: number): number {
15453 if(!isWasmInitialized) {
15454 throw new Error("initializeWasm() must be awaited first!");
15456 const nativeResponseValue = wasm.TS_Record_clone(orig);
15457 return nativeResponseValue;
15459 // void Logger_free(struct LDKLogger this_ptr);
15461 export function Logger_free(this_ptr: number): void {
15462 if(!isWasmInitialized) {
15463 throw new Error("initializeWasm() must be awaited first!");
15465 const nativeResponseValue = wasm.TS_Logger_free(this_ptr);
15466 // debug statements here
15468 // void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_obj);
15470 export function ChannelHandshakeConfig_free(this_obj: number): void {
15471 if(!isWasmInitialized) {
15472 throw new Error("initializeWasm() must be awaited first!");
15474 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_free(this_obj);
15475 // debug statements here
15477 // uint32_t ChannelHandshakeConfig_get_minimum_depth(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
15479 export function ChannelHandshakeConfig_get_minimum_depth(this_ptr: number): number {
15480 if(!isWasmInitialized) {
15481 throw new Error("initializeWasm() must be awaited first!");
15483 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_minimum_depth(this_ptr);
15484 return nativeResponseValue;
15486 // void ChannelHandshakeConfig_set_minimum_depth(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
15488 export function ChannelHandshakeConfig_set_minimum_depth(this_ptr: number, val: number): void {
15489 if(!isWasmInitialized) {
15490 throw new Error("initializeWasm() must be awaited first!");
15492 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_minimum_depth(this_ptr, val);
15493 // debug statements here
15495 // uint16_t ChannelHandshakeConfig_get_our_to_self_delay(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
15497 export function ChannelHandshakeConfig_get_our_to_self_delay(this_ptr: number): number {
15498 if(!isWasmInitialized) {
15499 throw new Error("initializeWasm() must be awaited first!");
15501 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_to_self_delay(this_ptr);
15502 return nativeResponseValue;
15504 // void ChannelHandshakeConfig_set_our_to_self_delay(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
15506 export function ChannelHandshakeConfig_set_our_to_self_delay(this_ptr: number, val: number): void {
15507 if(!isWasmInitialized) {
15508 throw new Error("initializeWasm() must be awaited first!");
15510 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_to_self_delay(this_ptr, val);
15511 // debug statements here
15513 // uint64_t ChannelHandshakeConfig_get_our_htlc_minimum_msat(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
15515 export function ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr: number): bigint {
15516 if(!isWasmInitialized) {
15517 throw new Error("initializeWasm() must be awaited first!");
15519 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr);
15520 return nativeResponseValue;
15522 // void ChannelHandshakeConfig_set_our_htlc_minimum_msat(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint64_t val);
15524 export function ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr: number, val: bigint): void {
15525 if(!isWasmInitialized) {
15526 throw new Error("initializeWasm() must be awaited first!");
15528 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr, val);
15529 // debug statements here
15531 // 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);
15533 export function ChannelHandshakeConfig_new(minimum_depth_arg: number, our_to_self_delay_arg: number, our_htlc_minimum_msat_arg: bigint): number {
15534 if(!isWasmInitialized) {
15535 throw new Error("initializeWasm() must be awaited first!");
15537 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_new(minimum_depth_arg, our_to_self_delay_arg, our_htlc_minimum_msat_arg);
15538 return nativeResponseValue;
15540 // uintptr_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg);
15542 export function ChannelHandshakeConfig_clone_ptr(arg: number): number {
15543 if(!isWasmInitialized) {
15544 throw new Error("initializeWasm() must be awaited first!");
15546 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone_ptr(arg);
15547 return nativeResponseValue;
15549 // struct LDKChannelHandshakeConfig ChannelHandshakeConfig_clone(const struct LDKChannelHandshakeConfig *NONNULL_PTR orig);
15551 export function ChannelHandshakeConfig_clone(orig: number): number {
15552 if(!isWasmInitialized) {
15553 throw new Error("initializeWasm() must be awaited first!");
15555 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone(orig);
15556 return nativeResponseValue;
15558 // MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void);
15560 export function ChannelHandshakeConfig_default(): number {
15561 if(!isWasmInitialized) {
15562 throw new Error("initializeWasm() must be awaited first!");
15564 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_default();
15565 return nativeResponseValue;
15567 // void ChannelHandshakeLimits_free(struct LDKChannelHandshakeLimits this_obj);
15569 export function ChannelHandshakeLimits_free(this_obj: number): void {
15570 if(!isWasmInitialized) {
15571 throw new Error("initializeWasm() must be awaited first!");
15573 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_free(this_obj);
15574 // debug statements here
15576 // uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
15578 export function ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr: number): bigint {
15579 if(!isWasmInitialized) {
15580 throw new Error("initializeWasm() must be awaited first!");
15582 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr);
15583 return nativeResponseValue;
15585 // void ChannelHandshakeLimits_set_min_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
15587 export function ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr: number, val: bigint): void {
15588 if(!isWasmInitialized) {
15589 throw new Error("initializeWasm() must be awaited first!");
15591 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr, val);
15592 // debug statements here
15594 // uint64_t ChannelHandshakeLimits_get_max_htlc_minimum_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
15596 export function ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr: number): bigint {
15597 if(!isWasmInitialized) {
15598 throw new Error("initializeWasm() must be awaited first!");
15600 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr);
15601 return nativeResponseValue;
15603 // void ChannelHandshakeLimits_set_max_htlc_minimum_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
15605 export function ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr: number, val: bigint): void {
15606 if(!isWasmInitialized) {
15607 throw new Error("initializeWasm() must be awaited first!");
15609 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr, val);
15610 // debug statements here
15612 // uint64_t ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
15614 export function ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
15615 if(!isWasmInitialized) {
15616 throw new Error("initializeWasm() must be awaited first!");
15618 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr);
15619 return nativeResponseValue;
15621 // void ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
15623 export function ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
15624 if(!isWasmInitialized) {
15625 throw new Error("initializeWasm() must be awaited first!");
15627 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr, val);
15628 // debug statements here
15630 // uint64_t ChannelHandshakeLimits_get_max_channel_reserve_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
15632 export function ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr: number): bigint {
15633 if(!isWasmInitialized) {
15634 throw new Error("initializeWasm() must be awaited first!");
15636 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr);
15637 return nativeResponseValue;
15639 // void ChannelHandshakeLimits_set_max_channel_reserve_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
15641 export function ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
15642 if(!isWasmInitialized) {
15643 throw new Error("initializeWasm() must be awaited first!");
15645 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr, val);
15646 // debug statements here
15648 // uint16_t ChannelHandshakeLimits_get_min_max_accepted_htlcs(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
15650 export function ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr: number): number {
15651 if(!isWasmInitialized) {
15652 throw new Error("initializeWasm() must be awaited first!");
15654 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr);
15655 return nativeResponseValue;
15657 // void ChannelHandshakeLimits_set_min_max_accepted_htlcs(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
15659 export function ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr: number, val: number): void {
15660 if(!isWasmInitialized) {
15661 throw new Error("initializeWasm() must be awaited first!");
15663 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr, val);
15664 // debug statements here
15666 // uint32_t ChannelHandshakeLimits_get_max_minimum_depth(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
15668 export function ChannelHandshakeLimits_get_max_minimum_depth(this_ptr: number): number {
15669 if(!isWasmInitialized) {
15670 throw new Error("initializeWasm() must be awaited first!");
15672 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_minimum_depth(this_ptr);
15673 return nativeResponseValue;
15675 // void ChannelHandshakeLimits_set_max_minimum_depth(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint32_t val);
15677 export function ChannelHandshakeLimits_set_max_minimum_depth(this_ptr: number, val: number): void {
15678 if(!isWasmInitialized) {
15679 throw new Error("initializeWasm() must be awaited first!");
15681 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_minimum_depth(this_ptr, val);
15682 // debug statements here
15684 // bool ChannelHandshakeLimits_get_force_announced_channel_preference(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
15686 export function ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr: number): boolean {
15687 if(!isWasmInitialized) {
15688 throw new Error("initializeWasm() must be awaited first!");
15690 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr);
15691 return nativeResponseValue;
15693 // void ChannelHandshakeLimits_set_force_announced_channel_preference(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
15695 export function ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr: number, val: boolean): void {
15696 if(!isWasmInitialized) {
15697 throw new Error("initializeWasm() must be awaited first!");
15699 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr, val);
15700 // debug statements here
15702 // uint16_t ChannelHandshakeLimits_get_their_to_self_delay(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
15704 export function ChannelHandshakeLimits_get_their_to_self_delay(this_ptr: number): number {
15705 if(!isWasmInitialized) {
15706 throw new Error("initializeWasm() must be awaited first!");
15708 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_their_to_self_delay(this_ptr);
15709 return nativeResponseValue;
15711 // void ChannelHandshakeLimits_set_their_to_self_delay(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
15713 export function ChannelHandshakeLimits_set_their_to_self_delay(this_ptr: number, val: number): void {
15714 if(!isWasmInitialized) {
15715 throw new Error("initializeWasm() must be awaited first!");
15717 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_their_to_self_delay(this_ptr, val);
15718 // debug statements here
15720 // 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);
15722 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 {
15723 if(!isWasmInitialized) {
15724 throw new Error("initializeWasm() must be awaited first!");
15726 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);
15727 return nativeResponseValue;
15729 // uintptr_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg);
15731 export function ChannelHandshakeLimits_clone_ptr(arg: number): number {
15732 if(!isWasmInitialized) {
15733 throw new Error("initializeWasm() must be awaited first!");
15735 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone_ptr(arg);
15736 return nativeResponseValue;
15738 // struct LDKChannelHandshakeLimits ChannelHandshakeLimits_clone(const struct LDKChannelHandshakeLimits *NONNULL_PTR orig);
15740 export function ChannelHandshakeLimits_clone(orig: number): number {
15741 if(!isWasmInitialized) {
15742 throw new Error("initializeWasm() must be awaited first!");
15744 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone(orig);
15745 return nativeResponseValue;
15747 // MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_default(void);
15749 export function ChannelHandshakeLimits_default(): number {
15750 if(!isWasmInitialized) {
15751 throw new Error("initializeWasm() must be awaited first!");
15753 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_default();
15754 return nativeResponseValue;
15756 // void ChannelConfig_free(struct LDKChannelConfig this_obj);
15758 export function ChannelConfig_free(this_obj: number): void {
15759 if(!isWasmInitialized) {
15760 throw new Error("initializeWasm() must be awaited first!");
15762 const nativeResponseValue = wasm.TS_ChannelConfig_free(this_obj);
15763 // debug statements here
15765 // uint32_t ChannelConfig_get_forwarding_fee_proportional_millionths(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
15767 export function ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr: number): number {
15768 if(!isWasmInitialized) {
15769 throw new Error("initializeWasm() must be awaited first!");
15771 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr);
15772 return nativeResponseValue;
15774 // void ChannelConfig_set_forwarding_fee_proportional_millionths(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
15776 export function ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr: number, val: number): void {
15777 if(!isWasmInitialized) {
15778 throw new Error("initializeWasm() must be awaited first!");
15780 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr, val);
15781 // debug statements here
15783 // uint32_t ChannelConfig_get_forwarding_fee_base_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
15785 export function ChannelConfig_get_forwarding_fee_base_msat(this_ptr: number): number {
15786 if(!isWasmInitialized) {
15787 throw new Error("initializeWasm() must be awaited first!");
15789 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_base_msat(this_ptr);
15790 return nativeResponseValue;
15792 // void ChannelConfig_set_forwarding_fee_base_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
15794 export function ChannelConfig_set_forwarding_fee_base_msat(this_ptr: number, val: number): void {
15795 if(!isWasmInitialized) {
15796 throw new Error("initializeWasm() must be awaited first!");
15798 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_base_msat(this_ptr, val);
15799 // debug statements here
15801 // uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
15803 export function ChannelConfig_get_cltv_expiry_delta(this_ptr: number): number {
15804 if(!isWasmInitialized) {
15805 throw new Error("initializeWasm() must be awaited first!");
15807 const nativeResponseValue = wasm.TS_ChannelConfig_get_cltv_expiry_delta(this_ptr);
15808 return nativeResponseValue;
15810 // void ChannelConfig_set_cltv_expiry_delta(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint16_t val);
15812 export function ChannelConfig_set_cltv_expiry_delta(this_ptr: number, val: number): void {
15813 if(!isWasmInitialized) {
15814 throw new Error("initializeWasm() must be awaited first!");
15816 const nativeResponseValue = wasm.TS_ChannelConfig_set_cltv_expiry_delta(this_ptr, val);
15817 // debug statements here
15819 // bool ChannelConfig_get_announced_channel(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
15821 export function ChannelConfig_get_announced_channel(this_ptr: number): boolean {
15822 if(!isWasmInitialized) {
15823 throw new Error("initializeWasm() must be awaited first!");
15825 const nativeResponseValue = wasm.TS_ChannelConfig_get_announced_channel(this_ptr);
15826 return nativeResponseValue;
15828 // void ChannelConfig_set_announced_channel(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
15830 export function ChannelConfig_set_announced_channel(this_ptr: number, val: boolean): void {
15831 if(!isWasmInitialized) {
15832 throw new Error("initializeWasm() must be awaited first!");
15834 const nativeResponseValue = wasm.TS_ChannelConfig_set_announced_channel(this_ptr, val);
15835 // debug statements here
15837 // bool ChannelConfig_get_commit_upfront_shutdown_pubkey(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
15839 export function ChannelConfig_get_commit_upfront_shutdown_pubkey(this_ptr: number): boolean {
15840 if(!isWasmInitialized) {
15841 throw new Error("initializeWasm() must be awaited first!");
15843 const nativeResponseValue = wasm.TS_ChannelConfig_get_commit_upfront_shutdown_pubkey(this_ptr);
15844 return nativeResponseValue;
15846 // void ChannelConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
15848 export function ChannelConfig_set_commit_upfront_shutdown_pubkey(this_ptr: number, val: boolean): void {
15849 if(!isWasmInitialized) {
15850 throw new Error("initializeWasm() must be awaited first!");
15852 const nativeResponseValue = wasm.TS_ChannelConfig_set_commit_upfront_shutdown_pubkey(this_ptr, val);
15853 // debug statements here
15855 // uint64_t ChannelConfig_get_max_dust_htlc_exposure_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
15857 export function ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr: number): bigint {
15858 if(!isWasmInitialized) {
15859 throw new Error("initializeWasm() must be awaited first!");
15861 const nativeResponseValue = wasm.TS_ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr);
15862 return nativeResponseValue;
15864 // void ChannelConfig_set_max_dust_htlc_exposure_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
15866 export function ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr: number, val: bigint): void {
15867 if(!isWasmInitialized) {
15868 throw new Error("initializeWasm() must be awaited first!");
15870 const nativeResponseValue = wasm.TS_ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr, val);
15871 // debug statements here
15873 // uint64_t ChannelConfig_get_force_close_avoidance_max_fee_satoshis(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
15875 export function ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr: number): bigint {
15876 if(!isWasmInitialized) {
15877 throw new Error("initializeWasm() must be awaited first!");
15879 const nativeResponseValue = wasm.TS_ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr);
15880 return nativeResponseValue;
15882 // void ChannelConfig_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
15884 export function ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr: number, val: bigint): void {
15885 if(!isWasmInitialized) {
15886 throw new Error("initializeWasm() must be awaited first!");
15888 const nativeResponseValue = wasm.TS_ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr, val);
15889 // debug statements here
15891 // 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);
15893 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 {
15894 if(!isWasmInitialized) {
15895 throw new Error("initializeWasm() must be awaited first!");
15897 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);
15898 return nativeResponseValue;
15900 // uintptr_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg);
15902 export function ChannelConfig_clone_ptr(arg: number): number {
15903 if(!isWasmInitialized) {
15904 throw new Error("initializeWasm() must be awaited first!");
15906 const nativeResponseValue = wasm.TS_ChannelConfig_clone_ptr(arg);
15907 return nativeResponseValue;
15909 // struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
15911 export function ChannelConfig_clone(orig: number): number {
15912 if(!isWasmInitialized) {
15913 throw new Error("initializeWasm() must be awaited first!");
15915 const nativeResponseValue = wasm.TS_ChannelConfig_clone(orig);
15916 return nativeResponseValue;
15918 // MUST_USE_RES struct LDKChannelConfig ChannelConfig_default(void);
15920 export function ChannelConfig_default(): number {
15921 if(!isWasmInitialized) {
15922 throw new Error("initializeWasm() must be awaited first!");
15924 const nativeResponseValue = wasm.TS_ChannelConfig_default();
15925 return nativeResponseValue;
15927 // struct LDKCVec_u8Z ChannelConfig_write(const struct LDKChannelConfig *NONNULL_PTR obj);
15929 export function ChannelConfig_write(obj: number): number {
15930 if(!isWasmInitialized) {
15931 throw new Error("initializeWasm() must be awaited first!");
15933 const nativeResponseValue = wasm.TS_ChannelConfig_write(obj);
15934 return nativeResponseValue;
15936 // struct LDKCResult_ChannelConfigDecodeErrorZ ChannelConfig_read(struct LDKu8slice ser);
15938 export function ChannelConfig_read(ser: number): number {
15939 if(!isWasmInitialized) {
15940 throw new Error("initializeWasm() must be awaited first!");
15942 const nativeResponseValue = wasm.TS_ChannelConfig_read(ser);
15943 return nativeResponseValue;
15945 // void UserConfig_free(struct LDKUserConfig this_obj);
15947 export function UserConfig_free(this_obj: number): void {
15948 if(!isWasmInitialized) {
15949 throw new Error("initializeWasm() must be awaited first!");
15951 const nativeResponseValue = wasm.TS_UserConfig_free(this_obj);
15952 // debug statements here
15954 // struct LDKChannelHandshakeConfig UserConfig_get_own_channel_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
15956 export function UserConfig_get_own_channel_config(this_ptr: number): number {
15957 if(!isWasmInitialized) {
15958 throw new Error("initializeWasm() must be awaited first!");
15960 const nativeResponseValue = wasm.TS_UserConfig_get_own_channel_config(this_ptr);
15961 return nativeResponseValue;
15963 // void UserConfig_set_own_channel_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeConfig val);
15965 export function UserConfig_set_own_channel_config(this_ptr: number, val: number): void {
15966 if(!isWasmInitialized) {
15967 throw new Error("initializeWasm() must be awaited first!");
15969 const nativeResponseValue = wasm.TS_UserConfig_set_own_channel_config(this_ptr, val);
15970 // debug statements here
15972 // struct LDKChannelHandshakeLimits UserConfig_get_peer_channel_config_limits(const struct LDKUserConfig *NONNULL_PTR this_ptr);
15974 export function UserConfig_get_peer_channel_config_limits(this_ptr: number): number {
15975 if(!isWasmInitialized) {
15976 throw new Error("initializeWasm() must be awaited first!");
15978 const nativeResponseValue = wasm.TS_UserConfig_get_peer_channel_config_limits(this_ptr);
15979 return nativeResponseValue;
15981 // void UserConfig_set_peer_channel_config_limits(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeLimits val);
15983 export function UserConfig_set_peer_channel_config_limits(this_ptr: number, val: number): void {
15984 if(!isWasmInitialized) {
15985 throw new Error("initializeWasm() must be awaited first!");
15987 const nativeResponseValue = wasm.TS_UserConfig_set_peer_channel_config_limits(this_ptr, val);
15988 // debug statements here
15990 // struct LDKChannelConfig UserConfig_get_channel_options(const struct LDKUserConfig *NONNULL_PTR this_ptr);
15992 export function UserConfig_get_channel_options(this_ptr: number): number {
15993 if(!isWasmInitialized) {
15994 throw new Error("initializeWasm() must be awaited first!");
15996 const nativeResponseValue = wasm.TS_UserConfig_get_channel_options(this_ptr);
15997 return nativeResponseValue;
15999 // void UserConfig_set_channel_options(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
16001 export function UserConfig_set_channel_options(this_ptr: number, val: number): void {
16002 if(!isWasmInitialized) {
16003 throw new Error("initializeWasm() must be awaited first!");
16005 const nativeResponseValue = wasm.TS_UserConfig_set_channel_options(this_ptr, val);
16006 // debug statements here
16008 // bool UserConfig_get_accept_forwards_to_priv_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16010 export function UserConfig_get_accept_forwards_to_priv_channels(this_ptr: number): boolean {
16011 if(!isWasmInitialized) {
16012 throw new Error("initializeWasm() must be awaited first!");
16014 const nativeResponseValue = wasm.TS_UserConfig_get_accept_forwards_to_priv_channels(this_ptr);
16015 return nativeResponseValue;
16017 // void UserConfig_set_accept_forwards_to_priv_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
16019 export function UserConfig_set_accept_forwards_to_priv_channels(this_ptr: number, val: boolean): void {
16020 if(!isWasmInitialized) {
16021 throw new Error("initializeWasm() must be awaited first!");
16023 const nativeResponseValue = wasm.TS_UserConfig_set_accept_forwards_to_priv_channels(this_ptr, val);
16024 // debug statements here
16026 // bool UserConfig_get_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16028 export function UserConfig_get_accept_inbound_channels(this_ptr: number): boolean {
16029 if(!isWasmInitialized) {
16030 throw new Error("initializeWasm() must be awaited first!");
16032 const nativeResponseValue = wasm.TS_UserConfig_get_accept_inbound_channels(this_ptr);
16033 return nativeResponseValue;
16035 // void UserConfig_set_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
16037 export function UserConfig_set_accept_inbound_channels(this_ptr: number, val: boolean): void {
16038 if(!isWasmInitialized) {
16039 throw new Error("initializeWasm() must be awaited first!");
16041 const nativeResponseValue = wasm.TS_UserConfig_set_accept_inbound_channels(this_ptr, val);
16042 // debug statements here
16044 // bool UserConfig_get_manually_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16046 export function UserConfig_get_manually_accept_inbound_channels(this_ptr: number): boolean {
16047 if(!isWasmInitialized) {
16048 throw new Error("initializeWasm() must be awaited first!");
16050 const nativeResponseValue = wasm.TS_UserConfig_get_manually_accept_inbound_channels(this_ptr);
16051 return nativeResponseValue;
16053 // void UserConfig_set_manually_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
16055 export function UserConfig_set_manually_accept_inbound_channels(this_ptr: number, val: boolean): void {
16056 if(!isWasmInitialized) {
16057 throw new Error("initializeWasm() must be awaited first!");
16059 const nativeResponseValue = wasm.TS_UserConfig_set_manually_accept_inbound_channels(this_ptr, val);
16060 // debug statements here
16062 // 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);
16064 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 {
16065 if(!isWasmInitialized) {
16066 throw new Error("initializeWasm() must be awaited first!");
16068 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);
16069 return nativeResponseValue;
16071 // uintptr_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg);
16073 export function UserConfig_clone_ptr(arg: number): number {
16074 if(!isWasmInitialized) {
16075 throw new Error("initializeWasm() must be awaited first!");
16077 const nativeResponseValue = wasm.TS_UserConfig_clone_ptr(arg);
16078 return nativeResponseValue;
16080 // struct LDKUserConfig UserConfig_clone(const struct LDKUserConfig *NONNULL_PTR orig);
16082 export function UserConfig_clone(orig: number): number {
16083 if(!isWasmInitialized) {
16084 throw new Error("initializeWasm() must be awaited first!");
16086 const nativeResponseValue = wasm.TS_UserConfig_clone(orig);
16087 return nativeResponseValue;
16089 // MUST_USE_RES struct LDKUserConfig UserConfig_default(void);
16091 export function UserConfig_default(): number {
16092 if(!isWasmInitialized) {
16093 throw new Error("initializeWasm() must be awaited first!");
16095 const nativeResponseValue = wasm.TS_UserConfig_default();
16096 return nativeResponseValue;
16098 // void BestBlock_free(struct LDKBestBlock this_obj);
16100 export function BestBlock_free(this_obj: number): void {
16101 if(!isWasmInitialized) {
16102 throw new Error("initializeWasm() must be awaited first!");
16104 const nativeResponseValue = wasm.TS_BestBlock_free(this_obj);
16105 // debug statements here
16107 // uintptr_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg);
16109 export function BestBlock_clone_ptr(arg: number): number {
16110 if(!isWasmInitialized) {
16111 throw new Error("initializeWasm() must be awaited first!");
16113 const nativeResponseValue = wasm.TS_BestBlock_clone_ptr(arg);
16114 return nativeResponseValue;
16116 // struct LDKBestBlock BestBlock_clone(const struct LDKBestBlock *NONNULL_PTR orig);
16118 export function BestBlock_clone(orig: number): number {
16119 if(!isWasmInitialized) {
16120 throw new Error("initializeWasm() must be awaited first!");
16122 const nativeResponseValue = wasm.TS_BestBlock_clone(orig);
16123 return nativeResponseValue;
16125 // MUST_USE_RES struct LDKBestBlock BestBlock_from_genesis(enum LDKNetwork network);
16127 export function BestBlock_from_genesis(network: Network): number {
16128 if(!isWasmInitialized) {
16129 throw new Error("initializeWasm() must be awaited first!");
16131 const nativeResponseValue = wasm.TS_BestBlock_from_genesis(network);
16132 return nativeResponseValue;
16134 // MUST_USE_RES struct LDKBestBlock BestBlock_new(struct LDKThirtyTwoBytes block_hash, uint32_t height);
16136 export function BestBlock_new(block_hash: number, height: number): number {
16137 if(!isWasmInitialized) {
16138 throw new Error("initializeWasm() must be awaited first!");
16140 const nativeResponseValue = wasm.TS_BestBlock_new(block_hash, height);
16141 return nativeResponseValue;
16143 // MUST_USE_RES struct LDKThirtyTwoBytes BestBlock_block_hash(const struct LDKBestBlock *NONNULL_PTR this_arg);
16145 export function BestBlock_block_hash(this_arg: number): number {
16146 if(!isWasmInitialized) {
16147 throw new Error("initializeWasm() must be awaited first!");
16149 const nativeResponseValue = wasm.TS_BestBlock_block_hash(this_arg);
16150 return nativeResponseValue;
16152 // MUST_USE_RES uint32_t BestBlock_height(const struct LDKBestBlock *NONNULL_PTR this_arg);
16154 export function BestBlock_height(this_arg: number): number {
16155 if(!isWasmInitialized) {
16156 throw new Error("initializeWasm() must be awaited first!");
16158 const nativeResponseValue = wasm.TS_BestBlock_height(this_arg);
16159 return nativeResponseValue;
16161 // enum LDKAccessError AccessError_clone(const enum LDKAccessError *NONNULL_PTR orig);
16163 export function AccessError_clone(orig: number): AccessError {
16164 if(!isWasmInitialized) {
16165 throw new Error("initializeWasm() must be awaited first!");
16167 const nativeResponseValue = wasm.TS_AccessError_clone(orig);
16168 return nativeResponseValue;
16170 // enum LDKAccessError AccessError_unknown_chain(void);
16172 export function AccessError_unknown_chain(): AccessError {
16173 if(!isWasmInitialized) {
16174 throw new Error("initializeWasm() must be awaited first!");
16176 const nativeResponseValue = wasm.TS_AccessError_unknown_chain();
16177 return nativeResponseValue;
16179 // enum LDKAccessError AccessError_unknown_tx(void);
16181 export function AccessError_unknown_tx(): AccessError {
16182 if(!isWasmInitialized) {
16183 throw new Error("initializeWasm() must be awaited first!");
16185 const nativeResponseValue = wasm.TS_AccessError_unknown_tx();
16186 return nativeResponseValue;
16188 // void Access_free(struct LDKAccess this_ptr);
16190 export function Access_free(this_ptr: number): void {
16191 if(!isWasmInitialized) {
16192 throw new Error("initializeWasm() must be awaited first!");
16194 const nativeResponseValue = wasm.TS_Access_free(this_ptr);
16195 // debug statements here
16197 // void Listen_free(struct LDKListen this_ptr);
16199 export function Listen_free(this_ptr: number): void {
16200 if(!isWasmInitialized) {
16201 throw new Error("initializeWasm() must be awaited first!");
16203 const nativeResponseValue = wasm.TS_Listen_free(this_ptr);
16204 // debug statements here
16206 // void Confirm_free(struct LDKConfirm this_ptr);
16208 export function Confirm_free(this_ptr: number): void {
16209 if(!isWasmInitialized) {
16210 throw new Error("initializeWasm() must be awaited first!");
16212 const nativeResponseValue = wasm.TS_Confirm_free(this_ptr);
16213 // debug statements here
16215 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_clone(const enum LDKChannelMonitorUpdateErr *NONNULL_PTR orig);
16217 export function ChannelMonitorUpdateErr_clone(orig: number): ChannelMonitorUpdateErr {
16218 if(!isWasmInitialized) {
16219 throw new Error("initializeWasm() must be awaited first!");
16221 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_clone(orig);
16222 return nativeResponseValue;
16224 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_temporary_failure(void);
16226 export function ChannelMonitorUpdateErr_temporary_failure(): ChannelMonitorUpdateErr {
16227 if(!isWasmInitialized) {
16228 throw new Error("initializeWasm() must be awaited first!");
16230 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_temporary_failure();
16231 return nativeResponseValue;
16233 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_permanent_failure(void);
16235 export function ChannelMonitorUpdateErr_permanent_failure(): ChannelMonitorUpdateErr {
16236 if(!isWasmInitialized) {
16237 throw new Error("initializeWasm() must be awaited first!");
16239 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_permanent_failure();
16240 return nativeResponseValue;
16242 // void Watch_free(struct LDKWatch this_ptr);
16244 export function Watch_free(this_ptr: number): void {
16245 if(!isWasmInitialized) {
16246 throw new Error("initializeWasm() must be awaited first!");
16248 const nativeResponseValue = wasm.TS_Watch_free(this_ptr);
16249 // debug statements here
16251 // void Filter_free(struct LDKFilter this_ptr);
16253 export function Filter_free(this_ptr: number): void {
16254 if(!isWasmInitialized) {
16255 throw new Error("initializeWasm() must be awaited first!");
16257 const nativeResponseValue = wasm.TS_Filter_free(this_ptr);
16258 // debug statements here
16260 // void WatchedOutput_free(struct LDKWatchedOutput this_obj);
16262 export function WatchedOutput_free(this_obj: number): void {
16263 if(!isWasmInitialized) {
16264 throw new Error("initializeWasm() must be awaited first!");
16266 const nativeResponseValue = wasm.TS_WatchedOutput_free(this_obj);
16267 // debug statements here
16269 // struct LDKThirtyTwoBytes WatchedOutput_get_block_hash(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
16271 export function WatchedOutput_get_block_hash(this_ptr: number): number {
16272 if(!isWasmInitialized) {
16273 throw new Error("initializeWasm() must be awaited first!");
16275 const nativeResponseValue = wasm.TS_WatchedOutput_get_block_hash(this_ptr);
16276 return nativeResponseValue;
16278 // void WatchedOutput_set_block_hash(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
16280 export function WatchedOutput_set_block_hash(this_ptr: number, val: number): void {
16281 if(!isWasmInitialized) {
16282 throw new Error("initializeWasm() must be awaited first!");
16284 const nativeResponseValue = wasm.TS_WatchedOutput_set_block_hash(this_ptr, val);
16285 // debug statements here
16287 // struct LDKOutPoint WatchedOutput_get_outpoint(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
16289 export function WatchedOutput_get_outpoint(this_ptr: number): number {
16290 if(!isWasmInitialized) {
16291 throw new Error("initializeWasm() must be awaited first!");
16293 const nativeResponseValue = wasm.TS_WatchedOutput_get_outpoint(this_ptr);
16294 return nativeResponseValue;
16296 // void WatchedOutput_set_outpoint(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
16298 export function WatchedOutput_set_outpoint(this_ptr: number, val: number): void {
16299 if(!isWasmInitialized) {
16300 throw new Error("initializeWasm() must be awaited first!");
16302 const nativeResponseValue = wasm.TS_WatchedOutput_set_outpoint(this_ptr, val);
16303 // debug statements here
16305 // struct LDKu8slice WatchedOutput_get_script_pubkey(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
16307 export function WatchedOutput_get_script_pubkey(this_ptr: number): number {
16308 if(!isWasmInitialized) {
16309 throw new Error("initializeWasm() must be awaited first!");
16311 const nativeResponseValue = wasm.TS_WatchedOutput_get_script_pubkey(this_ptr);
16312 return nativeResponseValue;
16314 // void WatchedOutput_set_script_pubkey(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
16316 export function WatchedOutput_set_script_pubkey(this_ptr: number, val: number): void {
16317 if(!isWasmInitialized) {
16318 throw new Error("initializeWasm() must be awaited first!");
16320 const nativeResponseValue = wasm.TS_WatchedOutput_set_script_pubkey(this_ptr, val);
16321 // debug statements here
16323 // MUST_USE_RES struct LDKWatchedOutput WatchedOutput_new(struct LDKThirtyTwoBytes block_hash_arg, struct LDKOutPoint outpoint_arg, struct LDKCVec_u8Z script_pubkey_arg);
16325 export function WatchedOutput_new(block_hash_arg: number, outpoint_arg: number, script_pubkey_arg: number): number {
16326 if(!isWasmInitialized) {
16327 throw new Error("initializeWasm() must be awaited first!");
16329 const nativeResponseValue = wasm.TS_WatchedOutput_new(block_hash_arg, outpoint_arg, script_pubkey_arg);
16330 return nativeResponseValue;
16332 // uintptr_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg);
16334 export function WatchedOutput_clone_ptr(arg: number): number {
16335 if(!isWasmInitialized) {
16336 throw new Error("initializeWasm() must be awaited first!");
16338 const nativeResponseValue = wasm.TS_WatchedOutput_clone_ptr(arg);
16339 return nativeResponseValue;
16341 // struct LDKWatchedOutput WatchedOutput_clone(const struct LDKWatchedOutput *NONNULL_PTR orig);
16343 export function WatchedOutput_clone(orig: number): number {
16344 if(!isWasmInitialized) {
16345 throw new Error("initializeWasm() must be awaited first!");
16347 const nativeResponseValue = wasm.TS_WatchedOutput_clone(orig);
16348 return nativeResponseValue;
16350 // uint64_t WatchedOutput_hash(const struct LDKWatchedOutput *NONNULL_PTR o);
16352 export function WatchedOutput_hash(o: number): bigint {
16353 if(!isWasmInitialized) {
16354 throw new Error("initializeWasm() must be awaited first!");
16356 const nativeResponseValue = wasm.TS_WatchedOutput_hash(o);
16357 return nativeResponseValue;
16359 // void BroadcasterInterface_free(struct LDKBroadcasterInterface this_ptr);
16361 export function BroadcasterInterface_free(this_ptr: number): void {
16362 if(!isWasmInitialized) {
16363 throw new Error("initializeWasm() must be awaited first!");
16365 const nativeResponseValue = wasm.TS_BroadcasterInterface_free(this_ptr);
16366 // debug statements here
16368 // enum LDKConfirmationTarget ConfirmationTarget_clone(const enum LDKConfirmationTarget *NONNULL_PTR orig);
16370 export function ConfirmationTarget_clone(orig: number): ConfirmationTarget {
16371 if(!isWasmInitialized) {
16372 throw new Error("initializeWasm() must be awaited first!");
16374 const nativeResponseValue = wasm.TS_ConfirmationTarget_clone(orig);
16375 return nativeResponseValue;
16377 // enum LDKConfirmationTarget ConfirmationTarget_background(void);
16379 export function ConfirmationTarget_background(): ConfirmationTarget {
16380 if(!isWasmInitialized) {
16381 throw new Error("initializeWasm() must be awaited first!");
16383 const nativeResponseValue = wasm.TS_ConfirmationTarget_background();
16384 return nativeResponseValue;
16386 // enum LDKConfirmationTarget ConfirmationTarget_normal(void);
16388 export function ConfirmationTarget_normal(): ConfirmationTarget {
16389 if(!isWasmInitialized) {
16390 throw new Error("initializeWasm() must be awaited first!");
16392 const nativeResponseValue = wasm.TS_ConfirmationTarget_normal();
16393 return nativeResponseValue;
16395 // enum LDKConfirmationTarget ConfirmationTarget_high_priority(void);
16397 export function ConfirmationTarget_high_priority(): ConfirmationTarget {
16398 if(!isWasmInitialized) {
16399 throw new Error("initializeWasm() must be awaited first!");
16401 const nativeResponseValue = wasm.TS_ConfirmationTarget_high_priority();
16402 return nativeResponseValue;
16404 // bool ConfirmationTarget_eq(const enum LDKConfirmationTarget *NONNULL_PTR a, const enum LDKConfirmationTarget *NONNULL_PTR b);
16406 export function ConfirmationTarget_eq(a: number, b: number): boolean {
16407 if(!isWasmInitialized) {
16408 throw new Error("initializeWasm() must be awaited first!");
16410 const nativeResponseValue = wasm.TS_ConfirmationTarget_eq(a, b);
16411 return nativeResponseValue;
16413 // void FeeEstimator_free(struct LDKFeeEstimator this_ptr);
16415 export function FeeEstimator_free(this_ptr: number): void {
16416 if(!isWasmInitialized) {
16417 throw new Error("initializeWasm() must be awaited first!");
16419 const nativeResponseValue = wasm.TS_FeeEstimator_free(this_ptr);
16420 // debug statements here
16422 // void MonitorUpdateId_free(struct LDKMonitorUpdateId this_obj);
16424 export function MonitorUpdateId_free(this_obj: number): void {
16425 if(!isWasmInitialized) {
16426 throw new Error("initializeWasm() must be awaited first!");
16428 const nativeResponseValue = wasm.TS_MonitorUpdateId_free(this_obj);
16429 // debug statements here
16431 // uintptr_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg);
16433 export function MonitorUpdateId_clone_ptr(arg: number): number {
16434 if(!isWasmInitialized) {
16435 throw new Error("initializeWasm() must be awaited first!");
16437 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone_ptr(arg);
16438 return nativeResponseValue;
16440 // struct LDKMonitorUpdateId MonitorUpdateId_clone(const struct LDKMonitorUpdateId *NONNULL_PTR orig);
16442 export function MonitorUpdateId_clone(orig: number): number {
16443 if(!isWasmInitialized) {
16444 throw new Error("initializeWasm() must be awaited first!");
16446 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone(orig);
16447 return nativeResponseValue;
16449 // uint64_t MonitorUpdateId_hash(const struct LDKMonitorUpdateId *NONNULL_PTR o);
16451 export function MonitorUpdateId_hash(o: number): bigint {
16452 if(!isWasmInitialized) {
16453 throw new Error("initializeWasm() must be awaited first!");
16455 const nativeResponseValue = wasm.TS_MonitorUpdateId_hash(o);
16456 return nativeResponseValue;
16458 // bool MonitorUpdateId_eq(const struct LDKMonitorUpdateId *NONNULL_PTR a, const struct LDKMonitorUpdateId *NONNULL_PTR b);
16460 export function MonitorUpdateId_eq(a: number, b: number): boolean {
16461 if(!isWasmInitialized) {
16462 throw new Error("initializeWasm() must be awaited first!");
16464 const nativeResponseValue = wasm.TS_MonitorUpdateId_eq(a, b);
16465 return nativeResponseValue;
16467 // void Persist_free(struct LDKPersist this_ptr);
16469 export function Persist_free(this_ptr: number): void {
16470 if(!isWasmInitialized) {
16471 throw new Error("initializeWasm() must be awaited first!");
16473 const nativeResponseValue = wasm.TS_Persist_free(this_ptr);
16474 // debug statements here
16476 // void LockedChannelMonitor_free(struct LDKLockedChannelMonitor this_obj);
16478 export function LockedChannelMonitor_free(this_obj: number): void {
16479 if(!isWasmInitialized) {
16480 throw new Error("initializeWasm() must be awaited first!");
16482 const nativeResponseValue = wasm.TS_LockedChannelMonitor_free(this_obj);
16483 // debug statements here
16485 // void ChainMonitor_free(struct LDKChainMonitor this_obj);
16487 export function ChainMonitor_free(this_obj: number): void {
16488 if(!isWasmInitialized) {
16489 throw new Error("initializeWasm() must be awaited first!");
16491 const nativeResponseValue = wasm.TS_ChainMonitor_free(this_obj);
16492 // debug statements here
16494 // MUST_USE_RES struct LDKChainMonitor ChainMonitor_new(struct LDKCOption_FilterZ chain_source, struct LDKBroadcasterInterface broadcaster, struct LDKLogger logger, struct LDKFeeEstimator feeest, struct LDKPersist persister);
16496 export function ChainMonitor_new(chain_source: number, broadcaster: number, logger: number, feeest: number, persister: number): number {
16497 if(!isWasmInitialized) {
16498 throw new Error("initializeWasm() must be awaited first!");
16500 const nativeResponseValue = wasm.TS_ChainMonitor_new(chain_source, broadcaster, logger, feeest, persister);
16501 return nativeResponseValue;
16503 // MUST_USE_RES struct LDKCVec_BalanceZ ChainMonitor_get_claimable_balances(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKCVec_ChannelDetailsZ ignored_channels);
16505 export function ChainMonitor_get_claimable_balances(this_arg: number, ignored_channels: number): number {
16506 if(!isWasmInitialized) {
16507 throw new Error("initializeWasm() must be awaited first!");
16509 const nativeResponseValue = wasm.TS_ChainMonitor_get_claimable_balances(this_arg, ignored_channels);
16510 return nativeResponseValue;
16512 // MUST_USE_RES struct LDKCResult_LockedChannelMonitorNoneZ ChainMonitor_get_monitor(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo);
16514 export function ChainMonitor_get_monitor(this_arg: number, funding_txo: number): number {
16515 if(!isWasmInitialized) {
16516 throw new Error("initializeWasm() must be awaited first!");
16518 const nativeResponseValue = wasm.TS_ChainMonitor_get_monitor(this_arg, funding_txo);
16519 return nativeResponseValue;
16521 // MUST_USE_RES struct LDKCVec_OutPointZ ChainMonitor_list_monitors(const struct LDKChainMonitor *NONNULL_PTR this_arg);
16523 export function ChainMonitor_list_monitors(this_arg: number): number {
16524 if(!isWasmInitialized) {
16525 throw new Error("initializeWasm() must be awaited first!");
16527 const nativeResponseValue = wasm.TS_ChainMonitor_list_monitors(this_arg);
16528 return nativeResponseValue;
16530 // 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);
16532 export function ChainMonitor_channel_monitor_updated(this_arg: number, funding_txo: number, completed_update_id: number): number {
16533 if(!isWasmInitialized) {
16534 throw new Error("initializeWasm() must be awaited first!");
16536 const nativeResponseValue = wasm.TS_ChainMonitor_channel_monitor_updated(this_arg, funding_txo, completed_update_id);
16537 return nativeResponseValue;
16539 // struct LDKListen ChainMonitor_as_Listen(const struct LDKChainMonitor *NONNULL_PTR this_arg);
16541 export function ChainMonitor_as_Listen(this_arg: number): number {
16542 if(!isWasmInitialized) {
16543 throw new Error("initializeWasm() must be awaited first!");
16545 const nativeResponseValue = wasm.TS_ChainMonitor_as_Listen(this_arg);
16546 return nativeResponseValue;
16548 // struct LDKConfirm ChainMonitor_as_Confirm(const struct LDKChainMonitor *NONNULL_PTR this_arg);
16550 export function ChainMonitor_as_Confirm(this_arg: number): number {
16551 if(!isWasmInitialized) {
16552 throw new Error("initializeWasm() must be awaited first!");
16554 const nativeResponseValue = wasm.TS_ChainMonitor_as_Confirm(this_arg);
16555 return nativeResponseValue;
16557 // struct LDKWatch ChainMonitor_as_Watch(const struct LDKChainMonitor *NONNULL_PTR this_arg);
16559 export function ChainMonitor_as_Watch(this_arg: number): number {
16560 if(!isWasmInitialized) {
16561 throw new Error("initializeWasm() must be awaited first!");
16563 const nativeResponseValue = wasm.TS_ChainMonitor_as_Watch(this_arg);
16564 return nativeResponseValue;
16566 // struct LDKEventsProvider ChainMonitor_as_EventsProvider(const struct LDKChainMonitor *NONNULL_PTR this_arg);
16568 export function ChainMonitor_as_EventsProvider(this_arg: number): number {
16569 if(!isWasmInitialized) {
16570 throw new Error("initializeWasm() must be awaited first!");
16572 const nativeResponseValue = wasm.TS_ChainMonitor_as_EventsProvider(this_arg);
16573 return nativeResponseValue;
16575 // void ChannelMonitorUpdate_free(struct LDKChannelMonitorUpdate this_obj);
16577 export function ChannelMonitorUpdate_free(this_obj: number): void {
16578 if(!isWasmInitialized) {
16579 throw new Error("initializeWasm() must be awaited first!");
16581 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_free(this_obj);
16582 // debug statements here
16584 // uint64_t ChannelMonitorUpdate_get_update_id(const struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr);
16586 export function ChannelMonitorUpdate_get_update_id(this_ptr: number): bigint {
16587 if(!isWasmInitialized) {
16588 throw new Error("initializeWasm() must be awaited first!");
16590 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_get_update_id(this_ptr);
16591 return nativeResponseValue;
16593 // void ChannelMonitorUpdate_set_update_id(struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr, uint64_t val);
16595 export function ChannelMonitorUpdate_set_update_id(this_ptr: number, val: bigint): void {
16596 if(!isWasmInitialized) {
16597 throw new Error("initializeWasm() must be awaited first!");
16599 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_set_update_id(this_ptr, val);
16600 // debug statements here
16602 // uintptr_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg);
16604 export function ChannelMonitorUpdate_clone_ptr(arg: number): number {
16605 if(!isWasmInitialized) {
16606 throw new Error("initializeWasm() must be awaited first!");
16608 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone_ptr(arg);
16609 return nativeResponseValue;
16611 // struct LDKChannelMonitorUpdate ChannelMonitorUpdate_clone(const struct LDKChannelMonitorUpdate *NONNULL_PTR orig);
16613 export function ChannelMonitorUpdate_clone(orig: number): number {
16614 if(!isWasmInitialized) {
16615 throw new Error("initializeWasm() must be awaited first!");
16617 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone(orig);
16618 return nativeResponseValue;
16620 // struct LDKCVec_u8Z ChannelMonitorUpdate_write(const struct LDKChannelMonitorUpdate *NONNULL_PTR obj);
16622 export function ChannelMonitorUpdate_write(obj: number): number {
16623 if(!isWasmInitialized) {
16624 throw new Error("initializeWasm() must be awaited first!");
16626 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_write(obj);
16627 return nativeResponseValue;
16629 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ ChannelMonitorUpdate_read(struct LDKu8slice ser);
16631 export function ChannelMonitorUpdate_read(ser: number): number {
16632 if(!isWasmInitialized) {
16633 throw new Error("initializeWasm() must be awaited first!");
16635 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_read(ser);
16636 return nativeResponseValue;
16638 // void MonitorEvent_free(struct LDKMonitorEvent this_ptr);
16640 export function MonitorEvent_free(this_ptr: number): void {
16641 if(!isWasmInitialized) {
16642 throw new Error("initializeWasm() must be awaited first!");
16644 const nativeResponseValue = wasm.TS_MonitorEvent_free(this_ptr);
16645 // debug statements here
16647 // uintptr_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg);
16649 export function MonitorEvent_clone_ptr(arg: number): number {
16650 if(!isWasmInitialized) {
16651 throw new Error("initializeWasm() must be awaited first!");
16653 const nativeResponseValue = wasm.TS_MonitorEvent_clone_ptr(arg);
16654 return nativeResponseValue;
16656 // struct LDKMonitorEvent MonitorEvent_clone(const struct LDKMonitorEvent *NONNULL_PTR orig);
16658 export function MonitorEvent_clone(orig: number): number {
16659 if(!isWasmInitialized) {
16660 throw new Error("initializeWasm() must be awaited first!");
16662 const nativeResponseValue = wasm.TS_MonitorEvent_clone(orig);
16663 return nativeResponseValue;
16665 // struct LDKMonitorEvent MonitorEvent_htlcevent(struct LDKHTLCUpdate a);
16667 export function MonitorEvent_htlcevent(a: number): number {
16668 if(!isWasmInitialized) {
16669 throw new Error("initializeWasm() must be awaited first!");
16671 const nativeResponseValue = wasm.TS_MonitorEvent_htlcevent(a);
16672 return nativeResponseValue;
16674 // struct LDKMonitorEvent MonitorEvent_commitment_tx_confirmed(struct LDKOutPoint a);
16676 export function MonitorEvent_commitment_tx_confirmed(a: number): number {
16677 if(!isWasmInitialized) {
16678 throw new Error("initializeWasm() must be awaited first!");
16680 const nativeResponseValue = wasm.TS_MonitorEvent_commitment_tx_confirmed(a);
16681 return nativeResponseValue;
16683 // struct LDKMonitorEvent MonitorEvent_update_completed(struct LDKOutPoint funding_txo, uint64_t monitor_update_id);
16685 export function MonitorEvent_update_completed(funding_txo: number, monitor_update_id: bigint): number {
16686 if(!isWasmInitialized) {
16687 throw new Error("initializeWasm() must be awaited first!");
16689 const nativeResponseValue = wasm.TS_MonitorEvent_update_completed(funding_txo, monitor_update_id);
16690 return nativeResponseValue;
16692 // struct LDKMonitorEvent MonitorEvent_update_failed(struct LDKOutPoint a);
16694 export function MonitorEvent_update_failed(a: number): number {
16695 if(!isWasmInitialized) {
16696 throw new Error("initializeWasm() must be awaited first!");
16698 const nativeResponseValue = wasm.TS_MonitorEvent_update_failed(a);
16699 return nativeResponseValue;
16701 // struct LDKCVec_u8Z MonitorEvent_write(const struct LDKMonitorEvent *NONNULL_PTR obj);
16703 export function MonitorEvent_write(obj: number): number {
16704 if(!isWasmInitialized) {
16705 throw new Error("initializeWasm() must be awaited first!");
16707 const nativeResponseValue = wasm.TS_MonitorEvent_write(obj);
16708 return nativeResponseValue;
16710 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ MonitorEvent_read(struct LDKu8slice ser);
16712 export function MonitorEvent_read(ser: number): number {
16713 if(!isWasmInitialized) {
16714 throw new Error("initializeWasm() must be awaited first!");
16716 const nativeResponseValue = wasm.TS_MonitorEvent_read(ser);
16717 return nativeResponseValue;
16719 // void HTLCUpdate_free(struct LDKHTLCUpdate this_obj);
16721 export function HTLCUpdate_free(this_obj: number): void {
16722 if(!isWasmInitialized) {
16723 throw new Error("initializeWasm() must be awaited first!");
16725 const nativeResponseValue = wasm.TS_HTLCUpdate_free(this_obj);
16726 // debug statements here
16728 // uintptr_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg);
16730 export function HTLCUpdate_clone_ptr(arg: number): number {
16731 if(!isWasmInitialized) {
16732 throw new Error("initializeWasm() must be awaited first!");
16734 const nativeResponseValue = wasm.TS_HTLCUpdate_clone_ptr(arg);
16735 return nativeResponseValue;
16737 // struct LDKHTLCUpdate HTLCUpdate_clone(const struct LDKHTLCUpdate *NONNULL_PTR orig);
16739 export function HTLCUpdate_clone(orig: number): number {
16740 if(!isWasmInitialized) {
16741 throw new Error("initializeWasm() must be awaited first!");
16743 const nativeResponseValue = wasm.TS_HTLCUpdate_clone(orig);
16744 return nativeResponseValue;
16746 // struct LDKCVec_u8Z HTLCUpdate_write(const struct LDKHTLCUpdate *NONNULL_PTR obj);
16748 export function HTLCUpdate_write(obj: number): number {
16749 if(!isWasmInitialized) {
16750 throw new Error("initializeWasm() must be awaited first!");
16752 const nativeResponseValue = wasm.TS_HTLCUpdate_write(obj);
16753 return nativeResponseValue;
16755 // struct LDKCResult_HTLCUpdateDecodeErrorZ HTLCUpdate_read(struct LDKu8slice ser);
16757 export function HTLCUpdate_read(ser: number): number {
16758 if(!isWasmInitialized) {
16759 throw new Error("initializeWasm() must be awaited first!");
16761 const nativeResponseValue = wasm.TS_HTLCUpdate_read(ser);
16762 return nativeResponseValue;
16764 // void Balance_free(struct LDKBalance this_ptr);
16766 export function Balance_free(this_ptr: number): void {
16767 if(!isWasmInitialized) {
16768 throw new Error("initializeWasm() must be awaited first!");
16770 const nativeResponseValue = wasm.TS_Balance_free(this_ptr);
16771 // debug statements here
16773 // uintptr_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg);
16775 export function Balance_clone_ptr(arg: number): number {
16776 if(!isWasmInitialized) {
16777 throw new Error("initializeWasm() must be awaited first!");
16779 const nativeResponseValue = wasm.TS_Balance_clone_ptr(arg);
16780 return nativeResponseValue;
16782 // struct LDKBalance Balance_clone(const struct LDKBalance *NONNULL_PTR orig);
16784 export function Balance_clone(orig: number): number {
16785 if(!isWasmInitialized) {
16786 throw new Error("initializeWasm() must be awaited first!");
16788 const nativeResponseValue = wasm.TS_Balance_clone(orig);
16789 return nativeResponseValue;
16791 // struct LDKBalance Balance_claimable_on_channel_close(uint64_t claimable_amount_satoshis);
16793 export function Balance_claimable_on_channel_close(claimable_amount_satoshis: bigint): number {
16794 if(!isWasmInitialized) {
16795 throw new Error("initializeWasm() must be awaited first!");
16797 const nativeResponseValue = wasm.TS_Balance_claimable_on_channel_close(claimable_amount_satoshis);
16798 return nativeResponseValue;
16800 // struct LDKBalance Balance_claimable_awaiting_confirmations(uint64_t claimable_amount_satoshis, uint32_t confirmation_height);
16802 export function Balance_claimable_awaiting_confirmations(claimable_amount_satoshis: bigint, confirmation_height: number): number {
16803 if(!isWasmInitialized) {
16804 throw new Error("initializeWasm() must be awaited first!");
16806 const nativeResponseValue = wasm.TS_Balance_claimable_awaiting_confirmations(claimable_amount_satoshis, confirmation_height);
16807 return nativeResponseValue;
16809 // struct LDKBalance Balance_contentious_claimable(uint64_t claimable_amount_satoshis, uint32_t timeout_height);
16811 export function Balance_contentious_claimable(claimable_amount_satoshis: bigint, timeout_height: number): number {
16812 if(!isWasmInitialized) {
16813 throw new Error("initializeWasm() must be awaited first!");
16815 const nativeResponseValue = wasm.TS_Balance_contentious_claimable(claimable_amount_satoshis, timeout_height);
16816 return nativeResponseValue;
16818 // struct LDKBalance Balance_maybe_claimable_htlcawaiting_timeout(uint64_t claimable_amount_satoshis, uint32_t claimable_height);
16820 export function Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis: bigint, claimable_height: number): number {
16821 if(!isWasmInitialized) {
16822 throw new Error("initializeWasm() must be awaited first!");
16824 const nativeResponseValue = wasm.TS_Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis, claimable_height);
16825 return nativeResponseValue;
16827 // bool Balance_eq(const struct LDKBalance *NONNULL_PTR a, const struct LDKBalance *NONNULL_PTR b);
16829 export function Balance_eq(a: number, b: number): boolean {
16830 if(!isWasmInitialized) {
16831 throw new Error("initializeWasm() must be awaited first!");
16833 const nativeResponseValue = wasm.TS_Balance_eq(a, b);
16834 return nativeResponseValue;
16836 // void ChannelMonitor_free(struct LDKChannelMonitor this_obj);
16838 export function ChannelMonitor_free(this_obj: number): void {
16839 if(!isWasmInitialized) {
16840 throw new Error("initializeWasm() must be awaited first!");
16842 const nativeResponseValue = wasm.TS_ChannelMonitor_free(this_obj);
16843 // debug statements here
16845 // uintptr_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg);
16847 export function ChannelMonitor_clone_ptr(arg: number): number {
16848 if(!isWasmInitialized) {
16849 throw new Error("initializeWasm() must be awaited first!");
16851 const nativeResponseValue = wasm.TS_ChannelMonitor_clone_ptr(arg);
16852 return nativeResponseValue;
16854 // struct LDKChannelMonitor ChannelMonitor_clone(const struct LDKChannelMonitor *NONNULL_PTR orig);
16856 export function ChannelMonitor_clone(orig: number): number {
16857 if(!isWasmInitialized) {
16858 throw new Error("initializeWasm() must be awaited first!");
16860 const nativeResponseValue = wasm.TS_ChannelMonitor_clone(orig);
16861 return nativeResponseValue;
16863 // struct LDKCVec_u8Z ChannelMonitor_write(const struct LDKChannelMonitor *NONNULL_PTR obj);
16865 export function ChannelMonitor_write(obj: number): number {
16866 if(!isWasmInitialized) {
16867 throw new Error("initializeWasm() must be awaited first!");
16869 const nativeResponseValue = wasm.TS_ChannelMonitor_write(obj);
16870 return nativeResponseValue;
16872 // 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);
16874 export function ChannelMonitor_update_monitor(this_arg: number, updates: 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_update_monitor(this_arg, updates, broadcaster, fee_estimator, logger);
16879 return nativeResponseValue;
16881 // MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
16883 export function ChannelMonitor_get_latest_update_id(this_arg: number): bigint {
16884 if(!isWasmInitialized) {
16885 throw new Error("initializeWasm() must be awaited first!");
16887 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_update_id(this_arg);
16888 return nativeResponseValue;
16890 // MUST_USE_RES struct LDKC2Tuple_OutPointScriptZ ChannelMonitor_get_funding_txo(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
16892 export function ChannelMonitor_get_funding_txo(this_arg: number): number {
16893 if(!isWasmInitialized) {
16894 throw new Error("initializeWasm() must be awaited first!");
16896 const nativeResponseValue = wasm.TS_ChannelMonitor_get_funding_txo(this_arg);
16897 return nativeResponseValue;
16899 // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ChannelMonitor_get_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
16901 export function ChannelMonitor_get_outputs_to_watch(this_arg: number): number {
16902 if(!isWasmInitialized) {
16903 throw new Error("initializeWasm() must be awaited first!");
16905 const nativeResponseValue = wasm.TS_ChannelMonitor_get_outputs_to_watch(this_arg);
16906 return nativeResponseValue;
16908 // void ChannelMonitor_load_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKFilter *NONNULL_PTR filter);
16910 export function ChannelMonitor_load_outputs_to_watch(this_arg: number, filter: number): void {
16911 if(!isWasmInitialized) {
16912 throw new Error("initializeWasm() must be awaited first!");
16914 const nativeResponseValue = wasm.TS_ChannelMonitor_load_outputs_to_watch(this_arg, filter);
16915 // debug statements here
16917 // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
16919 export function ChannelMonitor_get_and_clear_pending_monitor_events(this_arg: number): number {
16920 if(!isWasmInitialized) {
16921 throw new Error("initializeWasm() must be awaited first!");
16923 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_monitor_events(this_arg);
16924 return nativeResponseValue;
16926 // MUST_USE_RES struct LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
16928 export function ChannelMonitor_get_and_clear_pending_events(this_arg: number): number {
16929 if(!isWasmInitialized) {
16930 throw new Error("initializeWasm() must be awaited first!");
16932 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_events(this_arg);
16933 return nativeResponseValue;
16935 // 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);
16937 export function ChannelMonitor_get_latest_holder_commitment_txn(this_arg: number, logger: number): number {
16938 if(!isWasmInitialized) {
16939 throw new Error("initializeWasm() must be awaited first!");
16941 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_holder_commitment_txn(this_arg, logger);
16942 return nativeResponseValue;
16944 // 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);
16946 export function ChannelMonitor_block_connected(this_arg: number, header: number, txdata: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
16947 if(!isWasmInitialized) {
16948 throw new Error("initializeWasm() must be awaited first!");
16950 const nativeResponseValue = wasm.TS_ChannelMonitor_block_connected(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
16951 return nativeResponseValue;
16953 // 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);
16955 export function ChannelMonitor_block_disconnected(this_arg: number, header: number, height: number, broadcaster: number, fee_estimator: number, logger: number): void {
16956 if(!isWasmInitialized) {
16957 throw new Error("initializeWasm() must be awaited first!");
16959 const nativeResponseValue = wasm.TS_ChannelMonitor_block_disconnected(this_arg, header, height, broadcaster, fee_estimator, logger);
16960 // debug statements here
16962 // 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);
16964 export function ChannelMonitor_transactions_confirmed(this_arg: number, header: number, txdata: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
16965 if(!isWasmInitialized) {
16966 throw new Error("initializeWasm() must be awaited first!");
16968 const nativeResponseValue = wasm.TS_ChannelMonitor_transactions_confirmed(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
16969 return nativeResponseValue;
16971 // 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);
16973 export function ChannelMonitor_transaction_unconfirmed(this_arg: number, txid: number, broadcaster: number, fee_estimator: number, logger: number): void {
16974 if(!isWasmInitialized) {
16975 throw new Error("initializeWasm() must be awaited first!");
16977 const nativeResponseValue = wasm.TS_ChannelMonitor_transaction_unconfirmed(this_arg, txid, broadcaster, fee_estimator, logger);
16978 // debug statements here
16980 // 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);
16982 export function ChannelMonitor_best_block_updated(this_arg: number, header: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
16983 if(!isWasmInitialized) {
16984 throw new Error("initializeWasm() must be awaited first!");
16986 const nativeResponseValue = wasm.TS_ChannelMonitor_best_block_updated(this_arg, header, height, broadcaster, fee_estimator, logger);
16987 return nativeResponseValue;
16989 // MUST_USE_RES struct LDKCVec_TxidZ ChannelMonitor_get_relevant_txids(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
16991 export function ChannelMonitor_get_relevant_txids(this_arg: number): number {
16992 if(!isWasmInitialized) {
16993 throw new Error("initializeWasm() must be awaited first!");
16995 const nativeResponseValue = wasm.TS_ChannelMonitor_get_relevant_txids(this_arg);
16996 return nativeResponseValue;
16998 // MUST_USE_RES struct LDKBestBlock ChannelMonitor_current_best_block(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17000 export function ChannelMonitor_current_best_block(this_arg: number): number {
17001 if(!isWasmInitialized) {
17002 throw new Error("initializeWasm() must be awaited first!");
17004 const nativeResponseValue = wasm.TS_ChannelMonitor_current_best_block(this_arg);
17005 return nativeResponseValue;
17007 // MUST_USE_RES struct LDKCVec_BalanceZ ChannelMonitor_get_claimable_balances(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17009 export function ChannelMonitor_get_claimable_balances(this_arg: number): number {
17010 if(!isWasmInitialized) {
17011 throw new Error("initializeWasm() must be awaited first!");
17013 const nativeResponseValue = wasm.TS_ChannelMonitor_get_claimable_balances(this_arg);
17014 return nativeResponseValue;
17016 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ C2Tuple_BlockHashChannelMonitorZ_read(struct LDKu8slice ser, const struct LDKKeysInterface *NONNULL_PTR arg);
17018 export function C2Tuple_BlockHashChannelMonitorZ_read(ser: number, arg: number): number {
17019 if(!isWasmInitialized) {
17020 throw new Error("initializeWasm() must be awaited first!");
17022 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_read(ser, arg);
17023 return nativeResponseValue;
17025 // void OutPoint_free(struct LDKOutPoint this_obj);
17027 export function OutPoint_free(this_obj: number): void {
17028 if(!isWasmInitialized) {
17029 throw new Error("initializeWasm() must be awaited first!");
17031 const nativeResponseValue = wasm.TS_OutPoint_free(this_obj);
17032 // debug statements here
17034 // const uint8_t (*OutPoint_get_txid(const struct LDKOutPoint *NONNULL_PTR this_ptr))[32];
17036 export function OutPoint_get_txid(this_ptr: number): number {
17037 if(!isWasmInitialized) {
17038 throw new Error("initializeWasm() must be awaited first!");
17040 const nativeResponseValue = wasm.TS_OutPoint_get_txid(this_ptr);
17041 return nativeResponseValue;
17043 // void OutPoint_set_txid(struct LDKOutPoint *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17045 export function OutPoint_set_txid(this_ptr: number, val: number): void {
17046 if(!isWasmInitialized) {
17047 throw new Error("initializeWasm() must be awaited first!");
17049 const nativeResponseValue = wasm.TS_OutPoint_set_txid(this_ptr, val);
17050 // debug statements here
17052 // uint16_t OutPoint_get_index(const struct LDKOutPoint *NONNULL_PTR this_ptr);
17054 export function OutPoint_get_index(this_ptr: number): number {
17055 if(!isWasmInitialized) {
17056 throw new Error("initializeWasm() must be awaited first!");
17058 const nativeResponseValue = wasm.TS_OutPoint_get_index(this_ptr);
17059 return nativeResponseValue;
17061 // void OutPoint_set_index(struct LDKOutPoint *NONNULL_PTR this_ptr, uint16_t val);
17063 export function OutPoint_set_index(this_ptr: number, val: number): void {
17064 if(!isWasmInitialized) {
17065 throw new Error("initializeWasm() must be awaited first!");
17067 const nativeResponseValue = wasm.TS_OutPoint_set_index(this_ptr, val);
17068 // debug statements here
17070 // MUST_USE_RES struct LDKOutPoint OutPoint_new(struct LDKThirtyTwoBytes txid_arg, uint16_t index_arg);
17072 export function OutPoint_new(txid_arg: number, index_arg: number): number {
17073 if(!isWasmInitialized) {
17074 throw new Error("initializeWasm() must be awaited first!");
17076 const nativeResponseValue = wasm.TS_OutPoint_new(txid_arg, index_arg);
17077 return nativeResponseValue;
17079 // uintptr_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg);
17081 export function OutPoint_clone_ptr(arg: number): number {
17082 if(!isWasmInitialized) {
17083 throw new Error("initializeWasm() must be awaited first!");
17085 const nativeResponseValue = wasm.TS_OutPoint_clone_ptr(arg);
17086 return nativeResponseValue;
17088 // struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig);
17090 export function OutPoint_clone(orig: number): number {
17091 if(!isWasmInitialized) {
17092 throw new Error("initializeWasm() must be awaited first!");
17094 const nativeResponseValue = wasm.TS_OutPoint_clone(orig);
17095 return nativeResponseValue;
17097 // bool OutPoint_eq(const struct LDKOutPoint *NONNULL_PTR a, const struct LDKOutPoint *NONNULL_PTR b);
17099 export function OutPoint_eq(a: number, b: number): boolean {
17100 if(!isWasmInitialized) {
17101 throw new Error("initializeWasm() must be awaited first!");
17103 const nativeResponseValue = wasm.TS_OutPoint_eq(a, b);
17104 return nativeResponseValue;
17106 // uint64_t OutPoint_hash(const struct LDKOutPoint *NONNULL_PTR o);
17108 export function OutPoint_hash(o: number): bigint {
17109 if(!isWasmInitialized) {
17110 throw new Error("initializeWasm() must be awaited first!");
17112 const nativeResponseValue = wasm.TS_OutPoint_hash(o);
17113 return nativeResponseValue;
17115 // MUST_USE_RES struct LDKThirtyTwoBytes OutPoint_to_channel_id(const struct LDKOutPoint *NONNULL_PTR this_arg);
17117 export function OutPoint_to_channel_id(this_arg: number): number {
17118 if(!isWasmInitialized) {
17119 throw new Error("initializeWasm() must be awaited first!");
17121 const nativeResponseValue = wasm.TS_OutPoint_to_channel_id(this_arg);
17122 return nativeResponseValue;
17124 // struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj);
17126 export function OutPoint_write(obj: number): number {
17127 if(!isWasmInitialized) {
17128 throw new Error("initializeWasm() must be awaited first!");
17130 const nativeResponseValue = wasm.TS_OutPoint_write(obj);
17131 return nativeResponseValue;
17133 // struct LDKCResult_OutPointDecodeErrorZ OutPoint_read(struct LDKu8slice ser);
17135 export function OutPoint_read(ser: number): number {
17136 if(!isWasmInitialized) {
17137 throw new Error("initializeWasm() must be awaited first!");
17139 const nativeResponseValue = wasm.TS_OutPoint_read(ser);
17140 return nativeResponseValue;
17142 // void DelayedPaymentOutputDescriptor_free(struct LDKDelayedPaymentOutputDescriptor this_obj);
17144 export function DelayedPaymentOutputDescriptor_free(this_obj: number): void {
17145 if(!isWasmInitialized) {
17146 throw new Error("initializeWasm() must be awaited first!");
17148 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_free(this_obj);
17149 // debug statements here
17151 // struct LDKOutPoint DelayedPaymentOutputDescriptor_get_outpoint(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17153 export function DelayedPaymentOutputDescriptor_get_outpoint(this_ptr: number): number {
17154 if(!isWasmInitialized) {
17155 throw new Error("initializeWasm() must be awaited first!");
17157 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_outpoint(this_ptr);
17158 return nativeResponseValue;
17160 // void DelayedPaymentOutputDescriptor_set_outpoint(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
17162 export function DelayedPaymentOutputDescriptor_set_outpoint(this_ptr: number, val: number): void {
17163 if(!isWasmInitialized) {
17164 throw new Error("initializeWasm() must be awaited first!");
17166 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_outpoint(this_ptr, val);
17167 // debug statements here
17169 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_per_commitment_point(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17171 export function DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr: number): number {
17172 if(!isWasmInitialized) {
17173 throw new Error("initializeWasm() must be awaited first!");
17175 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr);
17176 return nativeResponseValue;
17178 // void DelayedPaymentOutputDescriptor_set_per_commitment_point(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17180 export function DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr: number, val: number): void {
17181 if(!isWasmInitialized) {
17182 throw new Error("initializeWasm() must be awaited first!");
17184 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr, val);
17185 // debug statements here
17187 // uint16_t DelayedPaymentOutputDescriptor_get_to_self_delay(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17189 export function DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr: number): number {
17190 if(!isWasmInitialized) {
17191 throw new Error("initializeWasm() must be awaited first!");
17193 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr);
17194 return nativeResponseValue;
17196 // void DelayedPaymentOutputDescriptor_set_to_self_delay(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint16_t val);
17198 export function DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr: number, val: number): void {
17199 if(!isWasmInitialized) {
17200 throw new Error("initializeWasm() must be awaited first!");
17202 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr, val);
17203 // debug statements here
17205 // void DelayedPaymentOutputDescriptor_set_output(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
17207 export function DelayedPaymentOutputDescriptor_set_output(this_ptr: number, val: number): void {
17208 if(!isWasmInitialized) {
17209 throw new Error("initializeWasm() must be awaited first!");
17211 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_output(this_ptr, val);
17212 // debug statements here
17214 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_revocation_pubkey(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17216 export function DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr: number): number {
17217 if(!isWasmInitialized) {
17218 throw new Error("initializeWasm() must be awaited first!");
17220 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr);
17221 return nativeResponseValue;
17223 // void DelayedPaymentOutputDescriptor_set_revocation_pubkey(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17225 export function DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr: number, val: number): void {
17226 if(!isWasmInitialized) {
17227 throw new Error("initializeWasm() must be awaited first!");
17229 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr, val);
17230 // debug statements here
17232 // const uint8_t (*DelayedPaymentOutputDescriptor_get_channel_keys_id(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
17234 export function DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr: number): number {
17235 if(!isWasmInitialized) {
17236 throw new Error("initializeWasm() must be awaited first!");
17238 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
17239 return nativeResponseValue;
17241 // void DelayedPaymentOutputDescriptor_set_channel_keys_id(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17243 export function DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr: number, val: number): void {
17244 if(!isWasmInitialized) {
17245 throw new Error("initializeWasm() must be awaited first!");
17247 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
17248 // debug statements here
17250 // uint64_t DelayedPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17252 export function DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: number): bigint {
17253 if(!isWasmInitialized) {
17254 throw new Error("initializeWasm() must be awaited first!");
17256 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
17257 return nativeResponseValue;
17259 // void DelayedPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
17261 export function DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
17262 if(!isWasmInitialized) {
17263 throw new Error("initializeWasm() must be awaited first!");
17265 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
17266 // debug statements here
17268 // 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);
17270 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 {
17271 if(!isWasmInitialized) {
17272 throw new Error("initializeWasm() must be awaited first!");
17274 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);
17275 return nativeResponseValue;
17277 // uintptr_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg);
17279 export function DelayedPaymentOutputDescriptor_clone_ptr(arg: number): number {
17280 if(!isWasmInitialized) {
17281 throw new Error("initializeWasm() must be awaited first!");
17283 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone_ptr(arg);
17284 return nativeResponseValue;
17286 // struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_clone(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR orig);
17288 export function DelayedPaymentOutputDescriptor_clone(orig: number): number {
17289 if(!isWasmInitialized) {
17290 throw new Error("initializeWasm() must be awaited first!");
17292 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone(orig);
17293 return nativeResponseValue;
17295 // struct LDKCVec_u8Z DelayedPaymentOutputDescriptor_write(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR obj);
17297 export function DelayedPaymentOutputDescriptor_write(obj: number): number {
17298 if(!isWasmInitialized) {
17299 throw new Error("initializeWasm() must be awaited first!");
17301 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_write(obj);
17302 return nativeResponseValue;
17304 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ DelayedPaymentOutputDescriptor_read(struct LDKu8slice ser);
17306 export function DelayedPaymentOutputDescriptor_read(ser: number): number {
17307 if(!isWasmInitialized) {
17308 throw new Error("initializeWasm() must be awaited first!");
17310 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_read(ser);
17311 return nativeResponseValue;
17313 // void StaticPaymentOutputDescriptor_free(struct LDKStaticPaymentOutputDescriptor this_obj);
17315 export function StaticPaymentOutputDescriptor_free(this_obj: number): void {
17316 if(!isWasmInitialized) {
17317 throw new Error("initializeWasm() must be awaited first!");
17319 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_free(this_obj);
17320 // debug statements here
17322 // struct LDKOutPoint StaticPaymentOutputDescriptor_get_outpoint(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17324 export function StaticPaymentOutputDescriptor_get_outpoint(this_ptr: number): number {
17325 if(!isWasmInitialized) {
17326 throw new Error("initializeWasm() must be awaited first!");
17328 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_outpoint(this_ptr);
17329 return nativeResponseValue;
17331 // void StaticPaymentOutputDescriptor_set_outpoint(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
17333 export function StaticPaymentOutputDescriptor_set_outpoint(this_ptr: number, val: number): void {
17334 if(!isWasmInitialized) {
17335 throw new Error("initializeWasm() must be awaited first!");
17337 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_outpoint(this_ptr, val);
17338 // debug statements here
17340 // void StaticPaymentOutputDescriptor_set_output(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
17342 export function StaticPaymentOutputDescriptor_set_output(this_ptr: number, val: number): void {
17343 if(!isWasmInitialized) {
17344 throw new Error("initializeWasm() must be awaited first!");
17346 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_output(this_ptr, val);
17347 // debug statements here
17349 // const uint8_t (*StaticPaymentOutputDescriptor_get_channel_keys_id(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
17351 export function StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr: number): number {
17352 if(!isWasmInitialized) {
17353 throw new Error("initializeWasm() must be awaited first!");
17355 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
17356 return nativeResponseValue;
17358 // void StaticPaymentOutputDescriptor_set_channel_keys_id(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17360 export function StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr: number, val: number): void {
17361 if(!isWasmInitialized) {
17362 throw new Error("initializeWasm() must be awaited first!");
17364 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
17365 // debug statements here
17367 // uint64_t StaticPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17369 export function StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: number): bigint {
17370 if(!isWasmInitialized) {
17371 throw new Error("initializeWasm() must be awaited first!");
17373 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
17374 return nativeResponseValue;
17376 // void StaticPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
17378 export function StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
17379 if(!isWasmInitialized) {
17380 throw new Error("initializeWasm() must be awaited first!");
17382 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
17383 // debug statements here
17385 // 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);
17387 export function StaticPaymentOutputDescriptor_new(outpoint_arg: number, output_arg: number, channel_keys_id_arg: number, channel_value_satoshis_arg: bigint): number {
17388 if(!isWasmInitialized) {
17389 throw new Error("initializeWasm() must be awaited first!");
17391 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_new(outpoint_arg, output_arg, channel_keys_id_arg, channel_value_satoshis_arg);
17392 return nativeResponseValue;
17394 // uintptr_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg);
17396 export function StaticPaymentOutputDescriptor_clone_ptr(arg: number): number {
17397 if(!isWasmInitialized) {
17398 throw new Error("initializeWasm() must be awaited first!");
17400 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone_ptr(arg);
17401 return nativeResponseValue;
17403 // struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_clone(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR orig);
17405 export function StaticPaymentOutputDescriptor_clone(orig: number): number {
17406 if(!isWasmInitialized) {
17407 throw new Error("initializeWasm() must be awaited first!");
17409 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone(orig);
17410 return nativeResponseValue;
17412 // struct LDKCVec_u8Z StaticPaymentOutputDescriptor_write(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR obj);
17414 export function StaticPaymentOutputDescriptor_write(obj: number): number {
17415 if(!isWasmInitialized) {
17416 throw new Error("initializeWasm() must be awaited first!");
17418 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_write(obj);
17419 return nativeResponseValue;
17421 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ StaticPaymentOutputDescriptor_read(struct LDKu8slice ser);
17423 export function StaticPaymentOutputDescriptor_read(ser: number): number {
17424 if(!isWasmInitialized) {
17425 throw new Error("initializeWasm() must be awaited first!");
17427 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_read(ser);
17428 return nativeResponseValue;
17430 // void SpendableOutputDescriptor_free(struct LDKSpendableOutputDescriptor this_ptr);
17432 export function SpendableOutputDescriptor_free(this_ptr: number): void {
17433 if(!isWasmInitialized) {
17434 throw new Error("initializeWasm() must be awaited first!");
17436 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_free(this_ptr);
17437 // debug statements here
17439 // uintptr_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg);
17441 export function SpendableOutputDescriptor_clone_ptr(arg: number): number {
17442 if(!isWasmInitialized) {
17443 throw new Error("initializeWasm() must be awaited first!");
17445 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone_ptr(arg);
17446 return nativeResponseValue;
17448 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_clone(const struct LDKSpendableOutputDescriptor *NONNULL_PTR orig);
17450 export function SpendableOutputDescriptor_clone(orig: number): number {
17451 if(!isWasmInitialized) {
17452 throw new Error("initializeWasm() must be awaited first!");
17454 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone(orig);
17455 return nativeResponseValue;
17457 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_output(struct LDKOutPoint outpoint, struct LDKTxOut output);
17459 export function SpendableOutputDescriptor_static_output(outpoint: number, output: number): number {
17460 if(!isWasmInitialized) {
17461 throw new Error("initializeWasm() must be awaited first!");
17463 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_output(outpoint, output);
17464 return nativeResponseValue;
17466 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_delayed_payment_output(struct LDKDelayedPaymentOutputDescriptor a);
17468 export function SpendableOutputDescriptor_delayed_payment_output(a: number): number {
17469 if(!isWasmInitialized) {
17470 throw new Error("initializeWasm() must be awaited first!");
17472 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_delayed_payment_output(a);
17473 return nativeResponseValue;
17475 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_payment_output(struct LDKStaticPaymentOutputDescriptor a);
17477 export function SpendableOutputDescriptor_static_payment_output(a: number): number {
17478 if(!isWasmInitialized) {
17479 throw new Error("initializeWasm() must be awaited first!");
17481 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_payment_output(a);
17482 return nativeResponseValue;
17484 // struct LDKCVec_u8Z SpendableOutputDescriptor_write(const struct LDKSpendableOutputDescriptor *NONNULL_PTR obj);
17486 export function SpendableOutputDescriptor_write(obj: number): number {
17487 if(!isWasmInitialized) {
17488 throw new Error("initializeWasm() must be awaited first!");
17490 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_write(obj);
17491 return nativeResponseValue;
17493 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ SpendableOutputDescriptor_read(struct LDKu8slice ser);
17495 export function SpendableOutputDescriptor_read(ser: number): number {
17496 if(!isWasmInitialized) {
17497 throw new Error("initializeWasm() must be awaited first!");
17499 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_read(ser);
17500 return nativeResponseValue;
17502 // void BaseSign_free(struct LDKBaseSign this_ptr);
17504 export function BaseSign_free(this_ptr: number): void {
17505 if(!isWasmInitialized) {
17506 throw new Error("initializeWasm() must be awaited first!");
17508 const nativeResponseValue = wasm.TS_BaseSign_free(this_ptr);
17509 // debug statements here
17511 // uintptr_t Sign_clone_ptr(LDKSign *NONNULL_PTR arg);
17513 export function Sign_clone_ptr(arg: number): number {
17514 if(!isWasmInitialized) {
17515 throw new Error("initializeWasm() must be awaited first!");
17517 const nativeResponseValue = wasm.TS_Sign_clone_ptr(arg);
17518 return nativeResponseValue;
17520 // struct LDKSign Sign_clone(const struct LDKSign *NONNULL_PTR orig);
17522 export function Sign_clone(orig: number): number {
17523 if(!isWasmInitialized) {
17524 throw new Error("initializeWasm() must be awaited first!");
17526 const nativeResponseValue = wasm.TS_Sign_clone(orig);
17527 return nativeResponseValue;
17529 // void Sign_free(struct LDKSign this_ptr);
17531 export function Sign_free(this_ptr: number): void {
17532 if(!isWasmInitialized) {
17533 throw new Error("initializeWasm() must be awaited first!");
17535 const nativeResponseValue = wasm.TS_Sign_free(this_ptr);
17536 // debug statements here
17538 // enum LDKRecipient Recipient_clone(const enum LDKRecipient *NONNULL_PTR orig);
17540 export function Recipient_clone(orig: number): Recipient {
17541 if(!isWasmInitialized) {
17542 throw new Error("initializeWasm() must be awaited first!");
17544 const nativeResponseValue = wasm.TS_Recipient_clone(orig);
17545 return nativeResponseValue;
17547 // enum LDKRecipient Recipient_node(void);
17549 export function Recipient_node(): Recipient {
17550 if(!isWasmInitialized) {
17551 throw new Error("initializeWasm() must be awaited first!");
17553 const nativeResponseValue = wasm.TS_Recipient_node();
17554 return nativeResponseValue;
17556 // enum LDKRecipient Recipient_phantom_node(void);
17558 export function Recipient_phantom_node(): Recipient {
17559 if(!isWasmInitialized) {
17560 throw new Error("initializeWasm() must be awaited first!");
17562 const nativeResponseValue = wasm.TS_Recipient_phantom_node();
17563 return nativeResponseValue;
17565 // void KeysInterface_free(struct LDKKeysInterface this_ptr);
17567 export function KeysInterface_free(this_ptr: number): void {
17568 if(!isWasmInitialized) {
17569 throw new Error("initializeWasm() must be awaited first!");
17571 const nativeResponseValue = wasm.TS_KeysInterface_free(this_ptr);
17572 // debug statements here
17574 // void InMemorySigner_free(struct LDKInMemorySigner this_obj);
17576 export function InMemorySigner_free(this_obj: number): void {
17577 if(!isWasmInitialized) {
17578 throw new Error("initializeWasm() must be awaited first!");
17580 const nativeResponseValue = wasm.TS_InMemorySigner_free(this_obj);
17581 // debug statements here
17583 // const uint8_t (*InMemorySigner_get_funding_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
17585 export function InMemorySigner_get_funding_key(this_ptr: number): number {
17586 if(!isWasmInitialized) {
17587 throw new Error("initializeWasm() must be awaited first!");
17589 const nativeResponseValue = wasm.TS_InMemorySigner_get_funding_key(this_ptr);
17590 return nativeResponseValue;
17592 // void InMemorySigner_set_funding_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
17594 export function InMemorySigner_set_funding_key(this_ptr: number, val: number): void {
17595 if(!isWasmInitialized) {
17596 throw new Error("initializeWasm() must be awaited first!");
17598 const nativeResponseValue = wasm.TS_InMemorySigner_set_funding_key(this_ptr, val);
17599 // debug statements here
17601 // const uint8_t (*InMemorySigner_get_revocation_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
17603 export function InMemorySigner_get_revocation_base_key(this_ptr: number): number {
17604 if(!isWasmInitialized) {
17605 throw new Error("initializeWasm() must be awaited first!");
17607 const nativeResponseValue = wasm.TS_InMemorySigner_get_revocation_base_key(this_ptr);
17608 return nativeResponseValue;
17610 // void InMemorySigner_set_revocation_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
17612 export function InMemorySigner_set_revocation_base_key(this_ptr: number, val: number): void {
17613 if(!isWasmInitialized) {
17614 throw new Error("initializeWasm() must be awaited first!");
17616 const nativeResponseValue = wasm.TS_InMemorySigner_set_revocation_base_key(this_ptr, val);
17617 // debug statements here
17619 // const uint8_t (*InMemorySigner_get_payment_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
17621 export function InMemorySigner_get_payment_key(this_ptr: number): number {
17622 if(!isWasmInitialized) {
17623 throw new Error("initializeWasm() must be awaited first!");
17625 const nativeResponseValue = wasm.TS_InMemorySigner_get_payment_key(this_ptr);
17626 return nativeResponseValue;
17628 // void InMemorySigner_set_payment_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
17630 export function InMemorySigner_set_payment_key(this_ptr: number, val: number): void {
17631 if(!isWasmInitialized) {
17632 throw new Error("initializeWasm() must be awaited first!");
17634 const nativeResponseValue = wasm.TS_InMemorySigner_set_payment_key(this_ptr, val);
17635 // debug statements here
17637 // const uint8_t (*InMemorySigner_get_delayed_payment_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
17639 export function InMemorySigner_get_delayed_payment_base_key(this_ptr: number): number {
17640 if(!isWasmInitialized) {
17641 throw new Error("initializeWasm() must be awaited first!");
17643 const nativeResponseValue = wasm.TS_InMemorySigner_get_delayed_payment_base_key(this_ptr);
17644 return nativeResponseValue;
17646 // void InMemorySigner_set_delayed_payment_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
17648 export function InMemorySigner_set_delayed_payment_base_key(this_ptr: number, val: number): void {
17649 if(!isWasmInitialized) {
17650 throw new Error("initializeWasm() must be awaited first!");
17652 const nativeResponseValue = wasm.TS_InMemorySigner_set_delayed_payment_base_key(this_ptr, val);
17653 // debug statements here
17655 // const uint8_t (*InMemorySigner_get_htlc_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
17657 export function InMemorySigner_get_htlc_base_key(this_ptr: number): number {
17658 if(!isWasmInitialized) {
17659 throw new Error("initializeWasm() must be awaited first!");
17661 const nativeResponseValue = wasm.TS_InMemorySigner_get_htlc_base_key(this_ptr);
17662 return nativeResponseValue;
17664 // void InMemorySigner_set_htlc_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
17666 export function InMemorySigner_set_htlc_base_key(this_ptr: number, val: number): void {
17667 if(!isWasmInitialized) {
17668 throw new Error("initializeWasm() must be awaited first!");
17670 const nativeResponseValue = wasm.TS_InMemorySigner_set_htlc_base_key(this_ptr, val);
17671 // debug statements here
17673 // const uint8_t (*InMemorySigner_get_commitment_seed(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
17675 export function InMemorySigner_get_commitment_seed(this_ptr: number): number {
17676 if(!isWasmInitialized) {
17677 throw new Error("initializeWasm() must be awaited first!");
17679 const nativeResponseValue = wasm.TS_InMemorySigner_get_commitment_seed(this_ptr);
17680 return nativeResponseValue;
17682 // void InMemorySigner_set_commitment_seed(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17684 export function InMemorySigner_set_commitment_seed(this_ptr: number, val: number): void {
17685 if(!isWasmInitialized) {
17686 throw new Error("initializeWasm() must be awaited first!");
17688 const nativeResponseValue = wasm.TS_InMemorySigner_set_commitment_seed(this_ptr, val);
17689 // debug statements here
17691 // uintptr_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg);
17693 export function InMemorySigner_clone_ptr(arg: number): number {
17694 if(!isWasmInitialized) {
17695 throw new Error("initializeWasm() must be awaited first!");
17697 const nativeResponseValue = wasm.TS_InMemorySigner_clone_ptr(arg);
17698 return nativeResponseValue;
17700 // struct LDKInMemorySigner InMemorySigner_clone(const struct LDKInMemorySigner *NONNULL_PTR orig);
17702 export function InMemorySigner_clone(orig: number): number {
17703 if(!isWasmInitialized) {
17704 throw new Error("initializeWasm() must be awaited first!");
17706 const nativeResponseValue = wasm.TS_InMemorySigner_clone(orig);
17707 return nativeResponseValue;
17709 // 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);
17711 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 {
17712 if(!isWasmInitialized) {
17713 throw new Error("initializeWasm() must be awaited first!");
17715 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);
17716 return nativeResponseValue;
17718 // MUST_USE_RES struct LDKChannelPublicKeys InMemorySigner_counterparty_pubkeys(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
17720 export function InMemorySigner_counterparty_pubkeys(this_arg: number): number {
17721 if(!isWasmInitialized) {
17722 throw new Error("initializeWasm() must be awaited first!");
17724 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_pubkeys(this_arg);
17725 return nativeResponseValue;
17727 // MUST_USE_RES uint16_t InMemorySigner_counterparty_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
17729 export function InMemorySigner_counterparty_selected_contest_delay(this_arg: number): number {
17730 if(!isWasmInitialized) {
17731 throw new Error("initializeWasm() must be awaited first!");
17733 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_selected_contest_delay(this_arg);
17734 return nativeResponseValue;
17736 // MUST_USE_RES uint16_t InMemorySigner_holder_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
17738 export function InMemorySigner_holder_selected_contest_delay(this_arg: number): number {
17739 if(!isWasmInitialized) {
17740 throw new Error("initializeWasm() must be awaited first!");
17742 const nativeResponseValue = wasm.TS_InMemorySigner_holder_selected_contest_delay(this_arg);
17743 return nativeResponseValue;
17745 // MUST_USE_RES bool InMemorySigner_is_outbound(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
17747 export function InMemorySigner_is_outbound(this_arg: number): boolean {
17748 if(!isWasmInitialized) {
17749 throw new Error("initializeWasm() must be awaited first!");
17751 const nativeResponseValue = wasm.TS_InMemorySigner_is_outbound(this_arg);
17752 return nativeResponseValue;
17754 // MUST_USE_RES struct LDKOutPoint InMemorySigner_funding_outpoint(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
17756 export function InMemorySigner_funding_outpoint(this_arg: number): number {
17757 if(!isWasmInitialized) {
17758 throw new Error("initializeWasm() must be awaited first!");
17760 const nativeResponseValue = wasm.TS_InMemorySigner_funding_outpoint(this_arg);
17761 return nativeResponseValue;
17763 // MUST_USE_RES struct LDKChannelTransactionParameters InMemorySigner_get_channel_parameters(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
17765 export function InMemorySigner_get_channel_parameters(this_arg: number): number {
17766 if(!isWasmInitialized) {
17767 throw new Error("initializeWasm() must be awaited first!");
17769 const nativeResponseValue = wasm.TS_InMemorySigner_get_channel_parameters(this_arg);
17770 return nativeResponseValue;
17772 // MUST_USE_RES bool InMemorySigner_opt_anchors(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
17774 export function InMemorySigner_opt_anchors(this_arg: number): boolean {
17775 if(!isWasmInitialized) {
17776 throw new Error("initializeWasm() must be awaited first!");
17778 const nativeResponseValue = wasm.TS_InMemorySigner_opt_anchors(this_arg);
17779 return nativeResponseValue;
17781 // 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);
17783 export function InMemorySigner_sign_counterparty_payment_input(this_arg: number, spend_tx: number, input_idx: number, descriptor: number): number {
17784 if(!isWasmInitialized) {
17785 throw new Error("initializeWasm() must be awaited first!");
17787 const nativeResponseValue = wasm.TS_InMemorySigner_sign_counterparty_payment_input(this_arg, spend_tx, input_idx, descriptor);
17788 return nativeResponseValue;
17790 // 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);
17792 export function InMemorySigner_sign_dynamic_p2wsh_input(this_arg: number, spend_tx: number, input_idx: number, descriptor: number): number {
17793 if(!isWasmInitialized) {
17794 throw new Error("initializeWasm() must be awaited first!");
17796 const nativeResponseValue = wasm.TS_InMemorySigner_sign_dynamic_p2wsh_input(this_arg, spend_tx, input_idx, descriptor);
17797 return nativeResponseValue;
17799 // struct LDKBaseSign InMemorySigner_as_BaseSign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
17801 export function InMemorySigner_as_BaseSign(this_arg: number): number {
17802 if(!isWasmInitialized) {
17803 throw new Error("initializeWasm() must be awaited first!");
17805 const nativeResponseValue = wasm.TS_InMemorySigner_as_BaseSign(this_arg);
17806 return nativeResponseValue;
17808 // struct LDKSign InMemorySigner_as_Sign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
17810 export function InMemorySigner_as_Sign(this_arg: number): number {
17811 if(!isWasmInitialized) {
17812 throw new Error("initializeWasm() must be awaited first!");
17814 const nativeResponseValue = wasm.TS_InMemorySigner_as_Sign(this_arg);
17815 return nativeResponseValue;
17817 // struct LDKCVec_u8Z InMemorySigner_write(const struct LDKInMemorySigner *NONNULL_PTR obj);
17819 export function InMemorySigner_write(obj: number): number {
17820 if(!isWasmInitialized) {
17821 throw new Error("initializeWasm() must be awaited first!");
17823 const nativeResponseValue = wasm.TS_InMemorySigner_write(obj);
17824 return nativeResponseValue;
17826 // struct LDKCResult_InMemorySignerDecodeErrorZ InMemorySigner_read(struct LDKu8slice ser, struct LDKSecretKey arg);
17828 export function InMemorySigner_read(ser: number, arg: number): number {
17829 if(!isWasmInitialized) {
17830 throw new Error("initializeWasm() must be awaited first!");
17832 const nativeResponseValue = wasm.TS_InMemorySigner_read(ser, arg);
17833 return nativeResponseValue;
17835 // void KeysManager_free(struct LDKKeysManager this_obj);
17837 export function KeysManager_free(this_obj: number): void {
17838 if(!isWasmInitialized) {
17839 throw new Error("initializeWasm() must be awaited first!");
17841 const nativeResponseValue = wasm.TS_KeysManager_free(this_obj);
17842 // debug statements here
17844 // MUST_USE_RES struct LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], uint64_t starting_time_secs, uint32_t starting_time_nanos);
17846 export function KeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number): number {
17847 if(!isWasmInitialized) {
17848 throw new Error("initializeWasm() must be awaited first!");
17850 const nativeResponseValue = wasm.TS_KeysManager_new(seed, starting_time_secs, starting_time_nanos);
17851 return nativeResponseValue;
17853 // 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]);
17855 export function KeysManager_derive_channel_keys(this_arg: number, channel_value_satoshis: bigint, params: number): number {
17856 if(!isWasmInitialized) {
17857 throw new Error("initializeWasm() must be awaited first!");
17859 const nativeResponseValue = wasm.TS_KeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
17860 return nativeResponseValue;
17862 // 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);
17864 export function KeysManager_spend_spendable_outputs(this_arg: number, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): number {
17865 if(!isWasmInitialized) {
17866 throw new Error("initializeWasm() must be awaited first!");
17868 const nativeResponseValue = wasm.TS_KeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
17869 return nativeResponseValue;
17871 // struct LDKKeysInterface KeysManager_as_KeysInterface(const struct LDKKeysManager *NONNULL_PTR this_arg);
17873 export function KeysManager_as_KeysInterface(this_arg: number): number {
17874 if(!isWasmInitialized) {
17875 throw new Error("initializeWasm() must be awaited first!");
17877 const nativeResponseValue = wasm.TS_KeysManager_as_KeysInterface(this_arg);
17878 return nativeResponseValue;
17880 // void PhantomKeysManager_free(struct LDKPhantomKeysManager this_obj);
17882 export function PhantomKeysManager_free(this_obj: number): void {
17883 if(!isWasmInitialized) {
17884 throw new Error("initializeWasm() must be awaited first!");
17886 const nativeResponseValue = wasm.TS_PhantomKeysManager_free(this_obj);
17887 // debug statements here
17889 // struct LDKKeysInterface PhantomKeysManager_as_KeysInterface(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
17891 export function PhantomKeysManager_as_KeysInterface(this_arg: number): number {
17892 if(!isWasmInitialized) {
17893 throw new Error("initializeWasm() must be awaited first!");
17895 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_KeysInterface(this_arg);
17896 return nativeResponseValue;
17898 // 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]);
17900 export function PhantomKeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number, cross_node_seed: number): number {
17901 if(!isWasmInitialized) {
17902 throw new Error("initializeWasm() must be awaited first!");
17904 const nativeResponseValue = wasm.TS_PhantomKeysManager_new(seed, starting_time_secs, starting_time_nanos, cross_node_seed);
17905 return nativeResponseValue;
17907 // 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);
17909 export function PhantomKeysManager_spend_spendable_outputs(this_arg: number, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): number {
17910 if(!isWasmInitialized) {
17911 throw new Error("initializeWasm() must be awaited first!");
17913 const nativeResponseValue = wasm.TS_PhantomKeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
17914 return nativeResponseValue;
17916 // 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]);
17918 export function PhantomKeysManager_derive_channel_keys(this_arg: number, channel_value_satoshis: bigint, params: number): number {
17919 if(!isWasmInitialized) {
17920 throw new Error("initializeWasm() must be awaited first!");
17922 const nativeResponseValue = wasm.TS_PhantomKeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
17923 return nativeResponseValue;
17925 // void ChannelManager_free(struct LDKChannelManager this_obj);
17927 export function ChannelManager_free(this_obj: number): void {
17928 if(!isWasmInitialized) {
17929 throw new Error("initializeWasm() must be awaited first!");
17931 const nativeResponseValue = wasm.TS_ChannelManager_free(this_obj);
17932 // debug statements here
17934 // void ChainParameters_free(struct LDKChainParameters this_obj);
17936 export function ChainParameters_free(this_obj: number): void {
17937 if(!isWasmInitialized) {
17938 throw new Error("initializeWasm() must be awaited first!");
17940 const nativeResponseValue = wasm.TS_ChainParameters_free(this_obj);
17941 // debug statements here
17943 // enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr);
17945 export function ChainParameters_get_network(this_ptr: number): Network {
17946 if(!isWasmInitialized) {
17947 throw new Error("initializeWasm() must be awaited first!");
17949 const nativeResponseValue = wasm.TS_ChainParameters_get_network(this_ptr);
17950 return nativeResponseValue;
17952 // void ChainParameters_set_network(struct LDKChainParameters *NONNULL_PTR this_ptr, enum LDKNetwork val);
17954 export function ChainParameters_set_network(this_ptr: number, val: Network): void {
17955 if(!isWasmInitialized) {
17956 throw new Error("initializeWasm() must be awaited first!");
17958 const nativeResponseValue = wasm.TS_ChainParameters_set_network(this_ptr, val);
17959 // debug statements here
17961 // struct LDKBestBlock ChainParameters_get_best_block(const struct LDKChainParameters *NONNULL_PTR this_ptr);
17963 export function ChainParameters_get_best_block(this_ptr: number): number {
17964 if(!isWasmInitialized) {
17965 throw new Error("initializeWasm() must be awaited first!");
17967 const nativeResponseValue = wasm.TS_ChainParameters_get_best_block(this_ptr);
17968 return nativeResponseValue;
17970 // void ChainParameters_set_best_block(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKBestBlock val);
17972 export function ChainParameters_set_best_block(this_ptr: number, val: number): void {
17973 if(!isWasmInitialized) {
17974 throw new Error("initializeWasm() must be awaited first!");
17976 const nativeResponseValue = wasm.TS_ChainParameters_set_best_block(this_ptr, val);
17977 // debug statements here
17979 // MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKBestBlock best_block_arg);
17981 export function ChainParameters_new(network_arg: Network, best_block_arg: number): number {
17982 if(!isWasmInitialized) {
17983 throw new Error("initializeWasm() must be awaited first!");
17985 const nativeResponseValue = wasm.TS_ChainParameters_new(network_arg, best_block_arg);
17986 return nativeResponseValue;
17988 // uintptr_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg);
17990 export function ChainParameters_clone_ptr(arg: number): number {
17991 if(!isWasmInitialized) {
17992 throw new Error("initializeWasm() must be awaited first!");
17994 const nativeResponseValue = wasm.TS_ChainParameters_clone_ptr(arg);
17995 return nativeResponseValue;
17997 // struct LDKChainParameters ChainParameters_clone(const struct LDKChainParameters *NONNULL_PTR orig);
17999 export function ChainParameters_clone(orig: number): number {
18000 if(!isWasmInitialized) {
18001 throw new Error("initializeWasm() must be awaited first!");
18003 const nativeResponseValue = wasm.TS_ChainParameters_clone(orig);
18004 return nativeResponseValue;
18006 // void CounterpartyForwardingInfo_free(struct LDKCounterpartyForwardingInfo this_obj);
18008 export function CounterpartyForwardingInfo_free(this_obj: number): void {
18009 if(!isWasmInitialized) {
18010 throw new Error("initializeWasm() must be awaited first!");
18012 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_free(this_obj);
18013 // debug statements here
18015 // uint32_t CounterpartyForwardingInfo_get_fee_base_msat(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
18017 export function CounterpartyForwardingInfo_get_fee_base_msat(this_ptr: number): number {
18018 if(!isWasmInitialized) {
18019 throw new Error("initializeWasm() must be awaited first!");
18021 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_base_msat(this_ptr);
18022 return nativeResponseValue;
18024 // void CounterpartyForwardingInfo_set_fee_base_msat(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
18026 export function CounterpartyForwardingInfo_set_fee_base_msat(this_ptr: number, val: number): void {
18027 if(!isWasmInitialized) {
18028 throw new Error("initializeWasm() must be awaited first!");
18030 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_base_msat(this_ptr, val);
18031 // debug statements here
18033 // uint32_t CounterpartyForwardingInfo_get_fee_proportional_millionths(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
18035 export function CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr: number): number {
18036 if(!isWasmInitialized) {
18037 throw new Error("initializeWasm() must be awaited first!");
18039 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr);
18040 return nativeResponseValue;
18042 // void CounterpartyForwardingInfo_set_fee_proportional_millionths(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
18044 export function CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr: number, val: number): void {
18045 if(!isWasmInitialized) {
18046 throw new Error("initializeWasm() must be awaited first!");
18048 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr, val);
18049 // debug statements here
18051 // uint16_t CounterpartyForwardingInfo_get_cltv_expiry_delta(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
18053 export function CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr: number): number {
18054 if(!isWasmInitialized) {
18055 throw new Error("initializeWasm() must be awaited first!");
18057 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr);
18058 return nativeResponseValue;
18060 // void CounterpartyForwardingInfo_set_cltv_expiry_delta(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint16_t val);
18062 export function CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr: number, val: number): void {
18063 if(!isWasmInitialized) {
18064 throw new Error("initializeWasm() must be awaited first!");
18066 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr, val);
18067 // debug statements here
18069 // 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);
18071 export function CounterpartyForwardingInfo_new(fee_base_msat_arg: number, fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number): number {
18072 if(!isWasmInitialized) {
18073 throw new Error("initializeWasm() must be awaited first!");
18075 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
18076 return nativeResponseValue;
18078 // uintptr_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg);
18080 export function CounterpartyForwardingInfo_clone_ptr(arg: number): number {
18081 if(!isWasmInitialized) {
18082 throw new Error("initializeWasm() must be awaited first!");
18084 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone_ptr(arg);
18085 return nativeResponseValue;
18087 // struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_clone(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR orig);
18089 export function CounterpartyForwardingInfo_clone(orig: number): number {
18090 if(!isWasmInitialized) {
18091 throw new Error("initializeWasm() must be awaited first!");
18093 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone(orig);
18094 return nativeResponseValue;
18096 // void ChannelCounterparty_free(struct LDKChannelCounterparty this_obj);
18098 export function ChannelCounterparty_free(this_obj: number): void {
18099 if(!isWasmInitialized) {
18100 throw new Error("initializeWasm() must be awaited first!");
18102 const nativeResponseValue = wasm.TS_ChannelCounterparty_free(this_obj);
18103 // debug statements here
18105 // struct LDKPublicKey ChannelCounterparty_get_node_id(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18107 export function ChannelCounterparty_get_node_id(this_ptr: number): number {
18108 if(!isWasmInitialized) {
18109 throw new Error("initializeWasm() must be awaited first!");
18111 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_node_id(this_ptr);
18112 return nativeResponseValue;
18114 // void ChannelCounterparty_set_node_id(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKPublicKey val);
18116 export function ChannelCounterparty_set_node_id(this_ptr: number, val: number): void {
18117 if(!isWasmInitialized) {
18118 throw new Error("initializeWasm() must be awaited first!");
18120 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_node_id(this_ptr, val);
18121 // debug statements here
18123 // struct LDKInitFeatures ChannelCounterparty_get_features(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18125 export function ChannelCounterparty_get_features(this_ptr: number): number {
18126 if(!isWasmInitialized) {
18127 throw new Error("initializeWasm() must be awaited first!");
18129 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_features(this_ptr);
18130 return nativeResponseValue;
18132 // void ChannelCounterparty_set_features(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
18134 export function ChannelCounterparty_set_features(this_ptr: number, val: number): void {
18135 if(!isWasmInitialized) {
18136 throw new Error("initializeWasm() must be awaited first!");
18138 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_features(this_ptr, val);
18139 // debug statements here
18141 // uint64_t ChannelCounterparty_get_unspendable_punishment_reserve(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18143 export function ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr: number): bigint {
18144 if(!isWasmInitialized) {
18145 throw new Error("initializeWasm() must be awaited first!");
18147 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr);
18148 return nativeResponseValue;
18150 // void ChannelCounterparty_set_unspendable_punishment_reserve(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, uint64_t val);
18152 export function ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr: number, val: bigint): void {
18153 if(!isWasmInitialized) {
18154 throw new Error("initializeWasm() must be awaited first!");
18156 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr, val);
18157 // debug statements here
18159 // struct LDKCounterpartyForwardingInfo ChannelCounterparty_get_forwarding_info(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18161 export function ChannelCounterparty_get_forwarding_info(this_ptr: number): number {
18162 if(!isWasmInitialized) {
18163 throw new Error("initializeWasm() must be awaited first!");
18165 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_forwarding_info(this_ptr);
18166 return nativeResponseValue;
18168 // void ChannelCounterparty_set_forwarding_info(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCounterpartyForwardingInfo val);
18170 export function ChannelCounterparty_set_forwarding_info(this_ptr: number, val: number): void {
18171 if(!isWasmInitialized) {
18172 throw new Error("initializeWasm() must be awaited first!");
18174 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_forwarding_info(this_ptr, val);
18175 // debug statements here
18177 // 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);
18179 export function ChannelCounterparty_new(node_id_arg: number, features_arg: number, unspendable_punishment_reserve_arg: bigint, forwarding_info_arg: number): number {
18180 if(!isWasmInitialized) {
18181 throw new Error("initializeWasm() must be awaited first!");
18183 const nativeResponseValue = wasm.TS_ChannelCounterparty_new(node_id_arg, features_arg, unspendable_punishment_reserve_arg, forwarding_info_arg);
18184 return nativeResponseValue;
18186 // uintptr_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg);
18188 export function ChannelCounterparty_clone_ptr(arg: number): number {
18189 if(!isWasmInitialized) {
18190 throw new Error("initializeWasm() must be awaited first!");
18192 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone_ptr(arg);
18193 return nativeResponseValue;
18195 // struct LDKChannelCounterparty ChannelCounterparty_clone(const struct LDKChannelCounterparty *NONNULL_PTR orig);
18197 export function ChannelCounterparty_clone(orig: number): number {
18198 if(!isWasmInitialized) {
18199 throw new Error("initializeWasm() must be awaited first!");
18201 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone(orig);
18202 return nativeResponseValue;
18204 // void ChannelDetails_free(struct LDKChannelDetails this_obj);
18206 export function ChannelDetails_free(this_obj: number): void {
18207 if(!isWasmInitialized) {
18208 throw new Error("initializeWasm() must be awaited first!");
18210 const nativeResponseValue = wasm.TS_ChannelDetails_free(this_obj);
18211 // debug statements here
18213 // const uint8_t (*ChannelDetails_get_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr))[32];
18215 export function ChannelDetails_get_channel_id(this_ptr: number): number {
18216 if(!isWasmInitialized) {
18217 throw new Error("initializeWasm() must be awaited first!");
18219 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_id(this_ptr);
18220 return nativeResponseValue;
18222 // void ChannelDetails_set_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18224 export function ChannelDetails_set_channel_id(this_ptr: number, val: number): void {
18225 if(!isWasmInitialized) {
18226 throw new Error("initializeWasm() must be awaited first!");
18228 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_id(this_ptr, val);
18229 // debug statements here
18231 // struct LDKChannelCounterparty ChannelDetails_get_counterparty(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18233 export function ChannelDetails_get_counterparty(this_ptr: number): number {
18234 if(!isWasmInitialized) {
18235 throw new Error("initializeWasm() must be awaited first!");
18237 const nativeResponseValue = wasm.TS_ChannelDetails_get_counterparty(this_ptr);
18238 return nativeResponseValue;
18240 // void ChannelDetails_set_counterparty(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelCounterparty val);
18242 export function ChannelDetails_set_counterparty(this_ptr: number, val: number): void {
18243 if(!isWasmInitialized) {
18244 throw new Error("initializeWasm() must be awaited first!");
18246 const nativeResponseValue = wasm.TS_ChannelDetails_set_counterparty(this_ptr, val);
18247 // debug statements here
18249 // struct LDKOutPoint ChannelDetails_get_funding_txo(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18251 export function ChannelDetails_get_funding_txo(this_ptr: number): number {
18252 if(!isWasmInitialized) {
18253 throw new Error("initializeWasm() must be awaited first!");
18255 const nativeResponseValue = wasm.TS_ChannelDetails_get_funding_txo(this_ptr);
18256 return nativeResponseValue;
18258 // void ChannelDetails_set_funding_txo(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKOutPoint val);
18260 export function ChannelDetails_set_funding_txo(this_ptr: number, val: number): void {
18261 if(!isWasmInitialized) {
18262 throw new Error("initializeWasm() must be awaited first!");
18264 const nativeResponseValue = wasm.TS_ChannelDetails_set_funding_txo(this_ptr, val);
18265 // debug statements here
18267 // struct LDKCOption_u64Z ChannelDetails_get_short_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18269 export function ChannelDetails_get_short_channel_id(this_ptr: number): number {
18270 if(!isWasmInitialized) {
18271 throw new Error("initializeWasm() must be awaited first!");
18273 const nativeResponseValue = wasm.TS_ChannelDetails_get_short_channel_id(this_ptr);
18274 return nativeResponseValue;
18276 // void ChannelDetails_set_short_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
18278 export function ChannelDetails_set_short_channel_id(this_ptr: number, val: number): void {
18279 if(!isWasmInitialized) {
18280 throw new Error("initializeWasm() must be awaited first!");
18282 const nativeResponseValue = wasm.TS_ChannelDetails_set_short_channel_id(this_ptr, val);
18283 // debug statements here
18285 // uint64_t ChannelDetails_get_channel_value_satoshis(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18287 export function ChannelDetails_get_channel_value_satoshis(this_ptr: number): bigint {
18288 if(!isWasmInitialized) {
18289 throw new Error("initializeWasm() must be awaited first!");
18291 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_value_satoshis(this_ptr);
18292 return nativeResponseValue;
18294 // void ChannelDetails_set_channel_value_satoshis(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
18296 export function ChannelDetails_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
18297 if(!isWasmInitialized) {
18298 throw new Error("initializeWasm() must be awaited first!");
18300 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_value_satoshis(this_ptr, val);
18301 // debug statements here
18303 // struct LDKCOption_u64Z ChannelDetails_get_unspendable_punishment_reserve(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18305 export function ChannelDetails_get_unspendable_punishment_reserve(this_ptr: number): number {
18306 if(!isWasmInitialized) {
18307 throw new Error("initializeWasm() must be awaited first!");
18309 const nativeResponseValue = wasm.TS_ChannelDetails_get_unspendable_punishment_reserve(this_ptr);
18310 return nativeResponseValue;
18312 // void ChannelDetails_set_unspendable_punishment_reserve(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
18314 export function ChannelDetails_set_unspendable_punishment_reserve(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_unspendable_punishment_reserve(this_ptr, val);
18319 // debug statements here
18321 // uint64_t ChannelDetails_get_user_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18323 export function ChannelDetails_get_user_channel_id(this_ptr: number): bigint {
18324 if(!isWasmInitialized) {
18325 throw new Error("initializeWasm() must be awaited first!");
18327 const nativeResponseValue = wasm.TS_ChannelDetails_get_user_channel_id(this_ptr);
18328 return nativeResponseValue;
18330 // void ChannelDetails_set_user_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
18332 export function ChannelDetails_set_user_channel_id(this_ptr: number, val: bigint): void {
18333 if(!isWasmInitialized) {
18334 throw new Error("initializeWasm() must be awaited first!");
18336 const nativeResponseValue = wasm.TS_ChannelDetails_set_user_channel_id(this_ptr, val);
18337 // debug statements here
18339 // uint64_t ChannelDetails_get_balance_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18341 export function ChannelDetails_get_balance_msat(this_ptr: number): bigint {
18342 if(!isWasmInitialized) {
18343 throw new Error("initializeWasm() must be awaited first!");
18345 const nativeResponseValue = wasm.TS_ChannelDetails_get_balance_msat(this_ptr);
18346 return nativeResponseValue;
18348 // void ChannelDetails_set_balance_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
18350 export function ChannelDetails_set_balance_msat(this_ptr: number, val: bigint): void {
18351 if(!isWasmInitialized) {
18352 throw new Error("initializeWasm() must be awaited first!");
18354 const nativeResponseValue = wasm.TS_ChannelDetails_set_balance_msat(this_ptr, val);
18355 // debug statements here
18357 // uint64_t ChannelDetails_get_outbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18359 export function ChannelDetails_get_outbound_capacity_msat(this_ptr: number): bigint {
18360 if(!isWasmInitialized) {
18361 throw new Error("initializeWasm() must be awaited first!");
18363 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_capacity_msat(this_ptr);
18364 return nativeResponseValue;
18366 // void ChannelDetails_set_outbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
18368 export function ChannelDetails_set_outbound_capacity_msat(this_ptr: number, val: bigint): void {
18369 if(!isWasmInitialized) {
18370 throw new Error("initializeWasm() must be awaited first!");
18372 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_capacity_msat(this_ptr, val);
18373 // debug statements here
18375 // uint64_t ChannelDetails_get_inbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18377 export function ChannelDetails_get_inbound_capacity_msat(this_ptr: number): bigint {
18378 if(!isWasmInitialized) {
18379 throw new Error("initializeWasm() must be awaited first!");
18381 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_capacity_msat(this_ptr);
18382 return nativeResponseValue;
18384 // void ChannelDetails_set_inbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
18386 export function ChannelDetails_set_inbound_capacity_msat(this_ptr: number, val: bigint): void {
18387 if(!isWasmInitialized) {
18388 throw new Error("initializeWasm() must be awaited first!");
18390 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_capacity_msat(this_ptr, val);
18391 // debug statements here
18393 // struct LDKCOption_u32Z ChannelDetails_get_confirmations_required(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18395 export function ChannelDetails_get_confirmations_required(this_ptr: number): number {
18396 if(!isWasmInitialized) {
18397 throw new Error("initializeWasm() must be awaited first!");
18399 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations_required(this_ptr);
18400 return nativeResponseValue;
18402 // void ChannelDetails_set_confirmations_required(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
18404 export function ChannelDetails_set_confirmations_required(this_ptr: number, val: number): void {
18405 if(!isWasmInitialized) {
18406 throw new Error("initializeWasm() must be awaited first!");
18408 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations_required(this_ptr, val);
18409 // debug statements here
18411 // struct LDKCOption_u16Z ChannelDetails_get_force_close_spend_delay(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18413 export function ChannelDetails_get_force_close_spend_delay(this_ptr: number): number {
18414 if(!isWasmInitialized) {
18415 throw new Error("initializeWasm() must be awaited first!");
18417 const nativeResponseValue = wasm.TS_ChannelDetails_get_force_close_spend_delay(this_ptr);
18418 return nativeResponseValue;
18420 // void ChannelDetails_set_force_close_spend_delay(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
18422 export function ChannelDetails_set_force_close_spend_delay(this_ptr: number, val: number): void {
18423 if(!isWasmInitialized) {
18424 throw new Error("initializeWasm() must be awaited first!");
18426 const nativeResponseValue = wasm.TS_ChannelDetails_set_force_close_spend_delay(this_ptr, val);
18427 // debug statements here
18429 // bool ChannelDetails_get_is_outbound(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18431 export function ChannelDetails_get_is_outbound(this_ptr: number): boolean {
18432 if(!isWasmInitialized) {
18433 throw new Error("initializeWasm() must be awaited first!");
18435 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_outbound(this_ptr);
18436 return nativeResponseValue;
18438 // void ChannelDetails_set_is_outbound(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
18440 export function ChannelDetails_set_is_outbound(this_ptr: number, val: boolean): void {
18441 if(!isWasmInitialized) {
18442 throw new Error("initializeWasm() must be awaited first!");
18444 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_outbound(this_ptr, val);
18445 // debug statements here
18447 // bool ChannelDetails_get_is_funding_locked(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18449 export function ChannelDetails_get_is_funding_locked(this_ptr: number): boolean {
18450 if(!isWasmInitialized) {
18451 throw new Error("initializeWasm() must be awaited first!");
18453 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_funding_locked(this_ptr);
18454 return nativeResponseValue;
18456 // void ChannelDetails_set_is_funding_locked(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
18458 export function ChannelDetails_set_is_funding_locked(this_ptr: number, val: boolean): void {
18459 if(!isWasmInitialized) {
18460 throw new Error("initializeWasm() must be awaited first!");
18462 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_funding_locked(this_ptr, val);
18463 // debug statements here
18465 // bool ChannelDetails_get_is_usable(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18467 export function ChannelDetails_get_is_usable(this_ptr: number): boolean {
18468 if(!isWasmInitialized) {
18469 throw new Error("initializeWasm() must be awaited first!");
18471 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_usable(this_ptr);
18472 return nativeResponseValue;
18474 // void ChannelDetails_set_is_usable(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
18476 export function ChannelDetails_set_is_usable(this_ptr: number, val: boolean): void {
18477 if(!isWasmInitialized) {
18478 throw new Error("initializeWasm() must be awaited first!");
18480 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_usable(this_ptr, val);
18481 // debug statements here
18483 // bool ChannelDetails_get_is_public(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18485 export function ChannelDetails_get_is_public(this_ptr: number): boolean {
18486 if(!isWasmInitialized) {
18487 throw new Error("initializeWasm() must be awaited first!");
18489 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_public(this_ptr);
18490 return nativeResponseValue;
18492 // void ChannelDetails_set_is_public(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
18494 export function ChannelDetails_set_is_public(this_ptr: number, val: boolean): void {
18495 if(!isWasmInitialized) {
18496 throw new Error("initializeWasm() must be awaited first!");
18498 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_public(this_ptr, val);
18499 // debug statements here
18501 // 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);
18503 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 {
18504 if(!isWasmInitialized) {
18505 throw new Error("initializeWasm() must be awaited first!");
18507 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);
18508 return nativeResponseValue;
18510 // uintptr_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg);
18512 export function ChannelDetails_clone_ptr(arg: number): number {
18513 if(!isWasmInitialized) {
18514 throw new Error("initializeWasm() must be awaited first!");
18516 const nativeResponseValue = wasm.TS_ChannelDetails_clone_ptr(arg);
18517 return nativeResponseValue;
18519 // struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
18521 export function ChannelDetails_clone(orig: number): number {
18522 if(!isWasmInitialized) {
18523 throw new Error("initializeWasm() must be awaited first!");
18525 const nativeResponseValue = wasm.TS_ChannelDetails_clone(orig);
18526 return nativeResponseValue;
18528 // void PaymentSendFailure_free(struct LDKPaymentSendFailure this_ptr);
18530 export function PaymentSendFailure_free(this_ptr: number): void {
18531 if(!isWasmInitialized) {
18532 throw new Error("initializeWasm() must be awaited first!");
18534 const nativeResponseValue = wasm.TS_PaymentSendFailure_free(this_ptr);
18535 // debug statements here
18537 // uintptr_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg);
18539 export function PaymentSendFailure_clone_ptr(arg: number): number {
18540 if(!isWasmInitialized) {
18541 throw new Error("initializeWasm() must be awaited first!");
18543 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone_ptr(arg);
18544 return nativeResponseValue;
18546 // struct LDKPaymentSendFailure PaymentSendFailure_clone(const struct LDKPaymentSendFailure *NONNULL_PTR orig);
18548 export function PaymentSendFailure_clone(orig: number): number {
18549 if(!isWasmInitialized) {
18550 throw new Error("initializeWasm() must be awaited first!");
18552 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone(orig);
18553 return nativeResponseValue;
18555 // struct LDKPaymentSendFailure PaymentSendFailure_parameter_error(struct LDKAPIError a);
18557 export function PaymentSendFailure_parameter_error(a: number): number {
18558 if(!isWasmInitialized) {
18559 throw new Error("initializeWasm() must be awaited first!");
18561 const nativeResponseValue = wasm.TS_PaymentSendFailure_parameter_error(a);
18562 return nativeResponseValue;
18564 // struct LDKPaymentSendFailure PaymentSendFailure_path_parameter_error(struct LDKCVec_CResult_NoneAPIErrorZZ a);
18566 export function PaymentSendFailure_path_parameter_error(a: number): number {
18567 if(!isWasmInitialized) {
18568 throw new Error("initializeWasm() must be awaited first!");
18570 const nativeResponseValue = wasm.TS_PaymentSendFailure_path_parameter_error(a);
18571 return nativeResponseValue;
18573 // struct LDKPaymentSendFailure PaymentSendFailure_all_failed_retry_safe(struct LDKCVec_APIErrorZ a);
18575 export function PaymentSendFailure_all_failed_retry_safe(a: number): number {
18576 if(!isWasmInitialized) {
18577 throw new Error("initializeWasm() must be awaited first!");
18579 const nativeResponseValue = wasm.TS_PaymentSendFailure_all_failed_retry_safe(a);
18580 return nativeResponseValue;
18582 // struct LDKPaymentSendFailure PaymentSendFailure_partial_failure(struct LDKCVec_CResult_NoneAPIErrorZZ results, struct LDKRouteParameters failed_paths_retry, struct LDKThirtyTwoBytes payment_id);
18584 export function PaymentSendFailure_partial_failure(results: number, failed_paths_retry: number, payment_id: number): number {
18585 if(!isWasmInitialized) {
18586 throw new Error("initializeWasm() must be awaited first!");
18588 const nativeResponseValue = wasm.TS_PaymentSendFailure_partial_failure(results, failed_paths_retry, payment_id);
18589 return nativeResponseValue;
18591 // void PhantomRouteHints_free(struct LDKPhantomRouteHints this_obj);
18593 export function PhantomRouteHints_free(this_obj: number): void {
18594 if(!isWasmInitialized) {
18595 throw new Error("initializeWasm() must be awaited first!");
18597 const nativeResponseValue = wasm.TS_PhantomRouteHints_free(this_obj);
18598 // debug statements here
18600 // struct LDKCVec_ChannelDetailsZ PhantomRouteHints_get_channels(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
18602 export function PhantomRouteHints_get_channels(this_ptr: number): number {
18603 if(!isWasmInitialized) {
18604 throw new Error("initializeWasm() must be awaited first!");
18606 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_channels(this_ptr);
18607 return nativeResponseValue;
18609 // void PhantomRouteHints_set_channels(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKCVec_ChannelDetailsZ val);
18611 export function PhantomRouteHints_set_channels(this_ptr: number, val: number): void {
18612 if(!isWasmInitialized) {
18613 throw new Error("initializeWasm() must be awaited first!");
18615 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_channels(this_ptr, val);
18616 // debug statements here
18618 // uint64_t PhantomRouteHints_get_phantom_scid(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
18620 export function PhantomRouteHints_get_phantom_scid(this_ptr: number): bigint {
18621 if(!isWasmInitialized) {
18622 throw new Error("initializeWasm() must be awaited first!");
18624 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_phantom_scid(this_ptr);
18625 return nativeResponseValue;
18627 // void PhantomRouteHints_set_phantom_scid(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, uint64_t val);
18629 export function PhantomRouteHints_set_phantom_scid(this_ptr: number, val: bigint): void {
18630 if(!isWasmInitialized) {
18631 throw new Error("initializeWasm() must be awaited first!");
18633 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_phantom_scid(this_ptr, val);
18634 // debug statements here
18636 // struct LDKPublicKey PhantomRouteHints_get_real_node_pubkey(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
18638 export function PhantomRouteHints_get_real_node_pubkey(this_ptr: number): number {
18639 if(!isWasmInitialized) {
18640 throw new Error("initializeWasm() must be awaited first!");
18642 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_real_node_pubkey(this_ptr);
18643 return nativeResponseValue;
18645 // void PhantomRouteHints_set_real_node_pubkey(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKPublicKey val);
18647 export function PhantomRouteHints_set_real_node_pubkey(this_ptr: number, val: number): void {
18648 if(!isWasmInitialized) {
18649 throw new Error("initializeWasm() must be awaited first!");
18651 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_real_node_pubkey(this_ptr, val);
18652 // debug statements here
18654 // MUST_USE_RES struct LDKPhantomRouteHints PhantomRouteHints_new(struct LDKCVec_ChannelDetailsZ channels_arg, uint64_t phantom_scid_arg, struct LDKPublicKey real_node_pubkey_arg);
18656 export function PhantomRouteHints_new(channels_arg: number, phantom_scid_arg: bigint, real_node_pubkey_arg: number): number {
18657 if(!isWasmInitialized) {
18658 throw new Error("initializeWasm() must be awaited first!");
18660 const nativeResponseValue = wasm.TS_PhantomRouteHints_new(channels_arg, phantom_scid_arg, real_node_pubkey_arg);
18661 return nativeResponseValue;
18663 // uintptr_t PhantomRouteHints_clone_ptr(LDKPhantomRouteHints *NONNULL_PTR arg);
18665 export function PhantomRouteHints_clone_ptr(arg: number): number {
18666 if(!isWasmInitialized) {
18667 throw new Error("initializeWasm() must be awaited first!");
18669 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone_ptr(arg);
18670 return nativeResponseValue;
18672 // struct LDKPhantomRouteHints PhantomRouteHints_clone(const struct LDKPhantomRouteHints *NONNULL_PTR orig);
18674 export function PhantomRouteHints_clone(orig: number): number {
18675 if(!isWasmInitialized) {
18676 throw new Error("initializeWasm() must be awaited first!");
18678 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone(orig);
18679 return nativeResponseValue;
18681 // 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);
18683 export function ChannelManager_new(fee_est: number, chain_monitor: number, tx_broadcaster: number, logger: number, keys_manager: number, config: number, params: number): number {
18684 if(!isWasmInitialized) {
18685 throw new Error("initializeWasm() must be awaited first!");
18687 const nativeResponseValue = wasm.TS_ChannelManager_new(fee_est, chain_monitor, tx_broadcaster, logger, keys_manager, config, params);
18688 return nativeResponseValue;
18690 // MUST_USE_RES struct LDKUserConfig ChannelManager_get_current_default_configuration(const struct LDKChannelManager *NONNULL_PTR this_arg);
18692 export function ChannelManager_get_current_default_configuration(this_arg: number): number {
18693 if(!isWasmInitialized) {
18694 throw new Error("initializeWasm() must be awaited first!");
18696 const nativeResponseValue = wasm.TS_ChannelManager_get_current_default_configuration(this_arg);
18697 return nativeResponseValue;
18699 // 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);
18701 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 {
18702 if(!isWasmInitialized) {
18703 throw new Error("initializeWasm() must be awaited first!");
18705 const nativeResponseValue = wasm.TS_ChannelManager_create_channel(this_arg, their_network_key, channel_value_satoshis, push_msat, user_channel_id, override_config);
18706 return nativeResponseValue;
18708 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
18710 export function ChannelManager_list_channels(this_arg: number): number {
18711 if(!isWasmInitialized) {
18712 throw new Error("initializeWasm() must be awaited first!");
18714 const nativeResponseValue = wasm.TS_ChannelManager_list_channels(this_arg);
18715 return nativeResponseValue;
18717 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_usable_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
18719 export function ChannelManager_list_usable_channels(this_arg: number): number {
18720 if(!isWasmInitialized) {
18721 throw new Error("initializeWasm() must be awaited first!");
18723 const nativeResponseValue = wasm.TS_ChannelManager_list_usable_channels(this_arg);
18724 return nativeResponseValue;
18726 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_close_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32]);
18728 export function ChannelManager_close_channel(this_arg: number, channel_id: number): number {
18729 if(!isWasmInitialized) {
18730 throw new Error("initializeWasm() must be awaited first!");
18732 const nativeResponseValue = wasm.TS_ChannelManager_close_channel(this_arg, channel_id);
18733 return nativeResponseValue;
18735 // 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);
18737 export function ChannelManager_close_channel_with_target_feerate(this_arg: number, channel_id: number, target_feerate_sats_per_1000_weight: number): number {
18738 if(!isWasmInitialized) {
18739 throw new Error("initializeWasm() must be awaited first!");
18741 const nativeResponseValue = wasm.TS_ChannelManager_close_channel_with_target_feerate(this_arg, channel_id, target_feerate_sats_per_1000_weight);
18742 return nativeResponseValue;
18744 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_force_close_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32]);
18746 export function ChannelManager_force_close_channel(this_arg: number, channel_id: number): number {
18747 if(!isWasmInitialized) {
18748 throw new Error("initializeWasm() must be awaited first!");
18750 const nativeResponseValue = wasm.TS_ChannelManager_force_close_channel(this_arg, channel_id);
18751 return nativeResponseValue;
18753 // void ChannelManager_force_close_all_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
18755 export function ChannelManager_force_close_all_channels(this_arg: number): void {
18756 if(!isWasmInitialized) {
18757 throw new Error("initializeWasm() must be awaited first!");
18759 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels(this_arg);
18760 // debug statements here
18762 // 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);
18764 export function ChannelManager_send_payment(this_arg: number, route: number, payment_hash: number, payment_secret: number): number {
18765 if(!isWasmInitialized) {
18766 throw new Error("initializeWasm() must be awaited first!");
18768 const nativeResponseValue = wasm.TS_ChannelManager_send_payment(this_arg, route, payment_hash, payment_secret);
18769 return nativeResponseValue;
18771 // 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);
18773 export function ChannelManager_retry_payment(this_arg: number, route: number, payment_id: number): number {
18774 if(!isWasmInitialized) {
18775 throw new Error("initializeWasm() must be awaited first!");
18777 const nativeResponseValue = wasm.TS_ChannelManager_retry_payment(this_arg, route, payment_id);
18778 return nativeResponseValue;
18780 // void ChannelManager_abandon_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id);
18782 export function ChannelManager_abandon_payment(this_arg: number, payment_id: number): void {
18783 if(!isWasmInitialized) {
18784 throw new Error("initializeWasm() must be awaited first!");
18786 const nativeResponseValue = wasm.TS_ChannelManager_abandon_payment(this_arg, payment_id);
18787 // debug statements here
18789 // 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);
18791 export function ChannelManager_send_spontaneous_payment(this_arg: number, route: number, payment_preimage: number): number {
18792 if(!isWasmInitialized) {
18793 throw new Error("initializeWasm() must be awaited first!");
18795 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment(this_arg, route, payment_preimage);
18796 return nativeResponseValue;
18798 // 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);
18800 export function ChannelManager_funding_transaction_generated(this_arg: number, temporary_channel_id: number, funding_transaction: number): number {
18801 if(!isWasmInitialized) {
18802 throw new Error("initializeWasm() must be awaited first!");
18804 const nativeResponseValue = wasm.TS_ChannelManager_funding_transaction_generated(this_arg, temporary_channel_id, funding_transaction);
18805 return nativeResponseValue;
18807 // void ChannelManager_broadcast_node_announcement(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThreeBytes rgb, struct LDKThirtyTwoBytes alias, struct LDKCVec_NetAddressZ addresses);
18809 export function ChannelManager_broadcast_node_announcement(this_arg: number, rgb: number, alias: number, addresses: number): void {
18810 if(!isWasmInitialized) {
18811 throw new Error("initializeWasm() must be awaited first!");
18813 const nativeResponseValue = wasm.TS_ChannelManager_broadcast_node_announcement(this_arg, rgb, alias, addresses);
18814 // debug statements here
18816 // void ChannelManager_process_pending_htlc_forwards(const struct LDKChannelManager *NONNULL_PTR this_arg);
18818 export function ChannelManager_process_pending_htlc_forwards(this_arg: number): void {
18819 if(!isWasmInitialized) {
18820 throw new Error("initializeWasm() must be awaited first!");
18822 const nativeResponseValue = wasm.TS_ChannelManager_process_pending_htlc_forwards(this_arg);
18823 // debug statements here
18825 // void ChannelManager_timer_tick_occurred(const struct LDKChannelManager *NONNULL_PTR this_arg);
18827 export function ChannelManager_timer_tick_occurred(this_arg: number): void {
18828 if(!isWasmInitialized) {
18829 throw new Error("initializeWasm() must be awaited first!");
18831 const nativeResponseValue = wasm.TS_ChannelManager_timer_tick_occurred(this_arg);
18832 // debug statements here
18834 // MUST_USE_RES bool ChannelManager_fail_htlc_backwards(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
18836 export function ChannelManager_fail_htlc_backwards(this_arg: number, payment_hash: number): boolean {
18837 if(!isWasmInitialized) {
18838 throw new Error("initializeWasm() must be awaited first!");
18840 const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards(this_arg, payment_hash);
18841 return nativeResponseValue;
18843 // MUST_USE_RES bool ChannelManager_claim_funds(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
18845 export function ChannelManager_claim_funds(this_arg: number, payment_preimage: number): boolean {
18846 if(!isWasmInitialized) {
18847 throw new Error("initializeWasm() must be awaited first!");
18849 const nativeResponseValue = wasm.TS_ChannelManager_claim_funds(this_arg, payment_preimage);
18850 return nativeResponseValue;
18852 // MUST_USE_RES struct LDKPublicKey ChannelManager_get_our_node_id(const struct LDKChannelManager *NONNULL_PTR this_arg);
18854 export function ChannelManager_get_our_node_id(this_arg: number): number {
18855 if(!isWasmInitialized) {
18856 throw new Error("initializeWasm() must be awaited first!");
18858 const nativeResponseValue = wasm.TS_ChannelManager_get_our_node_id(this_arg);
18859 return nativeResponseValue;
18861 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_accept_inbound_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*temporary_channel_id)[32]);
18863 export function ChannelManager_accept_inbound_channel(this_arg: number, temporary_channel_id: number): number {
18864 if(!isWasmInitialized) {
18865 throw new Error("initializeWasm() must be awaited first!");
18867 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel(this_arg, temporary_channel_id);
18868 return nativeResponseValue;
18870 // 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);
18872 export function ChannelManager_create_inbound_payment(this_arg: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
18873 if(!isWasmInitialized) {
18874 throw new Error("initializeWasm() must be awaited first!");
18876 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment(this_arg, min_value_msat, invoice_expiry_delta_secs);
18877 return nativeResponseValue;
18879 // 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);
18881 export function ChannelManager_create_inbound_payment_legacy(this_arg: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
18882 if(!isWasmInitialized) {
18883 throw new Error("initializeWasm() must be awaited first!");
18885 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_legacy(this_arg, min_value_msat, invoice_expiry_delta_secs);
18886 return nativeResponseValue;
18888 // 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);
18890 export function ChannelManager_create_inbound_payment_for_hash(this_arg: number, payment_hash: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
18891 if(!isWasmInitialized) {
18892 throw new Error("initializeWasm() must be awaited first!");
18894 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
18895 return nativeResponseValue;
18897 // 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);
18899 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 {
18900 if(!isWasmInitialized) {
18901 throw new Error("initializeWasm() must be awaited first!");
18903 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash_legacy(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
18904 return nativeResponseValue;
18906 // 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);
18908 export function ChannelManager_get_payment_preimage(this_arg: number, payment_hash: number, payment_secret: number): number {
18909 if(!isWasmInitialized) {
18910 throw new Error("initializeWasm() must be awaited first!");
18912 const nativeResponseValue = wasm.TS_ChannelManager_get_payment_preimage(this_arg, payment_hash, payment_secret);
18913 return nativeResponseValue;
18915 // MUST_USE_RES uint64_t ChannelManager_get_phantom_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
18917 export function ChannelManager_get_phantom_scid(this_arg: number): bigint {
18918 if(!isWasmInitialized) {
18919 throw new Error("initializeWasm() must be awaited first!");
18921 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_scid(this_arg);
18922 return nativeResponseValue;
18924 // MUST_USE_RES struct LDKPhantomRouteHints ChannelManager_get_phantom_route_hints(const struct LDKChannelManager *NONNULL_PTR this_arg);
18926 export function ChannelManager_get_phantom_route_hints(this_arg: number): number {
18927 if(!isWasmInitialized) {
18928 throw new Error("initializeWasm() must be awaited first!");
18930 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_route_hints(this_arg);
18931 return nativeResponseValue;
18933 // struct LDKMessageSendEventsProvider ChannelManager_as_MessageSendEventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
18935 export function ChannelManager_as_MessageSendEventsProvider(this_arg: number): number {
18936 if(!isWasmInitialized) {
18937 throw new Error("initializeWasm() must be awaited first!");
18939 const nativeResponseValue = wasm.TS_ChannelManager_as_MessageSendEventsProvider(this_arg);
18940 return nativeResponseValue;
18942 // struct LDKEventsProvider ChannelManager_as_EventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
18944 export function ChannelManager_as_EventsProvider(this_arg: number): number {
18945 if(!isWasmInitialized) {
18946 throw new Error("initializeWasm() must be awaited first!");
18948 const nativeResponseValue = wasm.TS_ChannelManager_as_EventsProvider(this_arg);
18949 return nativeResponseValue;
18951 // struct LDKListen ChannelManager_as_Listen(const struct LDKChannelManager *NONNULL_PTR this_arg);
18953 export function ChannelManager_as_Listen(this_arg: number): number {
18954 if(!isWasmInitialized) {
18955 throw new Error("initializeWasm() must be awaited first!");
18957 const nativeResponseValue = wasm.TS_ChannelManager_as_Listen(this_arg);
18958 return nativeResponseValue;
18960 // struct LDKConfirm ChannelManager_as_Confirm(const struct LDKChannelManager *NONNULL_PTR this_arg);
18962 export function ChannelManager_as_Confirm(this_arg: number): number {
18963 if(!isWasmInitialized) {
18964 throw new Error("initializeWasm() must be awaited first!");
18966 const nativeResponseValue = wasm.TS_ChannelManager_as_Confirm(this_arg);
18967 return nativeResponseValue;
18969 // void ChannelManager_await_persistable_update(const struct LDKChannelManager *NONNULL_PTR this_arg);
18971 export function ChannelManager_await_persistable_update(this_arg: number): void {
18972 if(!isWasmInitialized) {
18973 throw new Error("initializeWasm() must be awaited first!");
18975 const nativeResponseValue = wasm.TS_ChannelManager_await_persistable_update(this_arg);
18976 // debug statements here
18978 // MUST_USE_RES struct LDKBestBlock ChannelManager_current_best_block(const struct LDKChannelManager *NONNULL_PTR this_arg);
18980 export function ChannelManager_current_best_block(this_arg: number): number {
18981 if(!isWasmInitialized) {
18982 throw new Error("initializeWasm() must be awaited first!");
18984 const nativeResponseValue = wasm.TS_ChannelManager_current_best_block(this_arg);
18985 return nativeResponseValue;
18987 // struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
18989 export function ChannelManager_as_ChannelMessageHandler(this_arg: number): number {
18990 if(!isWasmInitialized) {
18991 throw new Error("initializeWasm() must be awaited first!");
18993 const nativeResponseValue = wasm.TS_ChannelManager_as_ChannelMessageHandler(this_arg);
18994 return nativeResponseValue;
18996 // struct LDKCVec_u8Z CounterpartyForwardingInfo_write(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR obj);
18998 export function CounterpartyForwardingInfo_write(obj: number): number {
18999 if(!isWasmInitialized) {
19000 throw new Error("initializeWasm() must be awaited first!");
19002 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_write(obj);
19003 return nativeResponseValue;
19005 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CounterpartyForwardingInfo_read(struct LDKu8slice ser);
19007 export function CounterpartyForwardingInfo_read(ser: number): number {
19008 if(!isWasmInitialized) {
19009 throw new Error("initializeWasm() must be awaited first!");
19011 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_read(ser);
19012 return nativeResponseValue;
19014 // struct LDKCVec_u8Z ChannelCounterparty_write(const struct LDKChannelCounterparty *NONNULL_PTR obj);
19016 export function ChannelCounterparty_write(obj: number): number {
19017 if(!isWasmInitialized) {
19018 throw new Error("initializeWasm() must be awaited first!");
19020 const nativeResponseValue = wasm.TS_ChannelCounterparty_write(obj);
19021 return nativeResponseValue;
19023 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ ChannelCounterparty_read(struct LDKu8slice ser);
19025 export function ChannelCounterparty_read(ser: number): number {
19026 if(!isWasmInitialized) {
19027 throw new Error("initializeWasm() must be awaited first!");
19029 const nativeResponseValue = wasm.TS_ChannelCounterparty_read(ser);
19030 return nativeResponseValue;
19032 // struct LDKCVec_u8Z ChannelDetails_write(const struct LDKChannelDetails *NONNULL_PTR obj);
19034 export function ChannelDetails_write(obj: number): number {
19035 if(!isWasmInitialized) {
19036 throw new Error("initializeWasm() must be awaited first!");
19038 const nativeResponseValue = wasm.TS_ChannelDetails_write(obj);
19039 return nativeResponseValue;
19041 // struct LDKCResult_ChannelDetailsDecodeErrorZ ChannelDetails_read(struct LDKu8slice ser);
19043 export function ChannelDetails_read(ser: number): number {
19044 if(!isWasmInitialized) {
19045 throw new Error("initializeWasm() must be awaited first!");
19047 const nativeResponseValue = wasm.TS_ChannelDetails_read(ser);
19048 return nativeResponseValue;
19050 // struct LDKCVec_u8Z PhantomRouteHints_write(const struct LDKPhantomRouteHints *NONNULL_PTR obj);
19052 export function PhantomRouteHints_write(obj: number): number {
19053 if(!isWasmInitialized) {
19054 throw new Error("initializeWasm() must be awaited first!");
19056 const nativeResponseValue = wasm.TS_PhantomRouteHints_write(obj);
19057 return nativeResponseValue;
19059 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ PhantomRouteHints_read(struct LDKu8slice ser);
19061 export function PhantomRouteHints_read(ser: number): number {
19062 if(!isWasmInitialized) {
19063 throw new Error("initializeWasm() must be awaited first!");
19065 const nativeResponseValue = wasm.TS_PhantomRouteHints_read(ser);
19066 return nativeResponseValue;
19068 // struct LDKCVec_u8Z ChannelManager_write(const struct LDKChannelManager *NONNULL_PTR obj);
19070 export function ChannelManager_write(obj: number): number {
19071 if(!isWasmInitialized) {
19072 throw new Error("initializeWasm() must be awaited first!");
19074 const nativeResponseValue = wasm.TS_ChannelManager_write(obj);
19075 return nativeResponseValue;
19077 // void ChannelManagerReadArgs_free(struct LDKChannelManagerReadArgs this_obj);
19079 export function ChannelManagerReadArgs_free(this_obj: number): void {
19080 if(!isWasmInitialized) {
19081 throw new Error("initializeWasm() must be awaited first!");
19083 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_free(this_obj);
19084 // debug statements here
19086 // const struct LDKKeysInterface *ChannelManagerReadArgs_get_keys_manager(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19088 export function ChannelManagerReadArgs_get_keys_manager(this_ptr: number): number {
19089 if(!isWasmInitialized) {
19090 throw new Error("initializeWasm() must be awaited first!");
19092 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_keys_manager(this_ptr);
19093 return nativeResponseValue;
19095 // void ChannelManagerReadArgs_set_keys_manager(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKKeysInterface val);
19097 export function ChannelManagerReadArgs_set_keys_manager(this_ptr: number, val: number): void {
19098 if(!isWasmInitialized) {
19099 throw new Error("initializeWasm() must be awaited first!");
19101 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_keys_manager(this_ptr, val);
19102 // debug statements here
19104 // const struct LDKFeeEstimator *ChannelManagerReadArgs_get_fee_estimator(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19106 export function ChannelManagerReadArgs_get_fee_estimator(this_ptr: number): number {
19107 if(!isWasmInitialized) {
19108 throw new Error("initializeWasm() must be awaited first!");
19110 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_fee_estimator(this_ptr);
19111 return nativeResponseValue;
19113 // void ChannelManagerReadArgs_set_fee_estimator(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKFeeEstimator val);
19115 export function ChannelManagerReadArgs_set_fee_estimator(this_ptr: number, val: number): void {
19116 if(!isWasmInitialized) {
19117 throw new Error("initializeWasm() must be awaited first!");
19119 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_fee_estimator(this_ptr, val);
19120 // debug statements here
19122 // const struct LDKWatch *ChannelManagerReadArgs_get_chain_monitor(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19124 export function ChannelManagerReadArgs_get_chain_monitor(this_ptr: number): number {
19125 if(!isWasmInitialized) {
19126 throw new Error("initializeWasm() must be awaited first!");
19128 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_chain_monitor(this_ptr);
19129 return nativeResponseValue;
19131 // void ChannelManagerReadArgs_set_chain_monitor(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKWatch val);
19133 export function ChannelManagerReadArgs_set_chain_monitor(this_ptr: number, val: number): void {
19134 if(!isWasmInitialized) {
19135 throw new Error("initializeWasm() must be awaited first!");
19137 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_chain_monitor(this_ptr, val);
19138 // debug statements here
19140 // const struct LDKBroadcasterInterface *ChannelManagerReadArgs_get_tx_broadcaster(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19142 export function ChannelManagerReadArgs_get_tx_broadcaster(this_ptr: number): number {
19143 if(!isWasmInitialized) {
19144 throw new Error("initializeWasm() must be awaited first!");
19146 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_tx_broadcaster(this_ptr);
19147 return nativeResponseValue;
19149 // void ChannelManagerReadArgs_set_tx_broadcaster(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKBroadcasterInterface val);
19151 export function ChannelManagerReadArgs_set_tx_broadcaster(this_ptr: number, val: number): void {
19152 if(!isWasmInitialized) {
19153 throw new Error("initializeWasm() must be awaited first!");
19155 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_tx_broadcaster(this_ptr, val);
19156 // debug statements here
19158 // const struct LDKLogger *ChannelManagerReadArgs_get_logger(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19160 export function ChannelManagerReadArgs_get_logger(this_ptr: number): number {
19161 if(!isWasmInitialized) {
19162 throw new Error("initializeWasm() must be awaited first!");
19164 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_logger(this_ptr);
19165 return nativeResponseValue;
19167 // void ChannelManagerReadArgs_set_logger(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKLogger val);
19169 export function ChannelManagerReadArgs_set_logger(this_ptr: number, val: number): void {
19170 if(!isWasmInitialized) {
19171 throw new Error("initializeWasm() must be awaited first!");
19173 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_logger(this_ptr, val);
19174 // debug statements here
19176 // struct LDKUserConfig ChannelManagerReadArgs_get_default_config(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19178 export function ChannelManagerReadArgs_get_default_config(this_ptr: number): number {
19179 if(!isWasmInitialized) {
19180 throw new Error("initializeWasm() must be awaited first!");
19182 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_default_config(this_ptr);
19183 return nativeResponseValue;
19185 // void ChannelManagerReadArgs_set_default_config(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKUserConfig val);
19187 export function ChannelManagerReadArgs_set_default_config(this_ptr: number, val: number): void {
19188 if(!isWasmInitialized) {
19189 throw new Error("initializeWasm() must be awaited first!");
19191 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_default_config(this_ptr, val);
19192 // debug statements here
19194 // 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);
19196 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 {
19197 if(!isWasmInitialized) {
19198 throw new Error("initializeWasm() must be awaited first!");
19200 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_new(keys_manager, fee_estimator, chain_monitor, tx_broadcaster, logger, default_config, channel_monitors);
19201 return nativeResponseValue;
19203 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ C2Tuple_BlockHashChannelManagerZ_read(struct LDKu8slice ser, struct LDKChannelManagerReadArgs arg);
19205 export function C2Tuple_BlockHashChannelManagerZ_read(ser: number, arg: number): number {
19206 if(!isWasmInitialized) {
19207 throw new Error("initializeWasm() must be awaited first!");
19209 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_read(ser, arg);
19210 return nativeResponseValue;
19212 // void DecodeError_free(struct LDKDecodeError this_obj);
19214 export function DecodeError_free(this_obj: number): void {
19215 if(!isWasmInitialized) {
19216 throw new Error("initializeWasm() must be awaited first!");
19218 const nativeResponseValue = wasm.TS_DecodeError_free(this_obj);
19219 // debug statements here
19221 // uintptr_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg);
19223 export function DecodeError_clone_ptr(arg: number): number {
19224 if(!isWasmInitialized) {
19225 throw new Error("initializeWasm() must be awaited first!");
19227 const nativeResponseValue = wasm.TS_DecodeError_clone_ptr(arg);
19228 return nativeResponseValue;
19230 // struct LDKDecodeError DecodeError_clone(const struct LDKDecodeError *NONNULL_PTR orig);
19232 export function DecodeError_clone(orig: number): number {
19233 if(!isWasmInitialized) {
19234 throw new Error("initializeWasm() must be awaited first!");
19236 const nativeResponseValue = wasm.TS_DecodeError_clone(orig);
19237 return nativeResponseValue;
19239 // void Init_free(struct LDKInit this_obj);
19241 export function Init_free(this_obj: number): void {
19242 if(!isWasmInitialized) {
19243 throw new Error("initializeWasm() must be awaited first!");
19245 const nativeResponseValue = wasm.TS_Init_free(this_obj);
19246 // debug statements here
19248 // struct LDKInitFeatures Init_get_features(const struct LDKInit *NONNULL_PTR this_ptr);
19250 export function Init_get_features(this_ptr: number): number {
19251 if(!isWasmInitialized) {
19252 throw new Error("initializeWasm() must be awaited first!");
19254 const nativeResponseValue = wasm.TS_Init_get_features(this_ptr);
19255 return nativeResponseValue;
19257 // void Init_set_features(struct LDKInit *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
19259 export function Init_set_features(this_ptr: number, val: number): void {
19260 if(!isWasmInitialized) {
19261 throw new Error("initializeWasm() must be awaited first!");
19263 const nativeResponseValue = wasm.TS_Init_set_features(this_ptr, val);
19264 // debug statements here
19266 // MUST_USE_RES struct LDKInit Init_new(struct LDKInitFeatures features_arg);
19268 export function Init_new(features_arg: number): number {
19269 if(!isWasmInitialized) {
19270 throw new Error("initializeWasm() must be awaited first!");
19272 const nativeResponseValue = wasm.TS_Init_new(features_arg);
19273 return nativeResponseValue;
19275 // uintptr_t Init_clone_ptr(LDKInit *NONNULL_PTR arg);
19277 export function Init_clone_ptr(arg: number): number {
19278 if(!isWasmInitialized) {
19279 throw new Error("initializeWasm() must be awaited first!");
19281 const nativeResponseValue = wasm.TS_Init_clone_ptr(arg);
19282 return nativeResponseValue;
19284 // struct LDKInit Init_clone(const struct LDKInit *NONNULL_PTR orig);
19286 export function Init_clone(orig: number): number {
19287 if(!isWasmInitialized) {
19288 throw new Error("initializeWasm() must be awaited first!");
19290 const nativeResponseValue = wasm.TS_Init_clone(orig);
19291 return nativeResponseValue;
19293 // void ErrorMessage_free(struct LDKErrorMessage this_obj);
19295 export function ErrorMessage_free(this_obj: number): void {
19296 if(!isWasmInitialized) {
19297 throw new Error("initializeWasm() must be awaited first!");
19299 const nativeResponseValue = wasm.TS_ErrorMessage_free(this_obj);
19300 // debug statements here
19302 // const uint8_t (*ErrorMessage_get_channel_id(const struct LDKErrorMessage *NONNULL_PTR this_ptr))[32];
19304 export function ErrorMessage_get_channel_id(this_ptr: number): number {
19305 if(!isWasmInitialized) {
19306 throw new Error("initializeWasm() must be awaited first!");
19308 const nativeResponseValue = wasm.TS_ErrorMessage_get_channel_id(this_ptr);
19309 return nativeResponseValue;
19311 // void ErrorMessage_set_channel_id(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19313 export function ErrorMessage_set_channel_id(this_ptr: number, val: number): void {
19314 if(!isWasmInitialized) {
19315 throw new Error("initializeWasm() must be awaited first!");
19317 const nativeResponseValue = wasm.TS_ErrorMessage_set_channel_id(this_ptr, val);
19318 // debug statements here
19320 // struct LDKStr ErrorMessage_get_data(const struct LDKErrorMessage *NONNULL_PTR this_ptr);
19322 export function ErrorMessage_get_data(this_ptr: number): number {
19323 if(!isWasmInitialized) {
19324 throw new Error("initializeWasm() must be awaited first!");
19326 const nativeResponseValue = wasm.TS_ErrorMessage_get_data(this_ptr);
19327 return nativeResponseValue;
19329 // void ErrorMessage_set_data(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKStr val);
19331 export function ErrorMessage_set_data(this_ptr: number, val: number): void {
19332 if(!isWasmInitialized) {
19333 throw new Error("initializeWasm() must be awaited first!");
19335 const nativeResponseValue = wasm.TS_ErrorMessage_set_data(this_ptr, val);
19336 // debug statements here
19338 // MUST_USE_RES struct LDKErrorMessage ErrorMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
19340 export function ErrorMessage_new(channel_id_arg: number, data_arg: number): number {
19341 if(!isWasmInitialized) {
19342 throw new Error("initializeWasm() must be awaited first!");
19344 const nativeResponseValue = wasm.TS_ErrorMessage_new(channel_id_arg, data_arg);
19345 return nativeResponseValue;
19347 // uintptr_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg);
19349 export function ErrorMessage_clone_ptr(arg: number): number {
19350 if(!isWasmInitialized) {
19351 throw new Error("initializeWasm() must be awaited first!");
19353 const nativeResponseValue = wasm.TS_ErrorMessage_clone_ptr(arg);
19354 return nativeResponseValue;
19356 // struct LDKErrorMessage ErrorMessage_clone(const struct LDKErrorMessage *NONNULL_PTR orig);
19358 export function ErrorMessage_clone(orig: number): number {
19359 if(!isWasmInitialized) {
19360 throw new Error("initializeWasm() must be awaited first!");
19362 const nativeResponseValue = wasm.TS_ErrorMessage_clone(orig);
19363 return nativeResponseValue;
19365 // void WarningMessage_free(struct LDKWarningMessage this_obj);
19367 export function WarningMessage_free(this_obj: number): void {
19368 if(!isWasmInitialized) {
19369 throw new Error("initializeWasm() must be awaited first!");
19371 const nativeResponseValue = wasm.TS_WarningMessage_free(this_obj);
19372 // debug statements here
19374 // const uint8_t (*WarningMessage_get_channel_id(const struct LDKWarningMessage *NONNULL_PTR this_ptr))[32];
19376 export function WarningMessage_get_channel_id(this_ptr: number): number {
19377 if(!isWasmInitialized) {
19378 throw new Error("initializeWasm() must be awaited first!");
19380 const nativeResponseValue = wasm.TS_WarningMessage_get_channel_id(this_ptr);
19381 return nativeResponseValue;
19383 // void WarningMessage_set_channel_id(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19385 export function WarningMessage_set_channel_id(this_ptr: number, val: number): void {
19386 if(!isWasmInitialized) {
19387 throw new Error("initializeWasm() must be awaited first!");
19389 const nativeResponseValue = wasm.TS_WarningMessage_set_channel_id(this_ptr, val);
19390 // debug statements here
19392 // struct LDKStr WarningMessage_get_data(const struct LDKWarningMessage *NONNULL_PTR this_ptr);
19394 export function WarningMessage_get_data(this_ptr: number): number {
19395 if(!isWasmInitialized) {
19396 throw new Error("initializeWasm() must be awaited first!");
19398 const nativeResponseValue = wasm.TS_WarningMessage_get_data(this_ptr);
19399 return nativeResponseValue;
19401 // void WarningMessage_set_data(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKStr val);
19403 export function WarningMessage_set_data(this_ptr: number, val: number): void {
19404 if(!isWasmInitialized) {
19405 throw new Error("initializeWasm() must be awaited first!");
19407 const nativeResponseValue = wasm.TS_WarningMessage_set_data(this_ptr, val);
19408 // debug statements here
19410 // MUST_USE_RES struct LDKWarningMessage WarningMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
19412 export function WarningMessage_new(channel_id_arg: number, data_arg: number): number {
19413 if(!isWasmInitialized) {
19414 throw new Error("initializeWasm() must be awaited first!");
19416 const nativeResponseValue = wasm.TS_WarningMessage_new(channel_id_arg, data_arg);
19417 return nativeResponseValue;
19419 // uintptr_t WarningMessage_clone_ptr(LDKWarningMessage *NONNULL_PTR arg);
19421 export function WarningMessage_clone_ptr(arg: number): number {
19422 if(!isWasmInitialized) {
19423 throw new Error("initializeWasm() must be awaited first!");
19425 const nativeResponseValue = wasm.TS_WarningMessage_clone_ptr(arg);
19426 return nativeResponseValue;
19428 // struct LDKWarningMessage WarningMessage_clone(const struct LDKWarningMessage *NONNULL_PTR orig);
19430 export function WarningMessage_clone(orig: number): number {
19431 if(!isWasmInitialized) {
19432 throw new Error("initializeWasm() must be awaited first!");
19434 const nativeResponseValue = wasm.TS_WarningMessage_clone(orig);
19435 return nativeResponseValue;
19437 // void Ping_free(struct LDKPing this_obj);
19439 export function Ping_free(this_obj: number): void {
19440 if(!isWasmInitialized) {
19441 throw new Error("initializeWasm() must be awaited first!");
19443 const nativeResponseValue = wasm.TS_Ping_free(this_obj);
19444 // debug statements here
19446 // uint16_t Ping_get_ponglen(const struct LDKPing *NONNULL_PTR this_ptr);
19448 export function Ping_get_ponglen(this_ptr: number): number {
19449 if(!isWasmInitialized) {
19450 throw new Error("initializeWasm() must be awaited first!");
19452 const nativeResponseValue = wasm.TS_Ping_get_ponglen(this_ptr);
19453 return nativeResponseValue;
19455 // void Ping_set_ponglen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
19457 export function Ping_set_ponglen(this_ptr: number, val: number): void {
19458 if(!isWasmInitialized) {
19459 throw new Error("initializeWasm() must be awaited first!");
19461 const nativeResponseValue = wasm.TS_Ping_set_ponglen(this_ptr, val);
19462 // debug statements here
19464 // uint16_t Ping_get_byteslen(const struct LDKPing *NONNULL_PTR this_ptr);
19466 export function Ping_get_byteslen(this_ptr: number): number {
19467 if(!isWasmInitialized) {
19468 throw new Error("initializeWasm() must be awaited first!");
19470 const nativeResponseValue = wasm.TS_Ping_get_byteslen(this_ptr);
19471 return nativeResponseValue;
19473 // void Ping_set_byteslen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
19475 export function Ping_set_byteslen(this_ptr: number, val: number): void {
19476 if(!isWasmInitialized) {
19477 throw new Error("initializeWasm() must be awaited first!");
19479 const nativeResponseValue = wasm.TS_Ping_set_byteslen(this_ptr, val);
19480 // debug statements here
19482 // MUST_USE_RES struct LDKPing Ping_new(uint16_t ponglen_arg, uint16_t byteslen_arg);
19484 export function Ping_new(ponglen_arg: number, byteslen_arg: number): number {
19485 if(!isWasmInitialized) {
19486 throw new Error("initializeWasm() must be awaited first!");
19488 const nativeResponseValue = wasm.TS_Ping_new(ponglen_arg, byteslen_arg);
19489 return nativeResponseValue;
19491 // uintptr_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg);
19493 export function Ping_clone_ptr(arg: number): number {
19494 if(!isWasmInitialized) {
19495 throw new Error("initializeWasm() must be awaited first!");
19497 const nativeResponseValue = wasm.TS_Ping_clone_ptr(arg);
19498 return nativeResponseValue;
19500 // struct LDKPing Ping_clone(const struct LDKPing *NONNULL_PTR orig);
19502 export function Ping_clone(orig: number): number {
19503 if(!isWasmInitialized) {
19504 throw new Error("initializeWasm() must be awaited first!");
19506 const nativeResponseValue = wasm.TS_Ping_clone(orig);
19507 return nativeResponseValue;
19509 // void Pong_free(struct LDKPong this_obj);
19511 export function Pong_free(this_obj: number): void {
19512 if(!isWasmInitialized) {
19513 throw new Error("initializeWasm() must be awaited first!");
19515 const nativeResponseValue = wasm.TS_Pong_free(this_obj);
19516 // debug statements here
19518 // uint16_t Pong_get_byteslen(const struct LDKPong *NONNULL_PTR this_ptr);
19520 export function Pong_get_byteslen(this_ptr: number): number {
19521 if(!isWasmInitialized) {
19522 throw new Error("initializeWasm() must be awaited first!");
19524 const nativeResponseValue = wasm.TS_Pong_get_byteslen(this_ptr);
19525 return nativeResponseValue;
19527 // void Pong_set_byteslen(struct LDKPong *NONNULL_PTR this_ptr, uint16_t val);
19529 export function Pong_set_byteslen(this_ptr: number, val: number): void {
19530 if(!isWasmInitialized) {
19531 throw new Error("initializeWasm() must be awaited first!");
19533 const nativeResponseValue = wasm.TS_Pong_set_byteslen(this_ptr, val);
19534 // debug statements here
19536 // MUST_USE_RES struct LDKPong Pong_new(uint16_t byteslen_arg);
19538 export function Pong_new(byteslen_arg: number): number {
19539 if(!isWasmInitialized) {
19540 throw new Error("initializeWasm() must be awaited first!");
19542 const nativeResponseValue = wasm.TS_Pong_new(byteslen_arg);
19543 return nativeResponseValue;
19545 // uintptr_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg);
19547 export function Pong_clone_ptr(arg: number): number {
19548 if(!isWasmInitialized) {
19549 throw new Error("initializeWasm() must be awaited first!");
19551 const nativeResponseValue = wasm.TS_Pong_clone_ptr(arg);
19552 return nativeResponseValue;
19554 // struct LDKPong Pong_clone(const struct LDKPong *NONNULL_PTR orig);
19556 export function Pong_clone(orig: number): number {
19557 if(!isWasmInitialized) {
19558 throw new Error("initializeWasm() must be awaited first!");
19560 const nativeResponseValue = wasm.TS_Pong_clone(orig);
19561 return nativeResponseValue;
19563 // void OpenChannel_free(struct LDKOpenChannel this_obj);
19565 export function OpenChannel_free(this_obj: number): void {
19566 if(!isWasmInitialized) {
19567 throw new Error("initializeWasm() must be awaited first!");
19569 const nativeResponseValue = wasm.TS_OpenChannel_free(this_obj);
19570 // debug statements here
19572 // const uint8_t (*OpenChannel_get_chain_hash(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
19574 export function OpenChannel_get_chain_hash(this_ptr: number): number {
19575 if(!isWasmInitialized) {
19576 throw new Error("initializeWasm() must be awaited first!");
19578 const nativeResponseValue = wasm.TS_OpenChannel_get_chain_hash(this_ptr);
19579 return nativeResponseValue;
19581 // void OpenChannel_set_chain_hash(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19583 export function OpenChannel_set_chain_hash(this_ptr: number, val: number): void {
19584 if(!isWasmInitialized) {
19585 throw new Error("initializeWasm() must be awaited first!");
19587 const nativeResponseValue = wasm.TS_OpenChannel_set_chain_hash(this_ptr, val);
19588 // debug statements here
19590 // const uint8_t (*OpenChannel_get_temporary_channel_id(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
19592 export function OpenChannel_get_temporary_channel_id(this_ptr: number): number {
19593 if(!isWasmInitialized) {
19594 throw new Error("initializeWasm() must be awaited first!");
19596 const nativeResponseValue = wasm.TS_OpenChannel_get_temporary_channel_id(this_ptr);
19597 return nativeResponseValue;
19599 // void OpenChannel_set_temporary_channel_id(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19601 export function OpenChannel_set_temporary_channel_id(this_ptr: number, val: number): void {
19602 if(!isWasmInitialized) {
19603 throw new Error("initializeWasm() must be awaited first!");
19605 const nativeResponseValue = wasm.TS_OpenChannel_set_temporary_channel_id(this_ptr, val);
19606 // debug statements here
19608 // uint64_t OpenChannel_get_funding_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19610 export function OpenChannel_get_funding_satoshis(this_ptr: number): bigint {
19611 if(!isWasmInitialized) {
19612 throw new Error("initializeWasm() must be awaited first!");
19614 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_satoshis(this_ptr);
19615 return nativeResponseValue;
19617 // void OpenChannel_set_funding_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
19619 export function OpenChannel_set_funding_satoshis(this_ptr: number, val: bigint): void {
19620 if(!isWasmInitialized) {
19621 throw new Error("initializeWasm() must be awaited first!");
19623 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_satoshis(this_ptr, val);
19624 // debug statements here
19626 // uint64_t OpenChannel_get_push_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19628 export function OpenChannel_get_push_msat(this_ptr: number): bigint {
19629 if(!isWasmInitialized) {
19630 throw new Error("initializeWasm() must be awaited first!");
19632 const nativeResponseValue = wasm.TS_OpenChannel_get_push_msat(this_ptr);
19633 return nativeResponseValue;
19635 // void OpenChannel_set_push_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
19637 export function OpenChannel_set_push_msat(this_ptr: number, val: bigint): void {
19638 if(!isWasmInitialized) {
19639 throw new Error("initializeWasm() must be awaited first!");
19641 const nativeResponseValue = wasm.TS_OpenChannel_set_push_msat(this_ptr, val);
19642 // debug statements here
19644 // uint64_t OpenChannel_get_dust_limit_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19646 export function OpenChannel_get_dust_limit_satoshis(this_ptr: number): bigint {
19647 if(!isWasmInitialized) {
19648 throw new Error("initializeWasm() must be awaited first!");
19650 const nativeResponseValue = wasm.TS_OpenChannel_get_dust_limit_satoshis(this_ptr);
19651 return nativeResponseValue;
19653 // void OpenChannel_set_dust_limit_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
19655 export function OpenChannel_set_dust_limit_satoshis(this_ptr: number, val: bigint): void {
19656 if(!isWasmInitialized) {
19657 throw new Error("initializeWasm() must be awaited first!");
19659 const nativeResponseValue = wasm.TS_OpenChannel_set_dust_limit_satoshis(this_ptr, val);
19660 // debug statements here
19662 // uint64_t OpenChannel_get_max_htlc_value_in_flight_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19664 export function OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
19665 if(!isWasmInitialized) {
19666 throw new Error("initializeWasm() must be awaited first!");
19668 const nativeResponseValue = wasm.TS_OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr);
19669 return nativeResponseValue;
19671 // void OpenChannel_set_max_htlc_value_in_flight_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
19673 export function OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
19674 if(!isWasmInitialized) {
19675 throw new Error("initializeWasm() must be awaited first!");
19677 const nativeResponseValue = wasm.TS_OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
19678 // debug statements here
19680 // uint64_t OpenChannel_get_channel_reserve_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19682 export function OpenChannel_get_channel_reserve_satoshis(this_ptr: number): bigint {
19683 if(!isWasmInitialized) {
19684 throw new Error("initializeWasm() must be awaited first!");
19686 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_reserve_satoshis(this_ptr);
19687 return nativeResponseValue;
19689 // void OpenChannel_set_channel_reserve_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
19691 export function OpenChannel_set_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
19692 if(!isWasmInitialized) {
19693 throw new Error("initializeWasm() must be awaited first!");
19695 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_reserve_satoshis(this_ptr, val);
19696 // debug statements here
19698 // uint64_t OpenChannel_get_htlc_minimum_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19700 export function OpenChannel_get_htlc_minimum_msat(this_ptr: number): bigint {
19701 if(!isWasmInitialized) {
19702 throw new Error("initializeWasm() must be awaited first!");
19704 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_minimum_msat(this_ptr);
19705 return nativeResponseValue;
19707 // void OpenChannel_set_htlc_minimum_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
19709 export function OpenChannel_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
19710 if(!isWasmInitialized) {
19711 throw new Error("initializeWasm() must be awaited first!");
19713 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_minimum_msat(this_ptr, val);
19714 // debug statements here
19716 // uint32_t OpenChannel_get_feerate_per_kw(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19718 export function OpenChannel_get_feerate_per_kw(this_ptr: number): number {
19719 if(!isWasmInitialized) {
19720 throw new Error("initializeWasm() must be awaited first!");
19722 const nativeResponseValue = wasm.TS_OpenChannel_get_feerate_per_kw(this_ptr);
19723 return nativeResponseValue;
19725 // void OpenChannel_set_feerate_per_kw(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint32_t val);
19727 export function OpenChannel_set_feerate_per_kw(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_feerate_per_kw(this_ptr, val);
19732 // debug statements here
19734 // uint16_t OpenChannel_get_to_self_delay(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19736 export function OpenChannel_get_to_self_delay(this_ptr: number): number {
19737 if(!isWasmInitialized) {
19738 throw new Error("initializeWasm() must be awaited first!");
19740 const nativeResponseValue = wasm.TS_OpenChannel_get_to_self_delay(this_ptr);
19741 return nativeResponseValue;
19743 // void OpenChannel_set_to_self_delay(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
19745 export function OpenChannel_set_to_self_delay(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_to_self_delay(this_ptr, val);
19750 // debug statements here
19752 // uint16_t OpenChannel_get_max_accepted_htlcs(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19754 export function OpenChannel_get_max_accepted_htlcs(this_ptr: number): number {
19755 if(!isWasmInitialized) {
19756 throw new Error("initializeWasm() must be awaited first!");
19758 const nativeResponseValue = wasm.TS_OpenChannel_get_max_accepted_htlcs(this_ptr);
19759 return nativeResponseValue;
19761 // void OpenChannel_set_max_accepted_htlcs(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
19763 export function OpenChannel_set_max_accepted_htlcs(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_max_accepted_htlcs(this_ptr, val);
19768 // debug statements here
19770 // struct LDKPublicKey OpenChannel_get_funding_pubkey(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19772 export function OpenChannel_get_funding_pubkey(this_ptr: number): number {
19773 if(!isWasmInitialized) {
19774 throw new Error("initializeWasm() must be awaited first!");
19776 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_pubkey(this_ptr);
19777 return nativeResponseValue;
19779 // void OpenChannel_set_funding_pubkey(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19781 export function OpenChannel_set_funding_pubkey(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_funding_pubkey(this_ptr, val);
19786 // debug statements here
19788 // struct LDKPublicKey OpenChannel_get_revocation_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19790 export function OpenChannel_get_revocation_basepoint(this_ptr: number): number {
19791 if(!isWasmInitialized) {
19792 throw new Error("initializeWasm() must be awaited first!");
19794 const nativeResponseValue = wasm.TS_OpenChannel_get_revocation_basepoint(this_ptr);
19795 return nativeResponseValue;
19797 // void OpenChannel_set_revocation_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19799 export function OpenChannel_set_revocation_basepoint(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_revocation_basepoint(this_ptr, val);
19804 // debug statements here
19806 // struct LDKPublicKey OpenChannel_get_payment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19808 export function OpenChannel_get_payment_point(this_ptr: number): number {
19809 if(!isWasmInitialized) {
19810 throw new Error("initializeWasm() must be awaited first!");
19812 const nativeResponseValue = wasm.TS_OpenChannel_get_payment_point(this_ptr);
19813 return nativeResponseValue;
19815 // void OpenChannel_set_payment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19817 export function OpenChannel_set_payment_point(this_ptr: number, val: number): void {
19818 if(!isWasmInitialized) {
19819 throw new Error("initializeWasm() must be awaited first!");
19821 const nativeResponseValue = wasm.TS_OpenChannel_set_payment_point(this_ptr, val);
19822 // debug statements here
19824 // struct LDKPublicKey OpenChannel_get_delayed_payment_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19826 export function OpenChannel_get_delayed_payment_basepoint(this_ptr: number): number {
19827 if(!isWasmInitialized) {
19828 throw new Error("initializeWasm() must be awaited first!");
19830 const nativeResponseValue = wasm.TS_OpenChannel_get_delayed_payment_basepoint(this_ptr);
19831 return nativeResponseValue;
19833 // void OpenChannel_set_delayed_payment_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19835 export function OpenChannel_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
19836 if(!isWasmInitialized) {
19837 throw new Error("initializeWasm() must be awaited first!");
19839 const nativeResponseValue = wasm.TS_OpenChannel_set_delayed_payment_basepoint(this_ptr, val);
19840 // debug statements here
19842 // struct LDKPublicKey OpenChannel_get_htlc_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19844 export function OpenChannel_get_htlc_basepoint(this_ptr: number): number {
19845 if(!isWasmInitialized) {
19846 throw new Error("initializeWasm() must be awaited first!");
19848 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_basepoint(this_ptr);
19849 return nativeResponseValue;
19851 // void OpenChannel_set_htlc_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19853 export function OpenChannel_set_htlc_basepoint(this_ptr: number, val: number): void {
19854 if(!isWasmInitialized) {
19855 throw new Error("initializeWasm() must be awaited first!");
19857 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_basepoint(this_ptr, val);
19858 // debug statements here
19860 // struct LDKPublicKey OpenChannel_get_first_per_commitment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19862 export function OpenChannel_get_first_per_commitment_point(this_ptr: number): number {
19863 if(!isWasmInitialized) {
19864 throw new Error("initializeWasm() must be awaited first!");
19866 const nativeResponseValue = wasm.TS_OpenChannel_get_first_per_commitment_point(this_ptr);
19867 return nativeResponseValue;
19869 // void OpenChannel_set_first_per_commitment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19871 export function OpenChannel_set_first_per_commitment_point(this_ptr: number, val: number): void {
19872 if(!isWasmInitialized) {
19873 throw new Error("initializeWasm() must be awaited first!");
19875 const nativeResponseValue = wasm.TS_OpenChannel_set_first_per_commitment_point(this_ptr, val);
19876 // debug statements here
19878 // uint8_t OpenChannel_get_channel_flags(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19880 export function OpenChannel_get_channel_flags(this_ptr: number): number {
19881 if(!isWasmInitialized) {
19882 throw new Error("initializeWasm() must be awaited first!");
19884 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_flags(this_ptr);
19885 return nativeResponseValue;
19887 // void OpenChannel_set_channel_flags(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint8_t val);
19889 export function OpenChannel_set_channel_flags(this_ptr: number, val: number): void {
19890 if(!isWasmInitialized) {
19891 throw new Error("initializeWasm() must be awaited first!");
19893 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_flags(this_ptr, val);
19894 // debug statements here
19896 // struct LDKChannelTypeFeatures OpenChannel_get_channel_type(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19898 export function OpenChannel_get_channel_type(this_ptr: number): number {
19899 if(!isWasmInitialized) {
19900 throw new Error("initializeWasm() must be awaited first!");
19902 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_type(this_ptr);
19903 return nativeResponseValue;
19905 // void OpenChannel_set_channel_type(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
19907 export function OpenChannel_set_channel_type(this_ptr: number, val: number): void {
19908 if(!isWasmInitialized) {
19909 throw new Error("initializeWasm() must be awaited first!");
19911 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_type(this_ptr, val);
19912 // debug statements here
19914 // uintptr_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg);
19916 export function OpenChannel_clone_ptr(arg: number): number {
19917 if(!isWasmInitialized) {
19918 throw new Error("initializeWasm() must be awaited first!");
19920 const nativeResponseValue = wasm.TS_OpenChannel_clone_ptr(arg);
19921 return nativeResponseValue;
19923 // struct LDKOpenChannel OpenChannel_clone(const struct LDKOpenChannel *NONNULL_PTR orig);
19925 export function OpenChannel_clone(orig: number): number {
19926 if(!isWasmInitialized) {
19927 throw new Error("initializeWasm() must be awaited first!");
19929 const nativeResponseValue = wasm.TS_OpenChannel_clone(orig);
19930 return nativeResponseValue;
19932 // void AcceptChannel_free(struct LDKAcceptChannel this_obj);
19934 export function AcceptChannel_free(this_obj: number): void {
19935 if(!isWasmInitialized) {
19936 throw new Error("initializeWasm() must be awaited first!");
19938 const nativeResponseValue = wasm.TS_AcceptChannel_free(this_obj);
19939 // debug statements here
19941 // const uint8_t (*AcceptChannel_get_temporary_channel_id(const struct LDKAcceptChannel *NONNULL_PTR this_ptr))[32];
19943 export function AcceptChannel_get_temporary_channel_id(this_ptr: number): number {
19944 if(!isWasmInitialized) {
19945 throw new Error("initializeWasm() must be awaited first!");
19947 const nativeResponseValue = wasm.TS_AcceptChannel_get_temporary_channel_id(this_ptr);
19948 return nativeResponseValue;
19950 // void AcceptChannel_set_temporary_channel_id(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19952 export function AcceptChannel_set_temporary_channel_id(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_temporary_channel_id(this_ptr, val);
19957 // debug statements here
19959 // uint64_t AcceptChannel_get_dust_limit_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
19961 export function AcceptChannel_get_dust_limit_satoshis(this_ptr: number): bigint {
19962 if(!isWasmInitialized) {
19963 throw new Error("initializeWasm() must be awaited first!");
19965 const nativeResponseValue = wasm.TS_AcceptChannel_get_dust_limit_satoshis(this_ptr);
19966 return nativeResponseValue;
19968 // void AcceptChannel_set_dust_limit_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
19970 export function AcceptChannel_set_dust_limit_satoshis(this_ptr: number, val: bigint): void {
19971 if(!isWasmInitialized) {
19972 throw new Error("initializeWasm() must be awaited first!");
19974 const nativeResponseValue = wasm.TS_AcceptChannel_set_dust_limit_satoshis(this_ptr, val);
19975 // debug statements here
19977 // uint64_t AcceptChannel_get_max_htlc_value_in_flight_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
19979 export function AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
19980 if(!isWasmInitialized) {
19981 throw new Error("initializeWasm() must be awaited first!");
19983 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr);
19984 return nativeResponseValue;
19986 // void AcceptChannel_set_max_htlc_value_in_flight_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
19988 export function AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
19989 if(!isWasmInitialized) {
19990 throw new Error("initializeWasm() must be awaited first!");
19992 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
19993 // debug statements here
19995 // uint64_t AcceptChannel_get_channel_reserve_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
19997 export function AcceptChannel_get_channel_reserve_satoshis(this_ptr: number): bigint {
19998 if(!isWasmInitialized) {
19999 throw new Error("initializeWasm() must be awaited first!");
20001 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_reserve_satoshis(this_ptr);
20002 return nativeResponseValue;
20004 // void AcceptChannel_set_channel_reserve_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
20006 export function AcceptChannel_set_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
20007 if(!isWasmInitialized) {
20008 throw new Error("initializeWasm() must be awaited first!");
20010 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_reserve_satoshis(this_ptr, val);
20011 // debug statements here
20013 // uint64_t AcceptChannel_get_htlc_minimum_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20015 export function AcceptChannel_get_htlc_minimum_msat(this_ptr: number): bigint {
20016 if(!isWasmInitialized) {
20017 throw new Error("initializeWasm() must be awaited first!");
20019 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_minimum_msat(this_ptr);
20020 return nativeResponseValue;
20022 // void AcceptChannel_set_htlc_minimum_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
20024 export function AcceptChannel_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
20025 if(!isWasmInitialized) {
20026 throw new Error("initializeWasm() must be awaited first!");
20028 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_minimum_msat(this_ptr, val);
20029 // debug statements here
20031 // uint32_t AcceptChannel_get_minimum_depth(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20033 export function AcceptChannel_get_minimum_depth(this_ptr: number): number {
20034 if(!isWasmInitialized) {
20035 throw new Error("initializeWasm() must be awaited first!");
20037 const nativeResponseValue = wasm.TS_AcceptChannel_get_minimum_depth(this_ptr);
20038 return nativeResponseValue;
20040 // void AcceptChannel_set_minimum_depth(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint32_t val);
20042 export function AcceptChannel_set_minimum_depth(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_minimum_depth(this_ptr, val);
20047 // debug statements here
20049 // uint16_t AcceptChannel_get_to_self_delay(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20051 export function AcceptChannel_get_to_self_delay(this_ptr: number): number {
20052 if(!isWasmInitialized) {
20053 throw new Error("initializeWasm() must be awaited first!");
20055 const nativeResponseValue = wasm.TS_AcceptChannel_get_to_self_delay(this_ptr);
20056 return nativeResponseValue;
20058 // void AcceptChannel_set_to_self_delay(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
20060 export function AcceptChannel_set_to_self_delay(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_to_self_delay(this_ptr, val);
20065 // debug statements here
20067 // uint16_t AcceptChannel_get_max_accepted_htlcs(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20069 export function AcceptChannel_get_max_accepted_htlcs(this_ptr: number): number {
20070 if(!isWasmInitialized) {
20071 throw new Error("initializeWasm() must be awaited first!");
20073 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_accepted_htlcs(this_ptr);
20074 return nativeResponseValue;
20076 // void AcceptChannel_set_max_accepted_htlcs(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
20078 export function AcceptChannel_set_max_accepted_htlcs(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_max_accepted_htlcs(this_ptr, val);
20083 // debug statements here
20085 // struct LDKPublicKey AcceptChannel_get_funding_pubkey(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20087 export function AcceptChannel_get_funding_pubkey(this_ptr: number): number {
20088 if(!isWasmInitialized) {
20089 throw new Error("initializeWasm() must be awaited first!");
20091 const nativeResponseValue = wasm.TS_AcceptChannel_get_funding_pubkey(this_ptr);
20092 return nativeResponseValue;
20094 // void AcceptChannel_set_funding_pubkey(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20096 export function AcceptChannel_set_funding_pubkey(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_funding_pubkey(this_ptr, val);
20101 // debug statements here
20103 // struct LDKPublicKey AcceptChannel_get_revocation_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20105 export function AcceptChannel_get_revocation_basepoint(this_ptr: number): number {
20106 if(!isWasmInitialized) {
20107 throw new Error("initializeWasm() must be awaited first!");
20109 const nativeResponseValue = wasm.TS_AcceptChannel_get_revocation_basepoint(this_ptr);
20110 return nativeResponseValue;
20112 // void AcceptChannel_set_revocation_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20114 export function AcceptChannel_set_revocation_basepoint(this_ptr: number, val: number): void {
20115 if(!isWasmInitialized) {
20116 throw new Error("initializeWasm() must be awaited first!");
20118 const nativeResponseValue = wasm.TS_AcceptChannel_set_revocation_basepoint(this_ptr, val);
20119 // debug statements here
20121 // struct LDKPublicKey AcceptChannel_get_payment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20123 export function AcceptChannel_get_payment_point(this_ptr: number): number {
20124 if(!isWasmInitialized) {
20125 throw new Error("initializeWasm() must be awaited first!");
20127 const nativeResponseValue = wasm.TS_AcceptChannel_get_payment_point(this_ptr);
20128 return nativeResponseValue;
20130 // void AcceptChannel_set_payment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20132 export function AcceptChannel_set_payment_point(this_ptr: number, val: number): void {
20133 if(!isWasmInitialized) {
20134 throw new Error("initializeWasm() must be awaited first!");
20136 const nativeResponseValue = wasm.TS_AcceptChannel_set_payment_point(this_ptr, val);
20137 // debug statements here
20139 // struct LDKPublicKey AcceptChannel_get_delayed_payment_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20141 export function AcceptChannel_get_delayed_payment_basepoint(this_ptr: number): number {
20142 if(!isWasmInitialized) {
20143 throw new Error("initializeWasm() must be awaited first!");
20145 const nativeResponseValue = wasm.TS_AcceptChannel_get_delayed_payment_basepoint(this_ptr);
20146 return nativeResponseValue;
20148 // void AcceptChannel_set_delayed_payment_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20150 export function AcceptChannel_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
20151 if(!isWasmInitialized) {
20152 throw new Error("initializeWasm() must be awaited first!");
20154 const nativeResponseValue = wasm.TS_AcceptChannel_set_delayed_payment_basepoint(this_ptr, val);
20155 // debug statements here
20157 // struct LDKPublicKey AcceptChannel_get_htlc_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20159 export function AcceptChannel_get_htlc_basepoint(this_ptr: number): number {
20160 if(!isWasmInitialized) {
20161 throw new Error("initializeWasm() must be awaited first!");
20163 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_basepoint(this_ptr);
20164 return nativeResponseValue;
20166 // void AcceptChannel_set_htlc_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20168 export function AcceptChannel_set_htlc_basepoint(this_ptr: number, val: number): void {
20169 if(!isWasmInitialized) {
20170 throw new Error("initializeWasm() must be awaited first!");
20172 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_basepoint(this_ptr, val);
20173 // debug statements here
20175 // struct LDKPublicKey AcceptChannel_get_first_per_commitment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20177 export function AcceptChannel_get_first_per_commitment_point(this_ptr: number): number {
20178 if(!isWasmInitialized) {
20179 throw new Error("initializeWasm() must be awaited first!");
20181 const nativeResponseValue = wasm.TS_AcceptChannel_get_first_per_commitment_point(this_ptr);
20182 return nativeResponseValue;
20184 // void AcceptChannel_set_first_per_commitment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20186 export function AcceptChannel_set_first_per_commitment_point(this_ptr: number, val: number): void {
20187 if(!isWasmInitialized) {
20188 throw new Error("initializeWasm() must be awaited first!");
20190 const nativeResponseValue = wasm.TS_AcceptChannel_set_first_per_commitment_point(this_ptr, val);
20191 // debug statements here
20193 // struct LDKChannelTypeFeatures AcceptChannel_get_channel_type(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20195 export function AcceptChannel_get_channel_type(this_ptr: number): number {
20196 if(!isWasmInitialized) {
20197 throw new Error("initializeWasm() must be awaited first!");
20199 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_type(this_ptr);
20200 return nativeResponseValue;
20202 // void AcceptChannel_set_channel_type(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
20204 export function AcceptChannel_set_channel_type(this_ptr: number, val: number): void {
20205 if(!isWasmInitialized) {
20206 throw new Error("initializeWasm() must be awaited first!");
20208 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_type(this_ptr, val);
20209 // debug statements here
20211 // uintptr_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg);
20213 export function AcceptChannel_clone_ptr(arg: number): number {
20214 if(!isWasmInitialized) {
20215 throw new Error("initializeWasm() must be awaited first!");
20217 const nativeResponseValue = wasm.TS_AcceptChannel_clone_ptr(arg);
20218 return nativeResponseValue;
20220 // struct LDKAcceptChannel AcceptChannel_clone(const struct LDKAcceptChannel *NONNULL_PTR orig);
20222 export function AcceptChannel_clone(orig: number): number {
20223 if(!isWasmInitialized) {
20224 throw new Error("initializeWasm() must be awaited first!");
20226 const nativeResponseValue = wasm.TS_AcceptChannel_clone(orig);
20227 return nativeResponseValue;
20229 // void FundingCreated_free(struct LDKFundingCreated this_obj);
20231 export function FundingCreated_free(this_obj: number): void {
20232 if(!isWasmInitialized) {
20233 throw new Error("initializeWasm() must be awaited first!");
20235 const nativeResponseValue = wasm.TS_FundingCreated_free(this_obj);
20236 // debug statements here
20238 // const uint8_t (*FundingCreated_get_temporary_channel_id(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
20240 export function FundingCreated_get_temporary_channel_id(this_ptr: number): number {
20241 if(!isWasmInitialized) {
20242 throw new Error("initializeWasm() must be awaited first!");
20244 const nativeResponseValue = wasm.TS_FundingCreated_get_temporary_channel_id(this_ptr);
20245 return nativeResponseValue;
20247 // void FundingCreated_set_temporary_channel_id(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20249 export function FundingCreated_set_temporary_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_FundingCreated_set_temporary_channel_id(this_ptr, val);
20254 // debug statements here
20256 // const uint8_t (*FundingCreated_get_funding_txid(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
20258 export function FundingCreated_get_funding_txid(this_ptr: number): number {
20259 if(!isWasmInitialized) {
20260 throw new Error("initializeWasm() must be awaited first!");
20262 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_txid(this_ptr);
20263 return nativeResponseValue;
20265 // void FundingCreated_set_funding_txid(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20267 export function FundingCreated_set_funding_txid(this_ptr: number, val: number): void {
20268 if(!isWasmInitialized) {
20269 throw new Error("initializeWasm() must be awaited first!");
20271 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_txid(this_ptr, val);
20272 // debug statements here
20274 // uint16_t FundingCreated_get_funding_output_index(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
20276 export function FundingCreated_get_funding_output_index(this_ptr: number): number {
20277 if(!isWasmInitialized) {
20278 throw new Error("initializeWasm() must be awaited first!");
20280 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_output_index(this_ptr);
20281 return nativeResponseValue;
20283 // void FundingCreated_set_funding_output_index(struct LDKFundingCreated *NONNULL_PTR this_ptr, uint16_t val);
20285 export function FundingCreated_set_funding_output_index(this_ptr: number, val: number): void {
20286 if(!isWasmInitialized) {
20287 throw new Error("initializeWasm() must be awaited first!");
20289 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_output_index(this_ptr, val);
20290 // debug statements here
20292 // struct LDKSignature FundingCreated_get_signature(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
20294 export function FundingCreated_get_signature(this_ptr: number): number {
20295 if(!isWasmInitialized) {
20296 throw new Error("initializeWasm() must be awaited first!");
20298 const nativeResponseValue = wasm.TS_FundingCreated_get_signature(this_ptr);
20299 return nativeResponseValue;
20301 // void FundingCreated_set_signature(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKSignature val);
20303 export function FundingCreated_set_signature(this_ptr: number, val: number): void {
20304 if(!isWasmInitialized) {
20305 throw new Error("initializeWasm() must be awaited first!");
20307 const nativeResponseValue = wasm.TS_FundingCreated_set_signature(this_ptr, val);
20308 // debug statements here
20310 // 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);
20312 export function FundingCreated_new(temporary_channel_id_arg: number, funding_txid_arg: number, funding_output_index_arg: number, signature_arg: number): number {
20313 if(!isWasmInitialized) {
20314 throw new Error("initializeWasm() must be awaited first!");
20316 const nativeResponseValue = wasm.TS_FundingCreated_new(temporary_channel_id_arg, funding_txid_arg, funding_output_index_arg, signature_arg);
20317 return nativeResponseValue;
20319 // uintptr_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg);
20321 export function FundingCreated_clone_ptr(arg: number): number {
20322 if(!isWasmInitialized) {
20323 throw new Error("initializeWasm() must be awaited first!");
20325 const nativeResponseValue = wasm.TS_FundingCreated_clone_ptr(arg);
20326 return nativeResponseValue;
20328 // struct LDKFundingCreated FundingCreated_clone(const struct LDKFundingCreated *NONNULL_PTR orig);
20330 export function FundingCreated_clone(orig: number): number {
20331 if(!isWasmInitialized) {
20332 throw new Error("initializeWasm() must be awaited first!");
20334 const nativeResponseValue = wasm.TS_FundingCreated_clone(orig);
20335 return nativeResponseValue;
20337 // void FundingSigned_free(struct LDKFundingSigned this_obj);
20339 export function FundingSigned_free(this_obj: number): void {
20340 if(!isWasmInitialized) {
20341 throw new Error("initializeWasm() must be awaited first!");
20343 const nativeResponseValue = wasm.TS_FundingSigned_free(this_obj);
20344 // debug statements here
20346 // const uint8_t (*FundingSigned_get_channel_id(const struct LDKFundingSigned *NONNULL_PTR this_ptr))[32];
20348 export function FundingSigned_get_channel_id(this_ptr: number): number {
20349 if(!isWasmInitialized) {
20350 throw new Error("initializeWasm() must be awaited first!");
20352 const nativeResponseValue = wasm.TS_FundingSigned_get_channel_id(this_ptr);
20353 return nativeResponseValue;
20355 // void FundingSigned_set_channel_id(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20357 export function FundingSigned_set_channel_id(this_ptr: number, val: number): void {
20358 if(!isWasmInitialized) {
20359 throw new Error("initializeWasm() must be awaited first!");
20361 const nativeResponseValue = wasm.TS_FundingSigned_set_channel_id(this_ptr, val);
20362 // debug statements here
20364 // struct LDKSignature FundingSigned_get_signature(const struct LDKFundingSigned *NONNULL_PTR this_ptr);
20366 export function FundingSigned_get_signature(this_ptr: number): number {
20367 if(!isWasmInitialized) {
20368 throw new Error("initializeWasm() must be awaited first!");
20370 const nativeResponseValue = wasm.TS_FundingSigned_get_signature(this_ptr);
20371 return nativeResponseValue;
20373 // void FundingSigned_set_signature(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
20375 export function FundingSigned_set_signature(this_ptr: number, val: number): void {
20376 if(!isWasmInitialized) {
20377 throw new Error("initializeWasm() must be awaited first!");
20379 const nativeResponseValue = wasm.TS_FundingSigned_set_signature(this_ptr, val);
20380 // debug statements here
20382 // MUST_USE_RES struct LDKFundingSigned FundingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg);
20384 export function FundingSigned_new(channel_id_arg: number, signature_arg: number): number {
20385 if(!isWasmInitialized) {
20386 throw new Error("initializeWasm() must be awaited first!");
20388 const nativeResponseValue = wasm.TS_FundingSigned_new(channel_id_arg, signature_arg);
20389 return nativeResponseValue;
20391 // uintptr_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg);
20393 export function FundingSigned_clone_ptr(arg: number): number {
20394 if(!isWasmInitialized) {
20395 throw new Error("initializeWasm() must be awaited first!");
20397 const nativeResponseValue = wasm.TS_FundingSigned_clone_ptr(arg);
20398 return nativeResponseValue;
20400 // struct LDKFundingSigned FundingSigned_clone(const struct LDKFundingSigned *NONNULL_PTR orig);
20402 export function FundingSigned_clone(orig: number): number {
20403 if(!isWasmInitialized) {
20404 throw new Error("initializeWasm() must be awaited first!");
20406 const nativeResponseValue = wasm.TS_FundingSigned_clone(orig);
20407 return nativeResponseValue;
20409 // void FundingLocked_free(struct LDKFundingLocked this_obj);
20411 export function FundingLocked_free(this_obj: number): void {
20412 if(!isWasmInitialized) {
20413 throw new Error("initializeWasm() must be awaited first!");
20415 const nativeResponseValue = wasm.TS_FundingLocked_free(this_obj);
20416 // debug statements here
20418 // const uint8_t (*FundingLocked_get_channel_id(const struct LDKFundingLocked *NONNULL_PTR this_ptr))[32];
20420 export function FundingLocked_get_channel_id(this_ptr: number): number {
20421 if(!isWasmInitialized) {
20422 throw new Error("initializeWasm() must be awaited first!");
20424 const nativeResponseValue = wasm.TS_FundingLocked_get_channel_id(this_ptr);
20425 return nativeResponseValue;
20427 // void FundingLocked_set_channel_id(struct LDKFundingLocked *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20429 export function FundingLocked_set_channel_id(this_ptr: number, val: number): void {
20430 if(!isWasmInitialized) {
20431 throw new Error("initializeWasm() must be awaited first!");
20433 const nativeResponseValue = wasm.TS_FundingLocked_set_channel_id(this_ptr, val);
20434 // debug statements here
20436 // struct LDKPublicKey FundingLocked_get_next_per_commitment_point(const struct LDKFundingLocked *NONNULL_PTR this_ptr);
20438 export function FundingLocked_get_next_per_commitment_point(this_ptr: number): number {
20439 if(!isWasmInitialized) {
20440 throw new Error("initializeWasm() must be awaited first!");
20442 const nativeResponseValue = wasm.TS_FundingLocked_get_next_per_commitment_point(this_ptr);
20443 return nativeResponseValue;
20445 // void FundingLocked_set_next_per_commitment_point(struct LDKFundingLocked *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20447 export function FundingLocked_set_next_per_commitment_point(this_ptr: number, val: number): void {
20448 if(!isWasmInitialized) {
20449 throw new Error("initializeWasm() must be awaited first!");
20451 const nativeResponseValue = wasm.TS_FundingLocked_set_next_per_commitment_point(this_ptr, val);
20452 // debug statements here
20454 // MUST_USE_RES struct LDKFundingLocked FundingLocked_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKPublicKey next_per_commitment_point_arg);
20456 export function FundingLocked_new(channel_id_arg: number, next_per_commitment_point_arg: number): number {
20457 if(!isWasmInitialized) {
20458 throw new Error("initializeWasm() must be awaited first!");
20460 const nativeResponseValue = wasm.TS_FundingLocked_new(channel_id_arg, next_per_commitment_point_arg);
20461 return nativeResponseValue;
20463 // uintptr_t FundingLocked_clone_ptr(LDKFundingLocked *NONNULL_PTR arg);
20465 export function FundingLocked_clone_ptr(arg: number): number {
20466 if(!isWasmInitialized) {
20467 throw new Error("initializeWasm() must be awaited first!");
20469 const nativeResponseValue = wasm.TS_FundingLocked_clone_ptr(arg);
20470 return nativeResponseValue;
20472 // struct LDKFundingLocked FundingLocked_clone(const struct LDKFundingLocked *NONNULL_PTR orig);
20474 export function FundingLocked_clone(orig: number): number {
20475 if(!isWasmInitialized) {
20476 throw new Error("initializeWasm() must be awaited first!");
20478 const nativeResponseValue = wasm.TS_FundingLocked_clone(orig);
20479 return nativeResponseValue;
20481 // void Shutdown_free(struct LDKShutdown this_obj);
20483 export function Shutdown_free(this_obj: number): void {
20484 if(!isWasmInitialized) {
20485 throw new Error("initializeWasm() must be awaited first!");
20487 const nativeResponseValue = wasm.TS_Shutdown_free(this_obj);
20488 // debug statements here
20490 // const uint8_t (*Shutdown_get_channel_id(const struct LDKShutdown *NONNULL_PTR this_ptr))[32];
20492 export function Shutdown_get_channel_id(this_ptr: number): number {
20493 if(!isWasmInitialized) {
20494 throw new Error("initializeWasm() must be awaited first!");
20496 const nativeResponseValue = wasm.TS_Shutdown_get_channel_id(this_ptr);
20497 return nativeResponseValue;
20499 // void Shutdown_set_channel_id(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20501 export function Shutdown_set_channel_id(this_ptr: number, val: number): void {
20502 if(!isWasmInitialized) {
20503 throw new Error("initializeWasm() must be awaited first!");
20505 const nativeResponseValue = wasm.TS_Shutdown_set_channel_id(this_ptr, val);
20506 // debug statements here
20508 // struct LDKu8slice Shutdown_get_scriptpubkey(const struct LDKShutdown *NONNULL_PTR this_ptr);
20510 export function Shutdown_get_scriptpubkey(this_ptr: number): number {
20511 if(!isWasmInitialized) {
20512 throw new Error("initializeWasm() must be awaited first!");
20514 const nativeResponseValue = wasm.TS_Shutdown_get_scriptpubkey(this_ptr);
20515 return nativeResponseValue;
20517 // void Shutdown_set_scriptpubkey(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
20519 export function Shutdown_set_scriptpubkey(this_ptr: number, val: number): void {
20520 if(!isWasmInitialized) {
20521 throw new Error("initializeWasm() must be awaited first!");
20523 const nativeResponseValue = wasm.TS_Shutdown_set_scriptpubkey(this_ptr, val);
20524 // debug statements here
20526 // MUST_USE_RES struct LDKShutdown Shutdown_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z scriptpubkey_arg);
20528 export function Shutdown_new(channel_id_arg: number, scriptpubkey_arg: number): number {
20529 if(!isWasmInitialized) {
20530 throw new Error("initializeWasm() must be awaited first!");
20532 const nativeResponseValue = wasm.TS_Shutdown_new(channel_id_arg, scriptpubkey_arg);
20533 return nativeResponseValue;
20535 // uintptr_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg);
20537 export function Shutdown_clone_ptr(arg: number): number {
20538 if(!isWasmInitialized) {
20539 throw new Error("initializeWasm() must be awaited first!");
20541 const nativeResponseValue = wasm.TS_Shutdown_clone_ptr(arg);
20542 return nativeResponseValue;
20544 // struct LDKShutdown Shutdown_clone(const struct LDKShutdown *NONNULL_PTR orig);
20546 export function Shutdown_clone(orig: number): number {
20547 if(!isWasmInitialized) {
20548 throw new Error("initializeWasm() must be awaited first!");
20550 const nativeResponseValue = wasm.TS_Shutdown_clone(orig);
20551 return nativeResponseValue;
20553 // void ClosingSignedFeeRange_free(struct LDKClosingSignedFeeRange this_obj);
20555 export function ClosingSignedFeeRange_free(this_obj: number): void {
20556 if(!isWasmInitialized) {
20557 throw new Error("initializeWasm() must be awaited first!");
20559 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_free(this_obj);
20560 // debug statements here
20562 // uint64_t ClosingSignedFeeRange_get_min_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
20564 export function ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr: number): bigint {
20565 if(!isWasmInitialized) {
20566 throw new Error("initializeWasm() must be awaited first!");
20568 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr);
20569 return nativeResponseValue;
20571 // void ClosingSignedFeeRange_set_min_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
20573 export function ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr: number, val: bigint): void {
20574 if(!isWasmInitialized) {
20575 throw new Error("initializeWasm() must be awaited first!");
20577 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr, val);
20578 // debug statements here
20580 // uint64_t ClosingSignedFeeRange_get_max_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
20582 export function ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr: number): bigint {
20583 if(!isWasmInitialized) {
20584 throw new Error("initializeWasm() must be awaited first!");
20586 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr);
20587 return nativeResponseValue;
20589 // void ClosingSignedFeeRange_set_max_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
20591 export function ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr: number, val: bigint): void {
20592 if(!isWasmInitialized) {
20593 throw new Error("initializeWasm() must be awaited first!");
20595 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr, val);
20596 // debug statements here
20598 // MUST_USE_RES struct LDKClosingSignedFeeRange ClosingSignedFeeRange_new(uint64_t min_fee_satoshis_arg, uint64_t max_fee_satoshis_arg);
20600 export function ClosingSignedFeeRange_new(min_fee_satoshis_arg: bigint, max_fee_satoshis_arg: bigint): number {
20601 if(!isWasmInitialized) {
20602 throw new Error("initializeWasm() must be awaited first!");
20604 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
20605 return nativeResponseValue;
20607 // uintptr_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg);
20609 export function ClosingSignedFeeRange_clone_ptr(arg: number): number {
20610 if(!isWasmInitialized) {
20611 throw new Error("initializeWasm() must be awaited first!");
20613 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone_ptr(arg);
20614 return nativeResponseValue;
20616 // struct LDKClosingSignedFeeRange ClosingSignedFeeRange_clone(const struct LDKClosingSignedFeeRange *NONNULL_PTR orig);
20618 export function ClosingSignedFeeRange_clone(orig: number): number {
20619 if(!isWasmInitialized) {
20620 throw new Error("initializeWasm() must be awaited first!");
20622 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone(orig);
20623 return nativeResponseValue;
20625 // void ClosingSigned_free(struct LDKClosingSigned this_obj);
20627 export function ClosingSigned_free(this_obj: number): void {
20628 if(!isWasmInitialized) {
20629 throw new Error("initializeWasm() must be awaited first!");
20631 const nativeResponseValue = wasm.TS_ClosingSigned_free(this_obj);
20632 // debug statements here
20634 // const uint8_t (*ClosingSigned_get_channel_id(const struct LDKClosingSigned *NONNULL_PTR this_ptr))[32];
20636 export function ClosingSigned_get_channel_id(this_ptr: number): number {
20637 if(!isWasmInitialized) {
20638 throw new Error("initializeWasm() must be awaited first!");
20640 const nativeResponseValue = wasm.TS_ClosingSigned_get_channel_id(this_ptr);
20641 return nativeResponseValue;
20643 // void ClosingSigned_set_channel_id(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20645 export function ClosingSigned_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_ClosingSigned_set_channel_id(this_ptr, val);
20650 // debug statements here
20652 // uint64_t ClosingSigned_get_fee_satoshis(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
20654 export function ClosingSigned_get_fee_satoshis(this_ptr: number): bigint {
20655 if(!isWasmInitialized) {
20656 throw new Error("initializeWasm() must be awaited first!");
20658 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_satoshis(this_ptr);
20659 return nativeResponseValue;
20661 // void ClosingSigned_set_fee_satoshis(struct LDKClosingSigned *NONNULL_PTR this_ptr, uint64_t val);
20663 export function ClosingSigned_set_fee_satoshis(this_ptr: number, val: bigint): void {
20664 if(!isWasmInitialized) {
20665 throw new Error("initializeWasm() must be awaited first!");
20667 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_satoshis(this_ptr, val);
20668 // debug statements here
20670 // struct LDKSignature ClosingSigned_get_signature(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
20672 export function ClosingSigned_get_signature(this_ptr: number): number {
20673 if(!isWasmInitialized) {
20674 throw new Error("initializeWasm() must be awaited first!");
20676 const nativeResponseValue = wasm.TS_ClosingSigned_get_signature(this_ptr);
20677 return nativeResponseValue;
20679 // void ClosingSigned_set_signature(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
20681 export function ClosingSigned_set_signature(this_ptr: number, val: number): void {
20682 if(!isWasmInitialized) {
20683 throw new Error("initializeWasm() must be awaited first!");
20685 const nativeResponseValue = wasm.TS_ClosingSigned_set_signature(this_ptr, val);
20686 // debug statements here
20688 // struct LDKClosingSignedFeeRange ClosingSigned_get_fee_range(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
20690 export function ClosingSigned_get_fee_range(this_ptr: number): number {
20691 if(!isWasmInitialized) {
20692 throw new Error("initializeWasm() must be awaited first!");
20694 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_range(this_ptr);
20695 return nativeResponseValue;
20697 // void ClosingSigned_set_fee_range(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKClosingSignedFeeRange val);
20699 export function ClosingSigned_set_fee_range(this_ptr: number, val: number): void {
20700 if(!isWasmInitialized) {
20701 throw new Error("initializeWasm() must be awaited first!");
20703 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_range(this_ptr, val);
20704 // debug statements here
20706 // 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);
20708 export function ClosingSigned_new(channel_id_arg: number, fee_satoshis_arg: bigint, signature_arg: number, fee_range_arg: number): number {
20709 if(!isWasmInitialized) {
20710 throw new Error("initializeWasm() must be awaited first!");
20712 const nativeResponseValue = wasm.TS_ClosingSigned_new(channel_id_arg, fee_satoshis_arg, signature_arg, fee_range_arg);
20713 return nativeResponseValue;
20715 // uintptr_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg);
20717 export function ClosingSigned_clone_ptr(arg: number): number {
20718 if(!isWasmInitialized) {
20719 throw new Error("initializeWasm() must be awaited first!");
20721 const nativeResponseValue = wasm.TS_ClosingSigned_clone_ptr(arg);
20722 return nativeResponseValue;
20724 // struct LDKClosingSigned ClosingSigned_clone(const struct LDKClosingSigned *NONNULL_PTR orig);
20726 export function ClosingSigned_clone(orig: number): number {
20727 if(!isWasmInitialized) {
20728 throw new Error("initializeWasm() must be awaited first!");
20730 const nativeResponseValue = wasm.TS_ClosingSigned_clone(orig);
20731 return nativeResponseValue;
20733 // void UpdateAddHTLC_free(struct LDKUpdateAddHTLC this_obj);
20735 export function UpdateAddHTLC_free(this_obj: number): void {
20736 if(!isWasmInitialized) {
20737 throw new Error("initializeWasm() must be awaited first!");
20739 const nativeResponseValue = wasm.TS_UpdateAddHTLC_free(this_obj);
20740 // debug statements here
20742 // const uint8_t (*UpdateAddHTLC_get_channel_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
20744 export function UpdateAddHTLC_get_channel_id(this_ptr: number): number {
20745 if(!isWasmInitialized) {
20746 throw new Error("initializeWasm() must be awaited first!");
20748 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_channel_id(this_ptr);
20749 return nativeResponseValue;
20751 // void UpdateAddHTLC_set_channel_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20753 export function UpdateAddHTLC_set_channel_id(this_ptr: number, val: number): void {
20754 if(!isWasmInitialized) {
20755 throw new Error("initializeWasm() must be awaited first!");
20757 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_channel_id(this_ptr, val);
20758 // debug statements here
20760 // uint64_t UpdateAddHTLC_get_htlc_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
20762 export function UpdateAddHTLC_get_htlc_id(this_ptr: number): bigint {
20763 if(!isWasmInitialized) {
20764 throw new Error("initializeWasm() must be awaited first!");
20766 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_htlc_id(this_ptr);
20767 return nativeResponseValue;
20769 // void UpdateAddHTLC_set_htlc_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
20771 export function UpdateAddHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
20772 if(!isWasmInitialized) {
20773 throw new Error("initializeWasm() must be awaited first!");
20775 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_htlc_id(this_ptr, val);
20776 // debug statements here
20778 // uint64_t UpdateAddHTLC_get_amount_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
20780 export function UpdateAddHTLC_get_amount_msat(this_ptr: number): bigint {
20781 if(!isWasmInitialized) {
20782 throw new Error("initializeWasm() must be awaited first!");
20784 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_amount_msat(this_ptr);
20785 return nativeResponseValue;
20787 // void UpdateAddHTLC_set_amount_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
20789 export function UpdateAddHTLC_set_amount_msat(this_ptr: number, val: bigint): void {
20790 if(!isWasmInitialized) {
20791 throw new Error("initializeWasm() must be awaited first!");
20793 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_amount_msat(this_ptr, val);
20794 // debug statements here
20796 // const uint8_t (*UpdateAddHTLC_get_payment_hash(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
20798 export function UpdateAddHTLC_get_payment_hash(this_ptr: number): number {
20799 if(!isWasmInitialized) {
20800 throw new Error("initializeWasm() must be awaited first!");
20802 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_payment_hash(this_ptr);
20803 return nativeResponseValue;
20805 // void UpdateAddHTLC_set_payment_hash(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20807 export function UpdateAddHTLC_set_payment_hash(this_ptr: number, val: number): void {
20808 if(!isWasmInitialized) {
20809 throw new Error("initializeWasm() must be awaited first!");
20811 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_payment_hash(this_ptr, val);
20812 // debug statements here
20814 // uint32_t UpdateAddHTLC_get_cltv_expiry(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
20816 export function UpdateAddHTLC_get_cltv_expiry(this_ptr: number): number {
20817 if(!isWasmInitialized) {
20818 throw new Error("initializeWasm() must be awaited first!");
20820 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_cltv_expiry(this_ptr);
20821 return nativeResponseValue;
20823 // void UpdateAddHTLC_set_cltv_expiry(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint32_t val);
20825 export function UpdateAddHTLC_set_cltv_expiry(this_ptr: number, val: number): void {
20826 if(!isWasmInitialized) {
20827 throw new Error("initializeWasm() must be awaited first!");
20829 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_cltv_expiry(this_ptr, val);
20830 // debug statements here
20832 // uintptr_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg);
20834 export function UpdateAddHTLC_clone_ptr(arg: number): number {
20835 if(!isWasmInitialized) {
20836 throw new Error("initializeWasm() must be awaited first!");
20838 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone_ptr(arg);
20839 return nativeResponseValue;
20841 // struct LDKUpdateAddHTLC UpdateAddHTLC_clone(const struct LDKUpdateAddHTLC *NONNULL_PTR orig);
20843 export function UpdateAddHTLC_clone(orig: number): number {
20844 if(!isWasmInitialized) {
20845 throw new Error("initializeWasm() must be awaited first!");
20847 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone(orig);
20848 return nativeResponseValue;
20850 // void UpdateFulfillHTLC_free(struct LDKUpdateFulfillHTLC this_obj);
20852 export function UpdateFulfillHTLC_free(this_obj: number): void {
20853 if(!isWasmInitialized) {
20854 throw new Error("initializeWasm() must be awaited first!");
20856 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_free(this_obj);
20857 // debug statements here
20859 // const uint8_t (*UpdateFulfillHTLC_get_channel_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
20861 export function UpdateFulfillHTLC_get_channel_id(this_ptr: number): number {
20862 if(!isWasmInitialized) {
20863 throw new Error("initializeWasm() must be awaited first!");
20865 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_channel_id(this_ptr);
20866 return nativeResponseValue;
20868 // void UpdateFulfillHTLC_set_channel_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20870 export function UpdateFulfillHTLC_set_channel_id(this_ptr: number, val: number): void {
20871 if(!isWasmInitialized) {
20872 throw new Error("initializeWasm() must be awaited first!");
20874 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_channel_id(this_ptr, val);
20875 // debug statements here
20877 // uint64_t UpdateFulfillHTLC_get_htlc_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr);
20879 export function UpdateFulfillHTLC_get_htlc_id(this_ptr: number): bigint {
20880 if(!isWasmInitialized) {
20881 throw new Error("initializeWasm() must be awaited first!");
20883 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_htlc_id(this_ptr);
20884 return nativeResponseValue;
20886 // void UpdateFulfillHTLC_set_htlc_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, uint64_t val);
20888 export function UpdateFulfillHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
20889 if(!isWasmInitialized) {
20890 throw new Error("initializeWasm() must be awaited first!");
20892 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_htlc_id(this_ptr, val);
20893 // debug statements here
20895 // const uint8_t (*UpdateFulfillHTLC_get_payment_preimage(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
20897 export function UpdateFulfillHTLC_get_payment_preimage(this_ptr: number): number {
20898 if(!isWasmInitialized) {
20899 throw new Error("initializeWasm() must be awaited first!");
20901 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_payment_preimage(this_ptr);
20902 return nativeResponseValue;
20904 // void UpdateFulfillHTLC_set_payment_preimage(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20906 export function UpdateFulfillHTLC_set_payment_preimage(this_ptr: number, val: number): void {
20907 if(!isWasmInitialized) {
20908 throw new Error("initializeWasm() must be awaited first!");
20910 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_payment_preimage(this_ptr, val);
20911 // debug statements here
20913 // MUST_USE_RES struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t htlc_id_arg, struct LDKThirtyTwoBytes payment_preimage_arg);
20915 export function UpdateFulfillHTLC_new(channel_id_arg: number, htlc_id_arg: bigint, payment_preimage_arg: number): number {
20916 if(!isWasmInitialized) {
20917 throw new Error("initializeWasm() must be awaited first!");
20919 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_new(channel_id_arg, htlc_id_arg, payment_preimage_arg);
20920 return nativeResponseValue;
20922 // uintptr_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg);
20924 export function UpdateFulfillHTLC_clone_ptr(arg: number): number {
20925 if(!isWasmInitialized) {
20926 throw new Error("initializeWasm() must be awaited first!");
20928 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone_ptr(arg);
20929 return nativeResponseValue;
20931 // struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_clone(const struct LDKUpdateFulfillHTLC *NONNULL_PTR orig);
20933 export function UpdateFulfillHTLC_clone(orig: number): number {
20934 if(!isWasmInitialized) {
20935 throw new Error("initializeWasm() must be awaited first!");
20937 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone(orig);
20938 return nativeResponseValue;
20940 // void UpdateFailHTLC_free(struct LDKUpdateFailHTLC this_obj);
20942 export function UpdateFailHTLC_free(this_obj: number): void {
20943 if(!isWasmInitialized) {
20944 throw new Error("initializeWasm() must be awaited first!");
20946 const nativeResponseValue = wasm.TS_UpdateFailHTLC_free(this_obj);
20947 // debug statements here
20949 // const uint8_t (*UpdateFailHTLC_get_channel_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr))[32];
20951 export function UpdateFailHTLC_get_channel_id(this_ptr: number): number {
20952 if(!isWasmInitialized) {
20953 throw new Error("initializeWasm() must be awaited first!");
20955 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_channel_id(this_ptr);
20956 return nativeResponseValue;
20958 // void UpdateFailHTLC_set_channel_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20960 export function UpdateFailHTLC_set_channel_id(this_ptr: number, val: number): void {
20961 if(!isWasmInitialized) {
20962 throw new Error("initializeWasm() must be awaited first!");
20964 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_channel_id(this_ptr, val);
20965 // debug statements here
20967 // uint64_t UpdateFailHTLC_get_htlc_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr);
20969 export function UpdateFailHTLC_get_htlc_id(this_ptr: number): bigint {
20970 if(!isWasmInitialized) {
20971 throw new Error("initializeWasm() must be awaited first!");
20973 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_htlc_id(this_ptr);
20974 return nativeResponseValue;
20976 // void UpdateFailHTLC_set_htlc_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, uint64_t val);
20978 export function UpdateFailHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
20979 if(!isWasmInitialized) {
20980 throw new Error("initializeWasm() must be awaited first!");
20982 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_htlc_id(this_ptr, val);
20983 // debug statements here
20985 // uintptr_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg);
20987 export function UpdateFailHTLC_clone_ptr(arg: number): number {
20988 if(!isWasmInitialized) {
20989 throw new Error("initializeWasm() must be awaited first!");
20991 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone_ptr(arg);
20992 return nativeResponseValue;
20994 // struct LDKUpdateFailHTLC UpdateFailHTLC_clone(const struct LDKUpdateFailHTLC *NONNULL_PTR orig);
20996 export function UpdateFailHTLC_clone(orig: number): number {
20997 if(!isWasmInitialized) {
20998 throw new Error("initializeWasm() must be awaited first!");
21000 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone(orig);
21001 return nativeResponseValue;
21003 // void UpdateFailMalformedHTLC_free(struct LDKUpdateFailMalformedHTLC this_obj);
21005 export function UpdateFailMalformedHTLC_free(this_obj: number): void {
21006 if(!isWasmInitialized) {
21007 throw new Error("initializeWasm() must be awaited first!");
21009 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_free(this_obj);
21010 // debug statements here
21012 // const uint8_t (*UpdateFailMalformedHTLC_get_channel_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr))[32];
21014 export function UpdateFailMalformedHTLC_get_channel_id(this_ptr: number): number {
21015 if(!isWasmInitialized) {
21016 throw new Error("initializeWasm() must be awaited first!");
21018 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_channel_id(this_ptr);
21019 return nativeResponseValue;
21021 // void UpdateFailMalformedHTLC_set_channel_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21023 export function UpdateFailMalformedHTLC_set_channel_id(this_ptr: number, val: number): void {
21024 if(!isWasmInitialized) {
21025 throw new Error("initializeWasm() must be awaited first!");
21027 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_channel_id(this_ptr, val);
21028 // debug statements here
21030 // uint64_t UpdateFailMalformedHTLC_get_htlc_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
21032 export function UpdateFailMalformedHTLC_get_htlc_id(this_ptr: number): bigint {
21033 if(!isWasmInitialized) {
21034 throw new Error("initializeWasm() must be awaited first!");
21036 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_htlc_id(this_ptr);
21037 return nativeResponseValue;
21039 // void UpdateFailMalformedHTLC_set_htlc_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint64_t val);
21041 export function UpdateFailMalformedHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
21042 if(!isWasmInitialized) {
21043 throw new Error("initializeWasm() must be awaited first!");
21045 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_htlc_id(this_ptr, val);
21046 // debug statements here
21048 // uint16_t UpdateFailMalformedHTLC_get_failure_code(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
21050 export function UpdateFailMalformedHTLC_get_failure_code(this_ptr: number): number {
21051 if(!isWasmInitialized) {
21052 throw new Error("initializeWasm() must be awaited first!");
21054 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_failure_code(this_ptr);
21055 return nativeResponseValue;
21057 // void UpdateFailMalformedHTLC_set_failure_code(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint16_t val);
21059 export function UpdateFailMalformedHTLC_set_failure_code(this_ptr: number, val: number): void {
21060 if(!isWasmInitialized) {
21061 throw new Error("initializeWasm() must be awaited first!");
21063 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_failure_code(this_ptr, val);
21064 // debug statements here
21066 // uintptr_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg);
21068 export function UpdateFailMalformedHTLC_clone_ptr(arg: number): number {
21069 if(!isWasmInitialized) {
21070 throw new Error("initializeWasm() must be awaited first!");
21072 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone_ptr(arg);
21073 return nativeResponseValue;
21075 // struct LDKUpdateFailMalformedHTLC UpdateFailMalformedHTLC_clone(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR orig);
21077 export function UpdateFailMalformedHTLC_clone(orig: number): number {
21078 if(!isWasmInitialized) {
21079 throw new Error("initializeWasm() must be awaited first!");
21081 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone(orig);
21082 return nativeResponseValue;
21084 // void CommitmentSigned_free(struct LDKCommitmentSigned this_obj);
21086 export function CommitmentSigned_free(this_obj: number): void {
21087 if(!isWasmInitialized) {
21088 throw new Error("initializeWasm() must be awaited first!");
21090 const nativeResponseValue = wasm.TS_CommitmentSigned_free(this_obj);
21091 // debug statements here
21093 // const uint8_t (*CommitmentSigned_get_channel_id(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr))[32];
21095 export function CommitmentSigned_get_channel_id(this_ptr: number): number {
21096 if(!isWasmInitialized) {
21097 throw new Error("initializeWasm() must be awaited first!");
21099 const nativeResponseValue = wasm.TS_CommitmentSigned_get_channel_id(this_ptr);
21100 return nativeResponseValue;
21102 // void CommitmentSigned_set_channel_id(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21104 export function CommitmentSigned_set_channel_id(this_ptr: number, val: number): void {
21105 if(!isWasmInitialized) {
21106 throw new Error("initializeWasm() must be awaited first!");
21108 const nativeResponseValue = wasm.TS_CommitmentSigned_set_channel_id(this_ptr, val);
21109 // debug statements here
21111 // struct LDKSignature CommitmentSigned_get_signature(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
21113 export function CommitmentSigned_get_signature(this_ptr: number): number {
21114 if(!isWasmInitialized) {
21115 throw new Error("initializeWasm() must be awaited first!");
21117 const nativeResponseValue = wasm.TS_CommitmentSigned_get_signature(this_ptr);
21118 return nativeResponseValue;
21120 // void CommitmentSigned_set_signature(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
21122 export function CommitmentSigned_set_signature(this_ptr: number, val: number): void {
21123 if(!isWasmInitialized) {
21124 throw new Error("initializeWasm() must be awaited first!");
21126 const nativeResponseValue = wasm.TS_CommitmentSigned_set_signature(this_ptr, val);
21127 // debug statements here
21129 // void CommitmentSigned_set_htlc_signatures(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
21131 export function CommitmentSigned_set_htlc_signatures(this_ptr: number, val: number): void {
21132 if(!isWasmInitialized) {
21133 throw new Error("initializeWasm() must be awaited first!");
21135 const nativeResponseValue = wasm.TS_CommitmentSigned_set_htlc_signatures(this_ptr, val);
21136 // debug statements here
21138 // MUST_USE_RES struct LDKCommitmentSigned CommitmentSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg, struct LDKCVec_SignatureZ htlc_signatures_arg);
21140 export function CommitmentSigned_new(channel_id_arg: number, signature_arg: number, htlc_signatures_arg: number): number {
21141 if(!isWasmInitialized) {
21142 throw new Error("initializeWasm() must be awaited first!");
21144 const nativeResponseValue = wasm.TS_CommitmentSigned_new(channel_id_arg, signature_arg, htlc_signatures_arg);
21145 return nativeResponseValue;
21147 // uintptr_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg);
21149 export function CommitmentSigned_clone_ptr(arg: number): number {
21150 if(!isWasmInitialized) {
21151 throw new Error("initializeWasm() must be awaited first!");
21153 const nativeResponseValue = wasm.TS_CommitmentSigned_clone_ptr(arg);
21154 return nativeResponseValue;
21156 // struct LDKCommitmentSigned CommitmentSigned_clone(const struct LDKCommitmentSigned *NONNULL_PTR orig);
21158 export function CommitmentSigned_clone(orig: number): number {
21159 if(!isWasmInitialized) {
21160 throw new Error("initializeWasm() must be awaited first!");
21162 const nativeResponseValue = wasm.TS_CommitmentSigned_clone(orig);
21163 return nativeResponseValue;
21165 // void RevokeAndACK_free(struct LDKRevokeAndACK this_obj);
21167 export function RevokeAndACK_free(this_obj: number): void {
21168 if(!isWasmInitialized) {
21169 throw new Error("initializeWasm() must be awaited first!");
21171 const nativeResponseValue = wasm.TS_RevokeAndACK_free(this_obj);
21172 // debug statements here
21174 // const uint8_t (*RevokeAndACK_get_channel_id(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
21176 export function RevokeAndACK_get_channel_id(this_ptr: number): number {
21177 if(!isWasmInitialized) {
21178 throw new Error("initializeWasm() must be awaited first!");
21180 const nativeResponseValue = wasm.TS_RevokeAndACK_get_channel_id(this_ptr);
21181 return nativeResponseValue;
21183 // void RevokeAndACK_set_channel_id(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21185 export function RevokeAndACK_set_channel_id(this_ptr: number, val: number): void {
21186 if(!isWasmInitialized) {
21187 throw new Error("initializeWasm() must be awaited first!");
21189 const nativeResponseValue = wasm.TS_RevokeAndACK_set_channel_id(this_ptr, val);
21190 // debug statements here
21192 // const uint8_t (*RevokeAndACK_get_per_commitment_secret(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
21194 export function RevokeAndACK_get_per_commitment_secret(this_ptr: number): number {
21195 if(!isWasmInitialized) {
21196 throw new Error("initializeWasm() must be awaited first!");
21198 const nativeResponseValue = wasm.TS_RevokeAndACK_get_per_commitment_secret(this_ptr);
21199 return nativeResponseValue;
21201 // void RevokeAndACK_set_per_commitment_secret(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21203 export function RevokeAndACK_set_per_commitment_secret(this_ptr: number, val: number): void {
21204 if(!isWasmInitialized) {
21205 throw new Error("initializeWasm() must be awaited first!");
21207 const nativeResponseValue = wasm.TS_RevokeAndACK_set_per_commitment_secret(this_ptr, val);
21208 // debug statements here
21210 // struct LDKPublicKey RevokeAndACK_get_next_per_commitment_point(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr);
21212 export function RevokeAndACK_get_next_per_commitment_point(this_ptr: number): number {
21213 if(!isWasmInitialized) {
21214 throw new Error("initializeWasm() must be awaited first!");
21216 const nativeResponseValue = wasm.TS_RevokeAndACK_get_next_per_commitment_point(this_ptr);
21217 return nativeResponseValue;
21219 // void RevokeAndACK_set_next_per_commitment_point(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21221 export function RevokeAndACK_set_next_per_commitment_point(this_ptr: number, val: number): void {
21222 if(!isWasmInitialized) {
21223 throw new Error("initializeWasm() must be awaited first!");
21225 const nativeResponseValue = wasm.TS_RevokeAndACK_set_next_per_commitment_point(this_ptr, val);
21226 // debug statements here
21228 // 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);
21230 export function RevokeAndACK_new(channel_id_arg: number, per_commitment_secret_arg: number, next_per_commitment_point_arg: number): number {
21231 if(!isWasmInitialized) {
21232 throw new Error("initializeWasm() must be awaited first!");
21234 const nativeResponseValue = wasm.TS_RevokeAndACK_new(channel_id_arg, per_commitment_secret_arg, next_per_commitment_point_arg);
21235 return nativeResponseValue;
21237 // uintptr_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg);
21239 export function RevokeAndACK_clone_ptr(arg: number): number {
21240 if(!isWasmInitialized) {
21241 throw new Error("initializeWasm() must be awaited first!");
21243 const nativeResponseValue = wasm.TS_RevokeAndACK_clone_ptr(arg);
21244 return nativeResponseValue;
21246 // struct LDKRevokeAndACK RevokeAndACK_clone(const struct LDKRevokeAndACK *NONNULL_PTR orig);
21248 export function RevokeAndACK_clone(orig: number): number {
21249 if(!isWasmInitialized) {
21250 throw new Error("initializeWasm() must be awaited first!");
21252 const nativeResponseValue = wasm.TS_RevokeAndACK_clone(orig);
21253 return nativeResponseValue;
21255 // void UpdateFee_free(struct LDKUpdateFee this_obj);
21257 export function UpdateFee_free(this_obj: number): void {
21258 if(!isWasmInitialized) {
21259 throw new Error("initializeWasm() must be awaited first!");
21261 const nativeResponseValue = wasm.TS_UpdateFee_free(this_obj);
21262 // debug statements here
21264 // const uint8_t (*UpdateFee_get_channel_id(const struct LDKUpdateFee *NONNULL_PTR this_ptr))[32];
21266 export function UpdateFee_get_channel_id(this_ptr: number): number {
21267 if(!isWasmInitialized) {
21268 throw new Error("initializeWasm() must be awaited first!");
21270 const nativeResponseValue = wasm.TS_UpdateFee_get_channel_id(this_ptr);
21271 return nativeResponseValue;
21273 // void UpdateFee_set_channel_id(struct LDKUpdateFee *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21275 export function UpdateFee_set_channel_id(this_ptr: number, val: number): void {
21276 if(!isWasmInitialized) {
21277 throw new Error("initializeWasm() must be awaited first!");
21279 const nativeResponseValue = wasm.TS_UpdateFee_set_channel_id(this_ptr, val);
21280 // debug statements here
21282 // uint32_t UpdateFee_get_feerate_per_kw(const struct LDKUpdateFee *NONNULL_PTR this_ptr);
21284 export function UpdateFee_get_feerate_per_kw(this_ptr: number): number {
21285 if(!isWasmInitialized) {
21286 throw new Error("initializeWasm() must be awaited first!");
21288 const nativeResponseValue = wasm.TS_UpdateFee_get_feerate_per_kw(this_ptr);
21289 return nativeResponseValue;
21291 // void UpdateFee_set_feerate_per_kw(struct LDKUpdateFee *NONNULL_PTR this_ptr, uint32_t val);
21293 export function UpdateFee_set_feerate_per_kw(this_ptr: number, val: number): void {
21294 if(!isWasmInitialized) {
21295 throw new Error("initializeWasm() must be awaited first!");
21297 const nativeResponseValue = wasm.TS_UpdateFee_set_feerate_per_kw(this_ptr, val);
21298 // debug statements here
21300 // MUST_USE_RES struct LDKUpdateFee UpdateFee_new(struct LDKThirtyTwoBytes channel_id_arg, uint32_t feerate_per_kw_arg);
21302 export function UpdateFee_new(channel_id_arg: number, feerate_per_kw_arg: number): number {
21303 if(!isWasmInitialized) {
21304 throw new Error("initializeWasm() must be awaited first!");
21306 const nativeResponseValue = wasm.TS_UpdateFee_new(channel_id_arg, feerate_per_kw_arg);
21307 return nativeResponseValue;
21309 // uintptr_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg);
21311 export function UpdateFee_clone_ptr(arg: number): number {
21312 if(!isWasmInitialized) {
21313 throw new Error("initializeWasm() must be awaited first!");
21315 const nativeResponseValue = wasm.TS_UpdateFee_clone_ptr(arg);
21316 return nativeResponseValue;
21318 // struct LDKUpdateFee UpdateFee_clone(const struct LDKUpdateFee *NONNULL_PTR orig);
21320 export function UpdateFee_clone(orig: number): number {
21321 if(!isWasmInitialized) {
21322 throw new Error("initializeWasm() must be awaited first!");
21324 const nativeResponseValue = wasm.TS_UpdateFee_clone(orig);
21325 return nativeResponseValue;
21327 // void DataLossProtect_free(struct LDKDataLossProtect this_obj);
21329 export function DataLossProtect_free(this_obj: number): void {
21330 if(!isWasmInitialized) {
21331 throw new Error("initializeWasm() must be awaited first!");
21333 const nativeResponseValue = wasm.TS_DataLossProtect_free(this_obj);
21334 // debug statements here
21336 // const uint8_t (*DataLossProtect_get_your_last_per_commitment_secret(const struct LDKDataLossProtect *NONNULL_PTR this_ptr))[32];
21338 export function DataLossProtect_get_your_last_per_commitment_secret(this_ptr: number): number {
21339 if(!isWasmInitialized) {
21340 throw new Error("initializeWasm() must be awaited first!");
21342 const nativeResponseValue = wasm.TS_DataLossProtect_get_your_last_per_commitment_secret(this_ptr);
21343 return nativeResponseValue;
21345 // void DataLossProtect_set_your_last_per_commitment_secret(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21347 export function DataLossProtect_set_your_last_per_commitment_secret(this_ptr: number, val: number): void {
21348 if(!isWasmInitialized) {
21349 throw new Error("initializeWasm() must be awaited first!");
21351 const nativeResponseValue = wasm.TS_DataLossProtect_set_your_last_per_commitment_secret(this_ptr, val);
21352 // debug statements here
21354 // struct LDKPublicKey DataLossProtect_get_my_current_per_commitment_point(const struct LDKDataLossProtect *NONNULL_PTR this_ptr);
21356 export function DataLossProtect_get_my_current_per_commitment_point(this_ptr: number): number {
21357 if(!isWasmInitialized) {
21358 throw new Error("initializeWasm() must be awaited first!");
21360 const nativeResponseValue = wasm.TS_DataLossProtect_get_my_current_per_commitment_point(this_ptr);
21361 return nativeResponseValue;
21363 // void DataLossProtect_set_my_current_per_commitment_point(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21365 export function DataLossProtect_set_my_current_per_commitment_point(this_ptr: number, val: number): void {
21366 if(!isWasmInitialized) {
21367 throw new Error("initializeWasm() must be awaited first!");
21369 const nativeResponseValue = wasm.TS_DataLossProtect_set_my_current_per_commitment_point(this_ptr, val);
21370 // debug statements here
21372 // MUST_USE_RES struct LDKDataLossProtect DataLossProtect_new(struct LDKThirtyTwoBytes your_last_per_commitment_secret_arg, struct LDKPublicKey my_current_per_commitment_point_arg);
21374 export function DataLossProtect_new(your_last_per_commitment_secret_arg: number, my_current_per_commitment_point_arg: number): number {
21375 if(!isWasmInitialized) {
21376 throw new Error("initializeWasm() must be awaited first!");
21378 const nativeResponseValue = wasm.TS_DataLossProtect_new(your_last_per_commitment_secret_arg, my_current_per_commitment_point_arg);
21379 return nativeResponseValue;
21381 // uintptr_t DataLossProtect_clone_ptr(LDKDataLossProtect *NONNULL_PTR arg);
21383 export function DataLossProtect_clone_ptr(arg: number): number {
21384 if(!isWasmInitialized) {
21385 throw new Error("initializeWasm() must be awaited first!");
21387 const nativeResponseValue = wasm.TS_DataLossProtect_clone_ptr(arg);
21388 return nativeResponseValue;
21390 // struct LDKDataLossProtect DataLossProtect_clone(const struct LDKDataLossProtect *NONNULL_PTR orig);
21392 export function DataLossProtect_clone(orig: number): number {
21393 if(!isWasmInitialized) {
21394 throw new Error("initializeWasm() must be awaited first!");
21396 const nativeResponseValue = wasm.TS_DataLossProtect_clone(orig);
21397 return nativeResponseValue;
21399 // void ChannelReestablish_free(struct LDKChannelReestablish this_obj);
21401 export function ChannelReestablish_free(this_obj: number): void {
21402 if(!isWasmInitialized) {
21403 throw new Error("initializeWasm() must be awaited first!");
21405 const nativeResponseValue = wasm.TS_ChannelReestablish_free(this_obj);
21406 // debug statements here
21408 // const uint8_t (*ChannelReestablish_get_channel_id(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
21410 export function ChannelReestablish_get_channel_id(this_ptr: number): number {
21411 if(!isWasmInitialized) {
21412 throw new Error("initializeWasm() must be awaited first!");
21414 const nativeResponseValue = wasm.TS_ChannelReestablish_get_channel_id(this_ptr);
21415 return nativeResponseValue;
21417 // void ChannelReestablish_set_channel_id(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21419 export function ChannelReestablish_set_channel_id(this_ptr: number, val: number): void {
21420 if(!isWasmInitialized) {
21421 throw new Error("initializeWasm() must be awaited first!");
21423 const nativeResponseValue = wasm.TS_ChannelReestablish_set_channel_id(this_ptr, val);
21424 // debug statements here
21426 // uint64_t ChannelReestablish_get_next_local_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
21428 export function ChannelReestablish_get_next_local_commitment_number(this_ptr: number): bigint {
21429 if(!isWasmInitialized) {
21430 throw new Error("initializeWasm() must be awaited first!");
21432 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_local_commitment_number(this_ptr);
21433 return nativeResponseValue;
21435 // void ChannelReestablish_set_next_local_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
21437 export function ChannelReestablish_set_next_local_commitment_number(this_ptr: number, val: bigint): void {
21438 if(!isWasmInitialized) {
21439 throw new Error("initializeWasm() must be awaited first!");
21441 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_local_commitment_number(this_ptr, val);
21442 // debug statements here
21444 // uint64_t ChannelReestablish_get_next_remote_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
21446 export function ChannelReestablish_get_next_remote_commitment_number(this_ptr: number): bigint {
21447 if(!isWasmInitialized) {
21448 throw new Error("initializeWasm() must be awaited first!");
21450 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_remote_commitment_number(this_ptr);
21451 return nativeResponseValue;
21453 // void ChannelReestablish_set_next_remote_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
21455 export function ChannelReestablish_set_next_remote_commitment_number(this_ptr: number, val: bigint): void {
21456 if(!isWasmInitialized) {
21457 throw new Error("initializeWasm() must be awaited first!");
21459 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_remote_commitment_number(this_ptr, val);
21460 // debug statements here
21462 // uintptr_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg);
21464 export function ChannelReestablish_clone_ptr(arg: number): number {
21465 if(!isWasmInitialized) {
21466 throw new Error("initializeWasm() must be awaited first!");
21468 const nativeResponseValue = wasm.TS_ChannelReestablish_clone_ptr(arg);
21469 return nativeResponseValue;
21471 // struct LDKChannelReestablish ChannelReestablish_clone(const struct LDKChannelReestablish *NONNULL_PTR orig);
21473 export function ChannelReestablish_clone(orig: number): number {
21474 if(!isWasmInitialized) {
21475 throw new Error("initializeWasm() must be awaited first!");
21477 const nativeResponseValue = wasm.TS_ChannelReestablish_clone(orig);
21478 return nativeResponseValue;
21480 // void AnnouncementSignatures_free(struct LDKAnnouncementSignatures this_obj);
21482 export function AnnouncementSignatures_free(this_obj: number): void {
21483 if(!isWasmInitialized) {
21484 throw new Error("initializeWasm() must be awaited first!");
21486 const nativeResponseValue = wasm.TS_AnnouncementSignatures_free(this_obj);
21487 // debug statements here
21489 // const uint8_t (*AnnouncementSignatures_get_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr))[32];
21491 export function AnnouncementSignatures_get_channel_id(this_ptr: number): number {
21492 if(!isWasmInitialized) {
21493 throw new Error("initializeWasm() must be awaited first!");
21495 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_channel_id(this_ptr);
21496 return nativeResponseValue;
21498 // void AnnouncementSignatures_set_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21500 export function AnnouncementSignatures_set_channel_id(this_ptr: number, val: number): void {
21501 if(!isWasmInitialized) {
21502 throw new Error("initializeWasm() must be awaited first!");
21504 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_channel_id(this_ptr, val);
21505 // debug statements here
21507 // uint64_t AnnouncementSignatures_get_short_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
21509 export function AnnouncementSignatures_get_short_channel_id(this_ptr: number): bigint {
21510 if(!isWasmInitialized) {
21511 throw new Error("initializeWasm() must be awaited first!");
21513 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_short_channel_id(this_ptr);
21514 return nativeResponseValue;
21516 // void AnnouncementSignatures_set_short_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, uint64_t val);
21518 export function AnnouncementSignatures_set_short_channel_id(this_ptr: number, val: bigint): void {
21519 if(!isWasmInitialized) {
21520 throw new Error("initializeWasm() must be awaited first!");
21522 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_short_channel_id(this_ptr, val);
21523 // debug statements here
21525 // struct LDKSignature AnnouncementSignatures_get_node_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
21527 export function AnnouncementSignatures_get_node_signature(this_ptr: number): number {
21528 if(!isWasmInitialized) {
21529 throw new Error("initializeWasm() must be awaited first!");
21531 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_node_signature(this_ptr);
21532 return nativeResponseValue;
21534 // void AnnouncementSignatures_set_node_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
21536 export function AnnouncementSignatures_set_node_signature(this_ptr: number, val: number): void {
21537 if(!isWasmInitialized) {
21538 throw new Error("initializeWasm() must be awaited first!");
21540 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_node_signature(this_ptr, val);
21541 // debug statements here
21543 // struct LDKSignature AnnouncementSignatures_get_bitcoin_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
21545 export function AnnouncementSignatures_get_bitcoin_signature(this_ptr: number): number {
21546 if(!isWasmInitialized) {
21547 throw new Error("initializeWasm() must be awaited first!");
21549 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_bitcoin_signature(this_ptr);
21550 return nativeResponseValue;
21552 // void AnnouncementSignatures_set_bitcoin_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
21554 export function AnnouncementSignatures_set_bitcoin_signature(this_ptr: number, val: number): void {
21555 if(!isWasmInitialized) {
21556 throw new Error("initializeWasm() must be awaited first!");
21558 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_bitcoin_signature(this_ptr, val);
21559 // debug statements here
21561 // 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);
21563 export function AnnouncementSignatures_new(channel_id_arg: number, short_channel_id_arg: bigint, node_signature_arg: number, bitcoin_signature_arg: number): number {
21564 if(!isWasmInitialized) {
21565 throw new Error("initializeWasm() must be awaited first!");
21567 const nativeResponseValue = wasm.TS_AnnouncementSignatures_new(channel_id_arg, short_channel_id_arg, node_signature_arg, bitcoin_signature_arg);
21568 return nativeResponseValue;
21570 // uintptr_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg);
21572 export function AnnouncementSignatures_clone_ptr(arg: number): number {
21573 if(!isWasmInitialized) {
21574 throw new Error("initializeWasm() must be awaited first!");
21576 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone_ptr(arg);
21577 return nativeResponseValue;
21579 // struct LDKAnnouncementSignatures AnnouncementSignatures_clone(const struct LDKAnnouncementSignatures *NONNULL_PTR orig);
21581 export function AnnouncementSignatures_clone(orig: number): number {
21582 if(!isWasmInitialized) {
21583 throw new Error("initializeWasm() must be awaited first!");
21585 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone(orig);
21586 return nativeResponseValue;
21588 // void NetAddress_free(struct LDKNetAddress this_ptr);
21590 export function NetAddress_free(this_ptr: number): void {
21591 if(!isWasmInitialized) {
21592 throw new Error("initializeWasm() must be awaited first!");
21594 const nativeResponseValue = wasm.TS_NetAddress_free(this_ptr);
21595 // debug statements here
21597 // uintptr_t NetAddress_clone_ptr(LDKNetAddress *NONNULL_PTR arg);
21599 export function NetAddress_clone_ptr(arg: number): number {
21600 if(!isWasmInitialized) {
21601 throw new Error("initializeWasm() must be awaited first!");
21603 const nativeResponseValue = wasm.TS_NetAddress_clone_ptr(arg);
21604 return nativeResponseValue;
21606 // struct LDKNetAddress NetAddress_clone(const struct LDKNetAddress *NONNULL_PTR orig);
21608 export function NetAddress_clone(orig: number): number {
21609 if(!isWasmInitialized) {
21610 throw new Error("initializeWasm() must be awaited first!");
21612 const nativeResponseValue = wasm.TS_NetAddress_clone(orig);
21613 return nativeResponseValue;
21615 // struct LDKNetAddress NetAddress_ipv4(struct LDKFourBytes addr, uint16_t port);
21617 export function NetAddress_ipv4(addr: number, port: number): number {
21618 if(!isWasmInitialized) {
21619 throw new Error("initializeWasm() must be awaited first!");
21621 const nativeResponseValue = wasm.TS_NetAddress_ipv4(addr, port);
21622 return nativeResponseValue;
21624 // struct LDKNetAddress NetAddress_ipv6(struct LDKSixteenBytes addr, uint16_t port);
21626 export function NetAddress_ipv6(addr: number, port: number): number {
21627 if(!isWasmInitialized) {
21628 throw new Error("initializeWasm() must be awaited first!");
21630 const nativeResponseValue = wasm.TS_NetAddress_ipv6(addr, port);
21631 return nativeResponseValue;
21633 // struct LDKNetAddress NetAddress_onion_v2(struct LDKTwelveBytes a);
21635 export function NetAddress_onion_v2(a: number): number {
21636 if(!isWasmInitialized) {
21637 throw new Error("initializeWasm() must be awaited first!");
21639 const nativeResponseValue = wasm.TS_NetAddress_onion_v2(a);
21640 return nativeResponseValue;
21642 // struct LDKNetAddress NetAddress_onion_v3(struct LDKThirtyTwoBytes ed25519_pubkey, uint16_t checksum, uint8_t version, uint16_t port);
21644 export function NetAddress_onion_v3(ed25519_pubkey: number, checksum: number, version: number, port: number): number {
21645 if(!isWasmInitialized) {
21646 throw new Error("initializeWasm() must be awaited first!");
21648 const nativeResponseValue = wasm.TS_NetAddress_onion_v3(ed25519_pubkey, checksum, version, port);
21649 return nativeResponseValue;
21651 // struct LDKCVec_u8Z NetAddress_write(const struct LDKNetAddress *NONNULL_PTR obj);
21653 export function NetAddress_write(obj: number): number {
21654 if(!isWasmInitialized) {
21655 throw new Error("initializeWasm() must be awaited first!");
21657 const nativeResponseValue = wasm.TS_NetAddress_write(obj);
21658 return nativeResponseValue;
21660 // struct LDKCResult_NetAddressDecodeErrorZ NetAddress_read(struct LDKu8slice ser);
21662 export function NetAddress_read(ser: number): number {
21663 if(!isWasmInitialized) {
21664 throw new Error("initializeWasm() must be awaited first!");
21666 const nativeResponseValue = wasm.TS_NetAddress_read(ser);
21667 return nativeResponseValue;
21669 // void UnsignedNodeAnnouncement_free(struct LDKUnsignedNodeAnnouncement this_obj);
21671 export function UnsignedNodeAnnouncement_free(this_obj: number): void {
21672 if(!isWasmInitialized) {
21673 throw new Error("initializeWasm() must be awaited first!");
21675 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_free(this_obj);
21676 // debug statements here
21678 // struct LDKNodeFeatures UnsignedNodeAnnouncement_get_features(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
21680 export function UnsignedNodeAnnouncement_get_features(this_ptr: number): number {
21681 if(!isWasmInitialized) {
21682 throw new Error("initializeWasm() must be awaited first!");
21684 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_features(this_ptr);
21685 return nativeResponseValue;
21687 // void UnsignedNodeAnnouncement_set_features(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
21689 export function UnsignedNodeAnnouncement_set_features(this_ptr: number, val: number): void {
21690 if(!isWasmInitialized) {
21691 throw new Error("initializeWasm() must be awaited first!");
21693 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_features(this_ptr, val);
21694 // debug statements here
21696 // uint32_t UnsignedNodeAnnouncement_get_timestamp(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
21698 export function UnsignedNodeAnnouncement_get_timestamp(this_ptr: number): number {
21699 if(!isWasmInitialized) {
21700 throw new Error("initializeWasm() must be awaited first!");
21702 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_timestamp(this_ptr);
21703 return nativeResponseValue;
21705 // void UnsignedNodeAnnouncement_set_timestamp(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, uint32_t val);
21707 export function UnsignedNodeAnnouncement_set_timestamp(this_ptr: number, val: number): void {
21708 if(!isWasmInitialized) {
21709 throw new Error("initializeWasm() must be awaited first!");
21711 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_timestamp(this_ptr, val);
21712 // debug statements here
21714 // struct LDKPublicKey UnsignedNodeAnnouncement_get_node_id(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
21716 export function UnsignedNodeAnnouncement_get_node_id(this_ptr: number): number {
21717 if(!isWasmInitialized) {
21718 throw new Error("initializeWasm() must be awaited first!");
21720 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_node_id(this_ptr);
21721 return nativeResponseValue;
21723 // void UnsignedNodeAnnouncement_set_node_id(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21725 export function UnsignedNodeAnnouncement_set_node_id(this_ptr: number, val: number): void {
21726 if(!isWasmInitialized) {
21727 throw new Error("initializeWasm() must be awaited first!");
21729 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_node_id(this_ptr, val);
21730 // debug statements here
21732 // const uint8_t (*UnsignedNodeAnnouncement_get_rgb(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[3];
21734 export function UnsignedNodeAnnouncement_get_rgb(this_ptr: number): number {
21735 if(!isWasmInitialized) {
21736 throw new Error("initializeWasm() must be awaited first!");
21738 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_rgb(this_ptr);
21739 return nativeResponseValue;
21741 // void UnsignedNodeAnnouncement_set_rgb(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
21743 export function UnsignedNodeAnnouncement_set_rgb(this_ptr: number, val: number): void {
21744 if(!isWasmInitialized) {
21745 throw new Error("initializeWasm() must be awaited first!");
21747 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_rgb(this_ptr, val);
21748 // debug statements here
21750 // const uint8_t (*UnsignedNodeAnnouncement_get_alias(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[32];
21752 export function UnsignedNodeAnnouncement_get_alias(this_ptr: number): number {
21753 if(!isWasmInitialized) {
21754 throw new Error("initializeWasm() must be awaited first!");
21756 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_alias(this_ptr);
21757 return nativeResponseValue;
21759 // void UnsignedNodeAnnouncement_set_alias(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21761 export function UnsignedNodeAnnouncement_set_alias(this_ptr: number, val: number): void {
21762 if(!isWasmInitialized) {
21763 throw new Error("initializeWasm() must be awaited first!");
21765 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_alias(this_ptr, val);
21766 // debug statements here
21768 // void UnsignedNodeAnnouncement_set_addresses(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
21770 export function UnsignedNodeAnnouncement_set_addresses(this_ptr: number, val: number): void {
21771 if(!isWasmInitialized) {
21772 throw new Error("initializeWasm() must be awaited first!");
21774 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_addresses(this_ptr, val);
21775 // debug statements here
21777 // uintptr_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg);
21779 export function UnsignedNodeAnnouncement_clone_ptr(arg: number): number {
21780 if(!isWasmInitialized) {
21781 throw new Error("initializeWasm() must be awaited first!");
21783 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone_ptr(arg);
21784 return nativeResponseValue;
21786 // struct LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_clone(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR orig);
21788 export function UnsignedNodeAnnouncement_clone(orig: number): number {
21789 if(!isWasmInitialized) {
21790 throw new Error("initializeWasm() must be awaited first!");
21792 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone(orig);
21793 return nativeResponseValue;
21795 // void NodeAnnouncement_free(struct LDKNodeAnnouncement this_obj);
21797 export function NodeAnnouncement_free(this_obj: number): void {
21798 if(!isWasmInitialized) {
21799 throw new Error("initializeWasm() must be awaited first!");
21801 const nativeResponseValue = wasm.TS_NodeAnnouncement_free(this_obj);
21802 // debug statements here
21804 // struct LDKSignature NodeAnnouncement_get_signature(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
21806 export function NodeAnnouncement_get_signature(this_ptr: number): number {
21807 if(!isWasmInitialized) {
21808 throw new Error("initializeWasm() must be awaited first!");
21810 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_signature(this_ptr);
21811 return nativeResponseValue;
21813 // void NodeAnnouncement_set_signature(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
21815 export function NodeAnnouncement_set_signature(this_ptr: number, val: number): void {
21816 if(!isWasmInitialized) {
21817 throw new Error("initializeWasm() must be awaited first!");
21819 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_signature(this_ptr, val);
21820 // debug statements here
21822 // struct LDKUnsignedNodeAnnouncement NodeAnnouncement_get_contents(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
21824 export function NodeAnnouncement_get_contents(this_ptr: number): number {
21825 if(!isWasmInitialized) {
21826 throw new Error("initializeWasm() must be awaited first!");
21828 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_contents(this_ptr);
21829 return nativeResponseValue;
21831 // void NodeAnnouncement_set_contents(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedNodeAnnouncement val);
21833 export function NodeAnnouncement_set_contents(this_ptr: number, val: number): void {
21834 if(!isWasmInitialized) {
21835 throw new Error("initializeWasm() must be awaited first!");
21837 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_contents(this_ptr, val);
21838 // debug statements here
21840 // MUST_USE_RES struct LDKNodeAnnouncement NodeAnnouncement_new(struct LDKSignature signature_arg, struct LDKUnsignedNodeAnnouncement contents_arg);
21842 export function NodeAnnouncement_new(signature_arg: number, contents_arg: number): number {
21843 if(!isWasmInitialized) {
21844 throw new Error("initializeWasm() must be awaited first!");
21846 const nativeResponseValue = wasm.TS_NodeAnnouncement_new(signature_arg, contents_arg);
21847 return nativeResponseValue;
21849 // uintptr_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg);
21851 export function NodeAnnouncement_clone_ptr(arg: number): number {
21852 if(!isWasmInitialized) {
21853 throw new Error("initializeWasm() must be awaited first!");
21855 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone_ptr(arg);
21856 return nativeResponseValue;
21858 // struct LDKNodeAnnouncement NodeAnnouncement_clone(const struct LDKNodeAnnouncement *NONNULL_PTR orig);
21860 export function NodeAnnouncement_clone(orig: number): number {
21861 if(!isWasmInitialized) {
21862 throw new Error("initializeWasm() must be awaited first!");
21864 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone(orig);
21865 return nativeResponseValue;
21867 // void UnsignedChannelAnnouncement_free(struct LDKUnsignedChannelAnnouncement this_obj);
21869 export function UnsignedChannelAnnouncement_free(this_obj: number): void {
21870 if(!isWasmInitialized) {
21871 throw new Error("initializeWasm() must be awaited first!");
21873 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_free(this_obj);
21874 // debug statements here
21876 // struct LDKChannelFeatures UnsignedChannelAnnouncement_get_features(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
21878 export function UnsignedChannelAnnouncement_get_features(this_ptr: number): number {
21879 if(!isWasmInitialized) {
21880 throw new Error("initializeWasm() must be awaited first!");
21882 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_features(this_ptr);
21883 return nativeResponseValue;
21885 // void UnsignedChannelAnnouncement_set_features(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
21887 export function UnsignedChannelAnnouncement_set_features(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_features(this_ptr, val);
21892 // debug statements here
21894 // const uint8_t (*UnsignedChannelAnnouncement_get_chain_hash(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr))[32];
21896 export function UnsignedChannelAnnouncement_get_chain_hash(this_ptr: number): number {
21897 if(!isWasmInitialized) {
21898 throw new Error("initializeWasm() must be awaited first!");
21900 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_chain_hash(this_ptr);
21901 return nativeResponseValue;
21903 // void UnsignedChannelAnnouncement_set_chain_hash(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21905 export function UnsignedChannelAnnouncement_set_chain_hash(this_ptr: number, val: number): void {
21906 if(!isWasmInitialized) {
21907 throw new Error("initializeWasm() must be awaited first!");
21909 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_chain_hash(this_ptr, val);
21910 // debug statements here
21912 // uint64_t UnsignedChannelAnnouncement_get_short_channel_id(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
21914 export function UnsignedChannelAnnouncement_get_short_channel_id(this_ptr: number): bigint {
21915 if(!isWasmInitialized) {
21916 throw new Error("initializeWasm() must be awaited first!");
21918 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_short_channel_id(this_ptr);
21919 return nativeResponseValue;
21921 // void UnsignedChannelAnnouncement_set_short_channel_id(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, uint64_t val);
21923 export function UnsignedChannelAnnouncement_set_short_channel_id(this_ptr: number, val: bigint): void {
21924 if(!isWasmInitialized) {
21925 throw new Error("initializeWasm() must be awaited first!");
21927 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_short_channel_id(this_ptr, val);
21928 // debug statements here
21930 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
21932 export function UnsignedChannelAnnouncement_get_node_id_1(this_ptr: number): number {
21933 if(!isWasmInitialized) {
21934 throw new Error("initializeWasm() must be awaited first!");
21936 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_1(this_ptr);
21937 return nativeResponseValue;
21939 // void UnsignedChannelAnnouncement_set_node_id_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21941 export function UnsignedChannelAnnouncement_set_node_id_1(this_ptr: number, val: number): void {
21942 if(!isWasmInitialized) {
21943 throw new Error("initializeWasm() must be awaited first!");
21945 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_1(this_ptr, val);
21946 // debug statements here
21948 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
21950 export function UnsignedChannelAnnouncement_get_node_id_2(this_ptr: number): number {
21951 if(!isWasmInitialized) {
21952 throw new Error("initializeWasm() must be awaited first!");
21954 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_2(this_ptr);
21955 return nativeResponseValue;
21957 // void UnsignedChannelAnnouncement_set_node_id_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21959 export function UnsignedChannelAnnouncement_set_node_id_2(this_ptr: number, val: number): void {
21960 if(!isWasmInitialized) {
21961 throw new Error("initializeWasm() must be awaited first!");
21963 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_2(this_ptr, val);
21964 // debug statements here
21966 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
21968 export function UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr: number): number {
21969 if(!isWasmInitialized) {
21970 throw new Error("initializeWasm() must be awaited first!");
21972 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr);
21973 return nativeResponseValue;
21975 // void UnsignedChannelAnnouncement_set_bitcoin_key_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21977 export function UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr: number, val: number): void {
21978 if(!isWasmInitialized) {
21979 throw new Error("initializeWasm() must be awaited first!");
21981 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr, val);
21982 // debug statements here
21984 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
21986 export function UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr: number): number {
21987 if(!isWasmInitialized) {
21988 throw new Error("initializeWasm() must be awaited first!");
21990 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr);
21991 return nativeResponseValue;
21993 // void UnsignedChannelAnnouncement_set_bitcoin_key_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21995 export function UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr: number, val: number): void {
21996 if(!isWasmInitialized) {
21997 throw new Error("initializeWasm() must be awaited first!");
21999 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr, val);
22000 // debug statements here
22002 // uintptr_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg);
22004 export function UnsignedChannelAnnouncement_clone_ptr(arg: number): number {
22005 if(!isWasmInitialized) {
22006 throw new Error("initializeWasm() must be awaited first!");
22008 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone_ptr(arg);
22009 return nativeResponseValue;
22011 // struct LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_clone(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR orig);
22013 export function UnsignedChannelAnnouncement_clone(orig: number): number {
22014 if(!isWasmInitialized) {
22015 throw new Error("initializeWasm() must be awaited first!");
22017 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone(orig);
22018 return nativeResponseValue;
22020 // void ChannelAnnouncement_free(struct LDKChannelAnnouncement this_obj);
22022 export function ChannelAnnouncement_free(this_obj: number): void {
22023 if(!isWasmInitialized) {
22024 throw new Error("initializeWasm() must be awaited first!");
22026 const nativeResponseValue = wasm.TS_ChannelAnnouncement_free(this_obj);
22027 // debug statements here
22029 // struct LDKSignature ChannelAnnouncement_get_node_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
22031 export function ChannelAnnouncement_get_node_signature_1(this_ptr: number): number {
22032 if(!isWasmInitialized) {
22033 throw new Error("initializeWasm() must be awaited first!");
22035 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_1(this_ptr);
22036 return nativeResponseValue;
22038 // void ChannelAnnouncement_set_node_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
22040 export function ChannelAnnouncement_set_node_signature_1(this_ptr: number, val: number): void {
22041 if(!isWasmInitialized) {
22042 throw new Error("initializeWasm() must be awaited first!");
22044 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_1(this_ptr, val);
22045 // debug statements here
22047 // struct LDKSignature ChannelAnnouncement_get_node_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
22049 export function ChannelAnnouncement_get_node_signature_2(this_ptr: number): number {
22050 if(!isWasmInitialized) {
22051 throw new Error("initializeWasm() must be awaited first!");
22053 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_2(this_ptr);
22054 return nativeResponseValue;
22056 // void ChannelAnnouncement_set_node_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
22058 export function ChannelAnnouncement_set_node_signature_2(this_ptr: number, val: number): void {
22059 if(!isWasmInitialized) {
22060 throw new Error("initializeWasm() must be awaited first!");
22062 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_2(this_ptr, val);
22063 // debug statements here
22065 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
22067 export function ChannelAnnouncement_get_bitcoin_signature_1(this_ptr: number): number {
22068 if(!isWasmInitialized) {
22069 throw new Error("initializeWasm() must be awaited first!");
22071 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_1(this_ptr);
22072 return nativeResponseValue;
22074 // void ChannelAnnouncement_set_bitcoin_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
22076 export function ChannelAnnouncement_set_bitcoin_signature_1(this_ptr: number, val: number): void {
22077 if(!isWasmInitialized) {
22078 throw new Error("initializeWasm() must be awaited first!");
22080 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_1(this_ptr, val);
22081 // debug statements here
22083 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
22085 export function ChannelAnnouncement_get_bitcoin_signature_2(this_ptr: number): number {
22086 if(!isWasmInitialized) {
22087 throw new Error("initializeWasm() must be awaited first!");
22089 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_2(this_ptr);
22090 return nativeResponseValue;
22092 // void ChannelAnnouncement_set_bitcoin_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
22094 export function ChannelAnnouncement_set_bitcoin_signature_2(this_ptr: number, val: number): void {
22095 if(!isWasmInitialized) {
22096 throw new Error("initializeWasm() must be awaited first!");
22098 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_2(this_ptr, val);
22099 // debug statements here
22101 // struct LDKUnsignedChannelAnnouncement ChannelAnnouncement_get_contents(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
22103 export function ChannelAnnouncement_get_contents(this_ptr: number): number {
22104 if(!isWasmInitialized) {
22105 throw new Error("initializeWasm() must be awaited first!");
22107 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_contents(this_ptr);
22108 return nativeResponseValue;
22110 // void ChannelAnnouncement_set_contents(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedChannelAnnouncement val);
22112 export function ChannelAnnouncement_set_contents(this_ptr: number, val: number): void {
22113 if(!isWasmInitialized) {
22114 throw new Error("initializeWasm() must be awaited first!");
22116 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_contents(this_ptr, val);
22117 // debug statements here
22119 // 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);
22121 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 {
22122 if(!isWasmInitialized) {
22123 throw new Error("initializeWasm() must be awaited first!");
22125 const nativeResponseValue = wasm.TS_ChannelAnnouncement_new(node_signature_1_arg, node_signature_2_arg, bitcoin_signature_1_arg, bitcoin_signature_2_arg, contents_arg);
22126 return nativeResponseValue;
22128 // uintptr_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg);
22130 export function ChannelAnnouncement_clone_ptr(arg: number): number {
22131 if(!isWasmInitialized) {
22132 throw new Error("initializeWasm() must be awaited first!");
22134 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone_ptr(arg);
22135 return nativeResponseValue;
22137 // struct LDKChannelAnnouncement ChannelAnnouncement_clone(const struct LDKChannelAnnouncement *NONNULL_PTR orig);
22139 export function ChannelAnnouncement_clone(orig: number): number {
22140 if(!isWasmInitialized) {
22141 throw new Error("initializeWasm() must be awaited first!");
22143 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone(orig);
22144 return nativeResponseValue;
22146 // void UnsignedChannelUpdate_free(struct LDKUnsignedChannelUpdate this_obj);
22148 export function UnsignedChannelUpdate_free(this_obj: number): void {
22149 if(!isWasmInitialized) {
22150 throw new Error("initializeWasm() must be awaited first!");
22152 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_free(this_obj);
22153 // debug statements here
22155 // const uint8_t (*UnsignedChannelUpdate_get_chain_hash(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr))[32];
22157 export function UnsignedChannelUpdate_get_chain_hash(this_ptr: number): number {
22158 if(!isWasmInitialized) {
22159 throw new Error("initializeWasm() must be awaited first!");
22161 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_chain_hash(this_ptr);
22162 return nativeResponseValue;
22164 // void UnsignedChannelUpdate_set_chain_hash(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22166 export function UnsignedChannelUpdate_set_chain_hash(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_chain_hash(this_ptr, val);
22171 // debug statements here
22173 // uint64_t UnsignedChannelUpdate_get_short_channel_id(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
22175 export function UnsignedChannelUpdate_get_short_channel_id(this_ptr: number): bigint {
22176 if(!isWasmInitialized) {
22177 throw new Error("initializeWasm() must be awaited first!");
22179 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_short_channel_id(this_ptr);
22180 return nativeResponseValue;
22182 // void UnsignedChannelUpdate_set_short_channel_id(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
22184 export function UnsignedChannelUpdate_set_short_channel_id(this_ptr: number, val: bigint): void {
22185 if(!isWasmInitialized) {
22186 throw new Error("initializeWasm() must be awaited first!");
22188 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_short_channel_id(this_ptr, val);
22189 // debug statements here
22191 // uint32_t UnsignedChannelUpdate_get_timestamp(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
22193 export function UnsignedChannelUpdate_get_timestamp(this_ptr: number): number {
22194 if(!isWasmInitialized) {
22195 throw new Error("initializeWasm() must be awaited first!");
22197 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_timestamp(this_ptr);
22198 return nativeResponseValue;
22200 // void UnsignedChannelUpdate_set_timestamp(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
22202 export function UnsignedChannelUpdate_set_timestamp(this_ptr: number, val: number): void {
22203 if(!isWasmInitialized) {
22204 throw new Error("initializeWasm() must be awaited first!");
22206 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_timestamp(this_ptr, val);
22207 // debug statements here
22209 // uint8_t UnsignedChannelUpdate_get_flags(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
22211 export function UnsignedChannelUpdate_get_flags(this_ptr: number): number {
22212 if(!isWasmInitialized) {
22213 throw new Error("initializeWasm() must be awaited first!");
22215 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_flags(this_ptr);
22216 return nativeResponseValue;
22218 // void UnsignedChannelUpdate_set_flags(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint8_t val);
22220 export function UnsignedChannelUpdate_set_flags(this_ptr: number, val: number): void {
22221 if(!isWasmInitialized) {
22222 throw new Error("initializeWasm() must be awaited first!");
22224 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_flags(this_ptr, val);
22225 // debug statements here
22227 // uint16_t UnsignedChannelUpdate_get_cltv_expiry_delta(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
22229 export function UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr: number): number {
22230 if(!isWasmInitialized) {
22231 throw new Error("initializeWasm() must be awaited first!");
22233 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr);
22234 return nativeResponseValue;
22236 // void UnsignedChannelUpdate_set_cltv_expiry_delta(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint16_t val);
22238 export function UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr: number, val: number): void {
22239 if(!isWasmInitialized) {
22240 throw new Error("initializeWasm() must be awaited first!");
22242 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr, val);
22243 // debug statements here
22245 // uint64_t UnsignedChannelUpdate_get_htlc_minimum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
22247 export function UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr: number): bigint {
22248 if(!isWasmInitialized) {
22249 throw new Error("initializeWasm() must be awaited first!");
22251 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr);
22252 return nativeResponseValue;
22254 // void UnsignedChannelUpdate_set_htlc_minimum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
22256 export function UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
22257 if(!isWasmInitialized) {
22258 throw new Error("initializeWasm() must be awaited first!");
22260 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr, val);
22261 // debug statements here
22263 // uint32_t UnsignedChannelUpdate_get_fee_base_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
22265 export function UnsignedChannelUpdate_get_fee_base_msat(this_ptr: number): number {
22266 if(!isWasmInitialized) {
22267 throw new Error("initializeWasm() must be awaited first!");
22269 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_base_msat(this_ptr);
22270 return nativeResponseValue;
22272 // void UnsignedChannelUpdate_set_fee_base_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
22274 export function UnsignedChannelUpdate_set_fee_base_msat(this_ptr: number, val: number): void {
22275 if(!isWasmInitialized) {
22276 throw new Error("initializeWasm() must be awaited first!");
22278 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_base_msat(this_ptr, val);
22279 // debug statements here
22281 // uint32_t UnsignedChannelUpdate_get_fee_proportional_millionths(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
22283 export function UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr: number): number {
22284 if(!isWasmInitialized) {
22285 throw new Error("initializeWasm() must be awaited first!");
22287 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr);
22288 return nativeResponseValue;
22290 // void UnsignedChannelUpdate_set_fee_proportional_millionths(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
22292 export function UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr: number, val: number): void {
22293 if(!isWasmInitialized) {
22294 throw new Error("initializeWasm() must be awaited first!");
22296 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr, val);
22297 // debug statements here
22299 // uintptr_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg);
22301 export function UnsignedChannelUpdate_clone_ptr(arg: number): number {
22302 if(!isWasmInitialized) {
22303 throw new Error("initializeWasm() must be awaited first!");
22305 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone_ptr(arg);
22306 return nativeResponseValue;
22308 // struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_clone(const struct LDKUnsignedChannelUpdate *NONNULL_PTR orig);
22310 export function UnsignedChannelUpdate_clone(orig: number): number {
22311 if(!isWasmInitialized) {
22312 throw new Error("initializeWasm() must be awaited first!");
22314 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone(orig);
22315 return nativeResponseValue;
22317 // void ChannelUpdate_free(struct LDKChannelUpdate this_obj);
22319 export function ChannelUpdate_free(this_obj: number): void {
22320 if(!isWasmInitialized) {
22321 throw new Error("initializeWasm() must be awaited first!");
22323 const nativeResponseValue = wasm.TS_ChannelUpdate_free(this_obj);
22324 // debug statements here
22326 // struct LDKSignature ChannelUpdate_get_signature(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
22328 export function ChannelUpdate_get_signature(this_ptr: number): number {
22329 if(!isWasmInitialized) {
22330 throw new Error("initializeWasm() must be awaited first!");
22332 const nativeResponseValue = wasm.TS_ChannelUpdate_get_signature(this_ptr);
22333 return nativeResponseValue;
22335 // void ChannelUpdate_set_signature(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKSignature val);
22337 export function ChannelUpdate_set_signature(this_ptr: number, val: number): void {
22338 if(!isWasmInitialized) {
22339 throw new Error("initializeWasm() must be awaited first!");
22341 const nativeResponseValue = wasm.TS_ChannelUpdate_set_signature(this_ptr, val);
22342 // debug statements here
22344 // struct LDKUnsignedChannelUpdate ChannelUpdate_get_contents(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
22346 export function ChannelUpdate_get_contents(this_ptr: number): number {
22347 if(!isWasmInitialized) {
22348 throw new Error("initializeWasm() must be awaited first!");
22350 const nativeResponseValue = wasm.TS_ChannelUpdate_get_contents(this_ptr);
22351 return nativeResponseValue;
22353 // void ChannelUpdate_set_contents(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKUnsignedChannelUpdate val);
22355 export function ChannelUpdate_set_contents(this_ptr: number, val: number): void {
22356 if(!isWasmInitialized) {
22357 throw new Error("initializeWasm() must be awaited first!");
22359 const nativeResponseValue = wasm.TS_ChannelUpdate_set_contents(this_ptr, val);
22360 // debug statements here
22362 // MUST_USE_RES struct LDKChannelUpdate ChannelUpdate_new(struct LDKSignature signature_arg, struct LDKUnsignedChannelUpdate contents_arg);
22364 export function ChannelUpdate_new(signature_arg: number, contents_arg: number): number {
22365 if(!isWasmInitialized) {
22366 throw new Error("initializeWasm() must be awaited first!");
22368 const nativeResponseValue = wasm.TS_ChannelUpdate_new(signature_arg, contents_arg);
22369 return nativeResponseValue;
22371 // uintptr_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg);
22373 export function ChannelUpdate_clone_ptr(arg: number): number {
22374 if(!isWasmInitialized) {
22375 throw new Error("initializeWasm() must be awaited first!");
22377 const nativeResponseValue = wasm.TS_ChannelUpdate_clone_ptr(arg);
22378 return nativeResponseValue;
22380 // struct LDKChannelUpdate ChannelUpdate_clone(const struct LDKChannelUpdate *NONNULL_PTR orig);
22382 export function ChannelUpdate_clone(orig: number): number {
22383 if(!isWasmInitialized) {
22384 throw new Error("initializeWasm() must be awaited first!");
22386 const nativeResponseValue = wasm.TS_ChannelUpdate_clone(orig);
22387 return nativeResponseValue;
22389 // void QueryChannelRange_free(struct LDKQueryChannelRange this_obj);
22391 export function QueryChannelRange_free(this_obj: number): void {
22392 if(!isWasmInitialized) {
22393 throw new Error("initializeWasm() must be awaited first!");
22395 const nativeResponseValue = wasm.TS_QueryChannelRange_free(this_obj);
22396 // debug statements here
22398 // const uint8_t (*QueryChannelRange_get_chain_hash(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr))[32];
22400 export function QueryChannelRange_get_chain_hash(this_ptr: number): number {
22401 if(!isWasmInitialized) {
22402 throw new Error("initializeWasm() must be awaited first!");
22404 const nativeResponseValue = wasm.TS_QueryChannelRange_get_chain_hash(this_ptr);
22405 return nativeResponseValue;
22407 // void QueryChannelRange_set_chain_hash(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22409 export function QueryChannelRange_set_chain_hash(this_ptr: number, val: number): void {
22410 if(!isWasmInitialized) {
22411 throw new Error("initializeWasm() must be awaited first!");
22413 const nativeResponseValue = wasm.TS_QueryChannelRange_set_chain_hash(this_ptr, val);
22414 // debug statements here
22416 // uint32_t QueryChannelRange_get_first_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
22418 export function QueryChannelRange_get_first_blocknum(this_ptr: number): number {
22419 if(!isWasmInitialized) {
22420 throw new Error("initializeWasm() must be awaited first!");
22422 const nativeResponseValue = wasm.TS_QueryChannelRange_get_first_blocknum(this_ptr);
22423 return nativeResponseValue;
22425 // void QueryChannelRange_set_first_blocknum(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
22427 export function QueryChannelRange_set_first_blocknum(this_ptr: number, val: number): void {
22428 if(!isWasmInitialized) {
22429 throw new Error("initializeWasm() must be awaited first!");
22431 const nativeResponseValue = wasm.TS_QueryChannelRange_set_first_blocknum(this_ptr, val);
22432 // debug statements here
22434 // uint32_t QueryChannelRange_get_number_of_blocks(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
22436 export function QueryChannelRange_get_number_of_blocks(this_ptr: number): number {
22437 if(!isWasmInitialized) {
22438 throw new Error("initializeWasm() must be awaited first!");
22440 const nativeResponseValue = wasm.TS_QueryChannelRange_get_number_of_blocks(this_ptr);
22441 return nativeResponseValue;
22443 // void QueryChannelRange_set_number_of_blocks(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
22445 export function QueryChannelRange_set_number_of_blocks(this_ptr: number, val: number): void {
22446 if(!isWasmInitialized) {
22447 throw new Error("initializeWasm() must be awaited first!");
22449 const nativeResponseValue = wasm.TS_QueryChannelRange_set_number_of_blocks(this_ptr, val);
22450 // debug statements here
22452 // MUST_USE_RES struct LDKQueryChannelRange QueryChannelRange_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_blocknum_arg, uint32_t number_of_blocks_arg);
22454 export function QueryChannelRange_new(chain_hash_arg: number, first_blocknum_arg: number, number_of_blocks_arg: number): number {
22455 if(!isWasmInitialized) {
22456 throw new Error("initializeWasm() must be awaited first!");
22458 const nativeResponseValue = wasm.TS_QueryChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg);
22459 return nativeResponseValue;
22461 // uintptr_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg);
22463 export function QueryChannelRange_clone_ptr(arg: number): number {
22464 if(!isWasmInitialized) {
22465 throw new Error("initializeWasm() must be awaited first!");
22467 const nativeResponseValue = wasm.TS_QueryChannelRange_clone_ptr(arg);
22468 return nativeResponseValue;
22470 // struct LDKQueryChannelRange QueryChannelRange_clone(const struct LDKQueryChannelRange *NONNULL_PTR orig);
22472 export function QueryChannelRange_clone(orig: number): number {
22473 if(!isWasmInitialized) {
22474 throw new Error("initializeWasm() must be awaited first!");
22476 const nativeResponseValue = wasm.TS_QueryChannelRange_clone(orig);
22477 return nativeResponseValue;
22479 // void ReplyChannelRange_free(struct LDKReplyChannelRange this_obj);
22481 export function ReplyChannelRange_free(this_obj: number): void {
22482 if(!isWasmInitialized) {
22483 throw new Error("initializeWasm() must be awaited first!");
22485 const nativeResponseValue = wasm.TS_ReplyChannelRange_free(this_obj);
22486 // debug statements here
22488 // const uint8_t (*ReplyChannelRange_get_chain_hash(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr))[32];
22490 export function ReplyChannelRange_get_chain_hash(this_ptr: number): number {
22491 if(!isWasmInitialized) {
22492 throw new Error("initializeWasm() must be awaited first!");
22494 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_chain_hash(this_ptr);
22495 return nativeResponseValue;
22497 // void ReplyChannelRange_set_chain_hash(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22499 export function ReplyChannelRange_set_chain_hash(this_ptr: number, val: number): void {
22500 if(!isWasmInitialized) {
22501 throw new Error("initializeWasm() must be awaited first!");
22503 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_chain_hash(this_ptr, val);
22504 // debug statements here
22506 // uint32_t ReplyChannelRange_get_first_blocknum(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
22508 export function ReplyChannelRange_get_first_blocknum(this_ptr: number): number {
22509 if(!isWasmInitialized) {
22510 throw new Error("initializeWasm() must be awaited first!");
22512 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_first_blocknum(this_ptr);
22513 return nativeResponseValue;
22515 // void ReplyChannelRange_set_first_blocknum(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
22517 export function ReplyChannelRange_set_first_blocknum(this_ptr: number, val: number): void {
22518 if(!isWasmInitialized) {
22519 throw new Error("initializeWasm() must be awaited first!");
22521 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_first_blocknum(this_ptr, val);
22522 // debug statements here
22524 // uint32_t ReplyChannelRange_get_number_of_blocks(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
22526 export function ReplyChannelRange_get_number_of_blocks(this_ptr: number): number {
22527 if(!isWasmInitialized) {
22528 throw new Error("initializeWasm() must be awaited first!");
22530 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_number_of_blocks(this_ptr);
22531 return nativeResponseValue;
22533 // void ReplyChannelRange_set_number_of_blocks(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
22535 export function ReplyChannelRange_set_number_of_blocks(this_ptr: number, val: number): void {
22536 if(!isWasmInitialized) {
22537 throw new Error("initializeWasm() must be awaited first!");
22539 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_number_of_blocks(this_ptr, val);
22540 // debug statements here
22542 // bool ReplyChannelRange_get_sync_complete(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
22544 export function ReplyChannelRange_get_sync_complete(this_ptr: number): boolean {
22545 if(!isWasmInitialized) {
22546 throw new Error("initializeWasm() must be awaited first!");
22548 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_sync_complete(this_ptr);
22549 return nativeResponseValue;
22551 // void ReplyChannelRange_set_sync_complete(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, bool val);
22553 export function ReplyChannelRange_set_sync_complete(this_ptr: number, val: boolean): void {
22554 if(!isWasmInitialized) {
22555 throw new Error("initializeWasm() must be awaited first!");
22557 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_sync_complete(this_ptr, val);
22558 // debug statements here
22560 // void ReplyChannelRange_set_short_channel_ids(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
22562 export function ReplyChannelRange_set_short_channel_ids(this_ptr: number, val: number): void {
22563 if(!isWasmInitialized) {
22564 throw new Error("initializeWasm() must be awaited first!");
22566 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_short_channel_ids(this_ptr, val);
22567 // debug statements here
22569 // 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);
22571 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 {
22572 if(!isWasmInitialized) {
22573 throw new Error("initializeWasm() must be awaited first!");
22575 const nativeResponseValue = wasm.TS_ReplyChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg);
22576 return nativeResponseValue;
22578 // uintptr_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg);
22580 export function ReplyChannelRange_clone_ptr(arg: number): number {
22581 if(!isWasmInitialized) {
22582 throw new Error("initializeWasm() must be awaited first!");
22584 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone_ptr(arg);
22585 return nativeResponseValue;
22587 // struct LDKReplyChannelRange ReplyChannelRange_clone(const struct LDKReplyChannelRange *NONNULL_PTR orig);
22589 export function ReplyChannelRange_clone(orig: number): number {
22590 if(!isWasmInitialized) {
22591 throw new Error("initializeWasm() must be awaited first!");
22593 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone(orig);
22594 return nativeResponseValue;
22596 // void QueryShortChannelIds_free(struct LDKQueryShortChannelIds this_obj);
22598 export function QueryShortChannelIds_free(this_obj: number): void {
22599 if(!isWasmInitialized) {
22600 throw new Error("initializeWasm() must be awaited first!");
22602 const nativeResponseValue = wasm.TS_QueryShortChannelIds_free(this_obj);
22603 // debug statements here
22605 // const uint8_t (*QueryShortChannelIds_get_chain_hash(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr))[32];
22607 export function QueryShortChannelIds_get_chain_hash(this_ptr: number): number {
22608 if(!isWasmInitialized) {
22609 throw new Error("initializeWasm() must be awaited first!");
22611 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_chain_hash(this_ptr);
22612 return nativeResponseValue;
22614 // void QueryShortChannelIds_set_chain_hash(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22616 export function QueryShortChannelIds_set_chain_hash(this_ptr: number, val: number): void {
22617 if(!isWasmInitialized) {
22618 throw new Error("initializeWasm() must be awaited first!");
22620 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_chain_hash(this_ptr, val);
22621 // debug statements here
22623 // void QueryShortChannelIds_set_short_channel_ids(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
22625 export function QueryShortChannelIds_set_short_channel_ids(this_ptr: number, val: number): void {
22626 if(!isWasmInitialized) {
22627 throw new Error("initializeWasm() must be awaited first!");
22629 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_short_channel_ids(this_ptr, val);
22630 // debug statements here
22632 // MUST_USE_RES struct LDKQueryShortChannelIds QueryShortChannelIds_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKCVec_u64Z short_channel_ids_arg);
22634 export function QueryShortChannelIds_new(chain_hash_arg: number, short_channel_ids_arg: number): number {
22635 if(!isWasmInitialized) {
22636 throw new Error("initializeWasm() must be awaited first!");
22638 const nativeResponseValue = wasm.TS_QueryShortChannelIds_new(chain_hash_arg, short_channel_ids_arg);
22639 return nativeResponseValue;
22641 // uintptr_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg);
22643 export function QueryShortChannelIds_clone_ptr(arg: number): number {
22644 if(!isWasmInitialized) {
22645 throw new Error("initializeWasm() must be awaited first!");
22647 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone_ptr(arg);
22648 return nativeResponseValue;
22650 // struct LDKQueryShortChannelIds QueryShortChannelIds_clone(const struct LDKQueryShortChannelIds *NONNULL_PTR orig);
22652 export function QueryShortChannelIds_clone(orig: number): number {
22653 if(!isWasmInitialized) {
22654 throw new Error("initializeWasm() must be awaited first!");
22656 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone(orig);
22657 return nativeResponseValue;
22659 // void ReplyShortChannelIdsEnd_free(struct LDKReplyShortChannelIdsEnd this_obj);
22661 export function ReplyShortChannelIdsEnd_free(this_obj: number): void {
22662 if(!isWasmInitialized) {
22663 throw new Error("initializeWasm() must be awaited first!");
22665 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_free(this_obj);
22666 // debug statements here
22668 // const uint8_t (*ReplyShortChannelIdsEnd_get_chain_hash(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr))[32];
22670 export function ReplyShortChannelIdsEnd_get_chain_hash(this_ptr: number): number {
22671 if(!isWasmInitialized) {
22672 throw new Error("initializeWasm() must be awaited first!");
22674 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_chain_hash(this_ptr);
22675 return nativeResponseValue;
22677 // void ReplyShortChannelIdsEnd_set_chain_hash(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22679 export function ReplyShortChannelIdsEnd_set_chain_hash(this_ptr: number, val: number): void {
22680 if(!isWasmInitialized) {
22681 throw new Error("initializeWasm() must be awaited first!");
22683 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_chain_hash(this_ptr, val);
22684 // debug statements here
22686 // bool ReplyShortChannelIdsEnd_get_full_information(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr);
22688 export function ReplyShortChannelIdsEnd_get_full_information(this_ptr: number): boolean {
22689 if(!isWasmInitialized) {
22690 throw new Error("initializeWasm() must be awaited first!");
22692 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_full_information(this_ptr);
22693 return nativeResponseValue;
22695 // void ReplyShortChannelIdsEnd_set_full_information(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, bool val);
22697 export function ReplyShortChannelIdsEnd_set_full_information(this_ptr: number, val: boolean): void {
22698 if(!isWasmInitialized) {
22699 throw new Error("initializeWasm() must be awaited first!");
22701 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_full_information(this_ptr, val);
22702 // debug statements here
22704 // MUST_USE_RES struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_new(struct LDKThirtyTwoBytes chain_hash_arg, bool full_information_arg);
22706 export function ReplyShortChannelIdsEnd_new(chain_hash_arg: number, full_information_arg: boolean): number {
22707 if(!isWasmInitialized) {
22708 throw new Error("initializeWasm() must be awaited first!");
22710 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_new(chain_hash_arg, full_information_arg);
22711 return nativeResponseValue;
22713 // uintptr_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg);
22715 export function ReplyShortChannelIdsEnd_clone_ptr(arg: number): number {
22716 if(!isWasmInitialized) {
22717 throw new Error("initializeWasm() must be awaited first!");
22719 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone_ptr(arg);
22720 return nativeResponseValue;
22722 // struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_clone(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR orig);
22724 export function ReplyShortChannelIdsEnd_clone(orig: number): number {
22725 if(!isWasmInitialized) {
22726 throw new Error("initializeWasm() must be awaited first!");
22728 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone(orig);
22729 return nativeResponseValue;
22731 // void GossipTimestampFilter_free(struct LDKGossipTimestampFilter this_obj);
22733 export function GossipTimestampFilter_free(this_obj: number): void {
22734 if(!isWasmInitialized) {
22735 throw new Error("initializeWasm() must be awaited first!");
22737 const nativeResponseValue = wasm.TS_GossipTimestampFilter_free(this_obj);
22738 // debug statements here
22740 // const uint8_t (*GossipTimestampFilter_get_chain_hash(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr))[32];
22742 export function GossipTimestampFilter_get_chain_hash(this_ptr: number): number {
22743 if(!isWasmInitialized) {
22744 throw new Error("initializeWasm() must be awaited first!");
22746 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_chain_hash(this_ptr);
22747 return nativeResponseValue;
22749 // void GossipTimestampFilter_set_chain_hash(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22751 export function GossipTimestampFilter_set_chain_hash(this_ptr: number, val: number): void {
22752 if(!isWasmInitialized) {
22753 throw new Error("initializeWasm() must be awaited first!");
22755 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_chain_hash(this_ptr, val);
22756 // debug statements here
22758 // uint32_t GossipTimestampFilter_get_first_timestamp(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
22760 export function GossipTimestampFilter_get_first_timestamp(this_ptr: number): number {
22761 if(!isWasmInitialized) {
22762 throw new Error("initializeWasm() must be awaited first!");
22764 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_first_timestamp(this_ptr);
22765 return nativeResponseValue;
22767 // void GossipTimestampFilter_set_first_timestamp(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
22769 export function GossipTimestampFilter_set_first_timestamp(this_ptr: number, val: number): void {
22770 if(!isWasmInitialized) {
22771 throw new Error("initializeWasm() must be awaited first!");
22773 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_first_timestamp(this_ptr, val);
22774 // debug statements here
22776 // uint32_t GossipTimestampFilter_get_timestamp_range(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
22778 export function GossipTimestampFilter_get_timestamp_range(this_ptr: number): number {
22779 if(!isWasmInitialized) {
22780 throw new Error("initializeWasm() must be awaited first!");
22782 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_timestamp_range(this_ptr);
22783 return nativeResponseValue;
22785 // void GossipTimestampFilter_set_timestamp_range(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
22787 export function GossipTimestampFilter_set_timestamp_range(this_ptr: number, val: number): void {
22788 if(!isWasmInitialized) {
22789 throw new Error("initializeWasm() must be awaited first!");
22791 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_timestamp_range(this_ptr, val);
22792 // debug statements here
22794 // MUST_USE_RES struct LDKGossipTimestampFilter GossipTimestampFilter_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_timestamp_arg, uint32_t timestamp_range_arg);
22796 export function GossipTimestampFilter_new(chain_hash_arg: number, first_timestamp_arg: number, timestamp_range_arg: number): number {
22797 if(!isWasmInitialized) {
22798 throw new Error("initializeWasm() must be awaited first!");
22800 const nativeResponseValue = wasm.TS_GossipTimestampFilter_new(chain_hash_arg, first_timestamp_arg, timestamp_range_arg);
22801 return nativeResponseValue;
22803 // uintptr_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg);
22805 export function GossipTimestampFilter_clone_ptr(arg: number): number {
22806 if(!isWasmInitialized) {
22807 throw new Error("initializeWasm() must be awaited first!");
22809 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone_ptr(arg);
22810 return nativeResponseValue;
22812 // struct LDKGossipTimestampFilter GossipTimestampFilter_clone(const struct LDKGossipTimestampFilter *NONNULL_PTR orig);
22814 export function GossipTimestampFilter_clone(orig: number): number {
22815 if(!isWasmInitialized) {
22816 throw new Error("initializeWasm() must be awaited first!");
22818 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone(orig);
22819 return nativeResponseValue;
22821 // void ErrorAction_free(struct LDKErrorAction this_ptr);
22823 export function ErrorAction_free(this_ptr: number): void {
22824 if(!isWasmInitialized) {
22825 throw new Error("initializeWasm() must be awaited first!");
22827 const nativeResponseValue = wasm.TS_ErrorAction_free(this_ptr);
22828 // debug statements here
22830 // uintptr_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg);
22832 export function ErrorAction_clone_ptr(arg: number): number {
22833 if(!isWasmInitialized) {
22834 throw new Error("initializeWasm() must be awaited first!");
22836 const nativeResponseValue = wasm.TS_ErrorAction_clone_ptr(arg);
22837 return nativeResponseValue;
22839 // struct LDKErrorAction ErrorAction_clone(const struct LDKErrorAction *NONNULL_PTR orig);
22841 export function ErrorAction_clone(orig: number): number {
22842 if(!isWasmInitialized) {
22843 throw new Error("initializeWasm() must be awaited first!");
22845 const nativeResponseValue = wasm.TS_ErrorAction_clone(orig);
22846 return nativeResponseValue;
22848 // struct LDKErrorAction ErrorAction_disconnect_peer(struct LDKErrorMessage msg);
22850 export function ErrorAction_disconnect_peer(msg: number): number {
22851 if(!isWasmInitialized) {
22852 throw new Error("initializeWasm() must be awaited first!");
22854 const nativeResponseValue = wasm.TS_ErrorAction_disconnect_peer(msg);
22855 return nativeResponseValue;
22857 // struct LDKErrorAction ErrorAction_ignore_error(void);
22859 export function ErrorAction_ignore_error(): number {
22860 if(!isWasmInitialized) {
22861 throw new Error("initializeWasm() must be awaited first!");
22863 const nativeResponseValue = wasm.TS_ErrorAction_ignore_error();
22864 return nativeResponseValue;
22866 // struct LDKErrorAction ErrorAction_ignore_and_log(enum LDKLevel a);
22868 export function ErrorAction_ignore_and_log(a: Level): number {
22869 if(!isWasmInitialized) {
22870 throw new Error("initializeWasm() must be awaited first!");
22872 const nativeResponseValue = wasm.TS_ErrorAction_ignore_and_log(a);
22873 return nativeResponseValue;
22875 // struct LDKErrorAction ErrorAction_ignore_duplicate_gossip(void);
22877 export function ErrorAction_ignore_duplicate_gossip(): number {
22878 if(!isWasmInitialized) {
22879 throw new Error("initializeWasm() must be awaited first!");
22881 const nativeResponseValue = wasm.TS_ErrorAction_ignore_duplicate_gossip();
22882 return nativeResponseValue;
22884 // struct LDKErrorAction ErrorAction_send_error_message(struct LDKErrorMessage msg);
22886 export function ErrorAction_send_error_message(msg: number): number {
22887 if(!isWasmInitialized) {
22888 throw new Error("initializeWasm() must be awaited first!");
22890 const nativeResponseValue = wasm.TS_ErrorAction_send_error_message(msg);
22891 return nativeResponseValue;
22893 // struct LDKErrorAction ErrorAction_send_warning_message(struct LDKWarningMessage msg, enum LDKLevel log_level);
22895 export function ErrorAction_send_warning_message(msg: number, log_level: Level): number {
22896 if(!isWasmInitialized) {
22897 throw new Error("initializeWasm() must be awaited first!");
22899 const nativeResponseValue = wasm.TS_ErrorAction_send_warning_message(msg, log_level);
22900 return nativeResponseValue;
22902 // void LightningError_free(struct LDKLightningError this_obj);
22904 export function LightningError_free(this_obj: number): void {
22905 if(!isWasmInitialized) {
22906 throw new Error("initializeWasm() must be awaited first!");
22908 const nativeResponseValue = wasm.TS_LightningError_free(this_obj);
22909 // debug statements here
22911 // struct LDKStr LightningError_get_err(const struct LDKLightningError *NONNULL_PTR this_ptr);
22913 export function LightningError_get_err(this_ptr: number): number {
22914 if(!isWasmInitialized) {
22915 throw new Error("initializeWasm() must be awaited first!");
22917 const nativeResponseValue = wasm.TS_LightningError_get_err(this_ptr);
22918 return nativeResponseValue;
22920 // void LightningError_set_err(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKStr val);
22922 export function LightningError_set_err(this_ptr: number, val: number): void {
22923 if(!isWasmInitialized) {
22924 throw new Error("initializeWasm() must be awaited first!");
22926 const nativeResponseValue = wasm.TS_LightningError_set_err(this_ptr, val);
22927 // debug statements here
22929 // struct LDKErrorAction LightningError_get_action(const struct LDKLightningError *NONNULL_PTR this_ptr);
22931 export function LightningError_get_action(this_ptr: number): number {
22932 if(!isWasmInitialized) {
22933 throw new Error("initializeWasm() must be awaited first!");
22935 const nativeResponseValue = wasm.TS_LightningError_get_action(this_ptr);
22936 return nativeResponseValue;
22938 // void LightningError_set_action(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKErrorAction val);
22940 export function LightningError_set_action(this_ptr: number, val: number): void {
22941 if(!isWasmInitialized) {
22942 throw new Error("initializeWasm() must be awaited first!");
22944 const nativeResponseValue = wasm.TS_LightningError_set_action(this_ptr, val);
22945 // debug statements here
22947 // MUST_USE_RES struct LDKLightningError LightningError_new(struct LDKStr err_arg, struct LDKErrorAction action_arg);
22949 export function LightningError_new(err_arg: number, action_arg: number): number {
22950 if(!isWasmInitialized) {
22951 throw new Error("initializeWasm() must be awaited first!");
22953 const nativeResponseValue = wasm.TS_LightningError_new(err_arg, action_arg);
22954 return nativeResponseValue;
22956 // uintptr_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg);
22958 export function LightningError_clone_ptr(arg: number): number {
22959 if(!isWasmInitialized) {
22960 throw new Error("initializeWasm() must be awaited first!");
22962 const nativeResponseValue = wasm.TS_LightningError_clone_ptr(arg);
22963 return nativeResponseValue;
22965 // struct LDKLightningError LightningError_clone(const struct LDKLightningError *NONNULL_PTR orig);
22967 export function LightningError_clone(orig: number): number {
22968 if(!isWasmInitialized) {
22969 throw new Error("initializeWasm() must be awaited first!");
22971 const nativeResponseValue = wasm.TS_LightningError_clone(orig);
22972 return nativeResponseValue;
22974 // void CommitmentUpdate_free(struct LDKCommitmentUpdate this_obj);
22976 export function CommitmentUpdate_free(this_obj: number): void {
22977 if(!isWasmInitialized) {
22978 throw new Error("initializeWasm() must be awaited first!");
22980 const nativeResponseValue = wasm.TS_CommitmentUpdate_free(this_obj);
22981 // debug statements here
22983 // struct LDKCVec_UpdateAddHTLCZ CommitmentUpdate_get_update_add_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
22985 export function CommitmentUpdate_get_update_add_htlcs(this_ptr: number): number {
22986 if(!isWasmInitialized) {
22987 throw new Error("initializeWasm() must be awaited first!");
22989 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_add_htlcs(this_ptr);
22990 return nativeResponseValue;
22992 // void CommitmentUpdate_set_update_add_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateAddHTLCZ val);
22994 export function CommitmentUpdate_set_update_add_htlcs(this_ptr: number, val: number): void {
22995 if(!isWasmInitialized) {
22996 throw new Error("initializeWasm() must be awaited first!");
22998 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_add_htlcs(this_ptr, val);
22999 // debug statements here
23001 // struct LDKCVec_UpdateFulfillHTLCZ CommitmentUpdate_get_update_fulfill_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
23003 export function CommitmentUpdate_get_update_fulfill_htlcs(this_ptr: number): number {
23004 if(!isWasmInitialized) {
23005 throw new Error("initializeWasm() must be awaited first!");
23007 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fulfill_htlcs(this_ptr);
23008 return nativeResponseValue;
23010 // void CommitmentUpdate_set_update_fulfill_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFulfillHTLCZ val);
23012 export function CommitmentUpdate_set_update_fulfill_htlcs(this_ptr: number, val: number): void {
23013 if(!isWasmInitialized) {
23014 throw new Error("initializeWasm() must be awaited first!");
23016 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fulfill_htlcs(this_ptr, val);
23017 // debug statements here
23019 // struct LDKCVec_UpdateFailHTLCZ CommitmentUpdate_get_update_fail_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
23021 export function CommitmentUpdate_get_update_fail_htlcs(this_ptr: number): number {
23022 if(!isWasmInitialized) {
23023 throw new Error("initializeWasm() must be awaited first!");
23025 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_htlcs(this_ptr);
23026 return nativeResponseValue;
23028 // void CommitmentUpdate_set_update_fail_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailHTLCZ val);
23030 export function CommitmentUpdate_set_update_fail_htlcs(this_ptr: number, val: number): void {
23031 if(!isWasmInitialized) {
23032 throw new Error("initializeWasm() must be awaited first!");
23034 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_htlcs(this_ptr, val);
23035 // debug statements here
23037 // struct LDKCVec_UpdateFailMalformedHTLCZ CommitmentUpdate_get_update_fail_malformed_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
23039 export function CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr: number): number {
23040 if(!isWasmInitialized) {
23041 throw new Error("initializeWasm() must be awaited first!");
23043 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr);
23044 return nativeResponseValue;
23046 // void CommitmentUpdate_set_update_fail_malformed_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailMalformedHTLCZ val);
23048 export function CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr: number, val: number): void {
23049 if(!isWasmInitialized) {
23050 throw new Error("initializeWasm() must be awaited first!");
23052 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr, val);
23053 // debug statements here
23055 // struct LDKUpdateFee CommitmentUpdate_get_update_fee(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
23057 export function CommitmentUpdate_get_update_fee(this_ptr: number): number {
23058 if(!isWasmInitialized) {
23059 throw new Error("initializeWasm() must be awaited first!");
23061 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fee(this_ptr);
23062 return nativeResponseValue;
23064 // void CommitmentUpdate_set_update_fee(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKUpdateFee val);
23066 export function CommitmentUpdate_set_update_fee(this_ptr: number, val: number): void {
23067 if(!isWasmInitialized) {
23068 throw new Error("initializeWasm() must be awaited first!");
23070 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fee(this_ptr, val);
23071 // debug statements here
23073 // struct LDKCommitmentSigned CommitmentUpdate_get_commitment_signed(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
23075 export function CommitmentUpdate_get_commitment_signed(this_ptr: number): number {
23076 if(!isWasmInitialized) {
23077 throw new Error("initializeWasm() must be awaited first!");
23079 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_commitment_signed(this_ptr);
23080 return nativeResponseValue;
23082 // void CommitmentUpdate_set_commitment_signed(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCommitmentSigned val);
23084 export function CommitmentUpdate_set_commitment_signed(this_ptr: number, val: number): void {
23085 if(!isWasmInitialized) {
23086 throw new Error("initializeWasm() must be awaited first!");
23088 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_commitment_signed(this_ptr, val);
23089 // debug statements here
23091 // 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);
23093 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 {
23094 if(!isWasmInitialized) {
23095 throw new Error("initializeWasm() must be awaited first!");
23097 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);
23098 return nativeResponseValue;
23100 // uintptr_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg);
23102 export function CommitmentUpdate_clone_ptr(arg: number): number {
23103 if(!isWasmInitialized) {
23104 throw new Error("initializeWasm() must be awaited first!");
23106 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone_ptr(arg);
23107 return nativeResponseValue;
23109 // struct LDKCommitmentUpdate CommitmentUpdate_clone(const struct LDKCommitmentUpdate *NONNULL_PTR orig);
23111 export function CommitmentUpdate_clone(orig: number): number {
23112 if(!isWasmInitialized) {
23113 throw new Error("initializeWasm() must be awaited first!");
23115 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone(orig);
23116 return nativeResponseValue;
23118 // void ChannelMessageHandler_free(struct LDKChannelMessageHandler this_ptr);
23120 export function ChannelMessageHandler_free(this_ptr: number): void {
23121 if(!isWasmInitialized) {
23122 throw new Error("initializeWasm() must be awaited first!");
23124 const nativeResponseValue = wasm.TS_ChannelMessageHandler_free(this_ptr);
23125 // debug statements here
23127 // void RoutingMessageHandler_free(struct LDKRoutingMessageHandler this_ptr);
23129 export function RoutingMessageHandler_free(this_ptr: number): void {
23130 if(!isWasmInitialized) {
23131 throw new Error("initializeWasm() must be awaited first!");
23133 const nativeResponseValue = wasm.TS_RoutingMessageHandler_free(this_ptr);
23134 // debug statements here
23136 // struct LDKCVec_u8Z AcceptChannel_write(const struct LDKAcceptChannel *NONNULL_PTR obj);
23138 export function AcceptChannel_write(obj: number): number {
23139 if(!isWasmInitialized) {
23140 throw new Error("initializeWasm() must be awaited first!");
23142 const nativeResponseValue = wasm.TS_AcceptChannel_write(obj);
23143 return nativeResponseValue;
23145 // struct LDKCResult_AcceptChannelDecodeErrorZ AcceptChannel_read(struct LDKu8slice ser);
23147 export function AcceptChannel_read(ser: number): number {
23148 if(!isWasmInitialized) {
23149 throw new Error("initializeWasm() must be awaited first!");
23151 const nativeResponseValue = wasm.TS_AcceptChannel_read(ser);
23152 return nativeResponseValue;
23154 // struct LDKCVec_u8Z AnnouncementSignatures_write(const struct LDKAnnouncementSignatures *NONNULL_PTR obj);
23156 export function AnnouncementSignatures_write(obj: number): number {
23157 if(!isWasmInitialized) {
23158 throw new Error("initializeWasm() must be awaited first!");
23160 const nativeResponseValue = wasm.TS_AnnouncementSignatures_write(obj);
23161 return nativeResponseValue;
23163 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ AnnouncementSignatures_read(struct LDKu8slice ser);
23165 export function AnnouncementSignatures_read(ser: number): number {
23166 if(!isWasmInitialized) {
23167 throw new Error("initializeWasm() must be awaited first!");
23169 const nativeResponseValue = wasm.TS_AnnouncementSignatures_read(ser);
23170 return nativeResponseValue;
23172 // struct LDKCVec_u8Z ChannelReestablish_write(const struct LDKChannelReestablish *NONNULL_PTR obj);
23174 export function ChannelReestablish_write(obj: number): number {
23175 if(!isWasmInitialized) {
23176 throw new Error("initializeWasm() must be awaited first!");
23178 const nativeResponseValue = wasm.TS_ChannelReestablish_write(obj);
23179 return nativeResponseValue;
23181 // struct LDKCResult_ChannelReestablishDecodeErrorZ ChannelReestablish_read(struct LDKu8slice ser);
23183 export function ChannelReestablish_read(ser: number): number {
23184 if(!isWasmInitialized) {
23185 throw new Error("initializeWasm() must be awaited first!");
23187 const nativeResponseValue = wasm.TS_ChannelReestablish_read(ser);
23188 return nativeResponseValue;
23190 // struct LDKCVec_u8Z ClosingSigned_write(const struct LDKClosingSigned *NONNULL_PTR obj);
23192 export function ClosingSigned_write(obj: number): number {
23193 if(!isWasmInitialized) {
23194 throw new Error("initializeWasm() must be awaited first!");
23196 const nativeResponseValue = wasm.TS_ClosingSigned_write(obj);
23197 return nativeResponseValue;
23199 // struct LDKCResult_ClosingSignedDecodeErrorZ ClosingSigned_read(struct LDKu8slice ser);
23201 export function ClosingSigned_read(ser: number): number {
23202 if(!isWasmInitialized) {
23203 throw new Error("initializeWasm() must be awaited first!");
23205 const nativeResponseValue = wasm.TS_ClosingSigned_read(ser);
23206 return nativeResponseValue;
23208 // struct LDKCVec_u8Z ClosingSignedFeeRange_write(const struct LDKClosingSignedFeeRange *NONNULL_PTR obj);
23210 export function ClosingSignedFeeRange_write(obj: number): number {
23211 if(!isWasmInitialized) {
23212 throw new Error("initializeWasm() must be awaited first!");
23214 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_write(obj);
23215 return nativeResponseValue;
23217 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ ClosingSignedFeeRange_read(struct LDKu8slice ser);
23219 export function ClosingSignedFeeRange_read(ser: number): number {
23220 if(!isWasmInitialized) {
23221 throw new Error("initializeWasm() must be awaited first!");
23223 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_read(ser);
23224 return nativeResponseValue;
23226 // struct LDKCVec_u8Z CommitmentSigned_write(const struct LDKCommitmentSigned *NONNULL_PTR obj);
23228 export function CommitmentSigned_write(obj: number): number {
23229 if(!isWasmInitialized) {
23230 throw new Error("initializeWasm() must be awaited first!");
23232 const nativeResponseValue = wasm.TS_CommitmentSigned_write(obj);
23233 return nativeResponseValue;
23235 // struct LDKCResult_CommitmentSignedDecodeErrorZ CommitmentSigned_read(struct LDKu8slice ser);
23237 export function CommitmentSigned_read(ser: number): number {
23238 if(!isWasmInitialized) {
23239 throw new Error("initializeWasm() must be awaited first!");
23241 const nativeResponseValue = wasm.TS_CommitmentSigned_read(ser);
23242 return nativeResponseValue;
23244 // struct LDKCVec_u8Z FundingCreated_write(const struct LDKFundingCreated *NONNULL_PTR obj);
23246 export function FundingCreated_write(obj: number): number {
23247 if(!isWasmInitialized) {
23248 throw new Error("initializeWasm() must be awaited first!");
23250 const nativeResponseValue = wasm.TS_FundingCreated_write(obj);
23251 return nativeResponseValue;
23253 // struct LDKCResult_FundingCreatedDecodeErrorZ FundingCreated_read(struct LDKu8slice ser);
23255 export function FundingCreated_read(ser: number): number {
23256 if(!isWasmInitialized) {
23257 throw new Error("initializeWasm() must be awaited first!");
23259 const nativeResponseValue = wasm.TS_FundingCreated_read(ser);
23260 return nativeResponseValue;
23262 // struct LDKCVec_u8Z FundingSigned_write(const struct LDKFundingSigned *NONNULL_PTR obj);
23264 export function FundingSigned_write(obj: number): number {
23265 if(!isWasmInitialized) {
23266 throw new Error("initializeWasm() must be awaited first!");
23268 const nativeResponseValue = wasm.TS_FundingSigned_write(obj);
23269 return nativeResponseValue;
23271 // struct LDKCResult_FundingSignedDecodeErrorZ FundingSigned_read(struct LDKu8slice ser);
23273 export function FundingSigned_read(ser: number): number {
23274 if(!isWasmInitialized) {
23275 throw new Error("initializeWasm() must be awaited first!");
23277 const nativeResponseValue = wasm.TS_FundingSigned_read(ser);
23278 return nativeResponseValue;
23280 // struct LDKCVec_u8Z FundingLocked_write(const struct LDKFundingLocked *NONNULL_PTR obj);
23282 export function FundingLocked_write(obj: number): number {
23283 if(!isWasmInitialized) {
23284 throw new Error("initializeWasm() must be awaited first!");
23286 const nativeResponseValue = wasm.TS_FundingLocked_write(obj);
23287 return nativeResponseValue;
23289 // struct LDKCResult_FundingLockedDecodeErrorZ FundingLocked_read(struct LDKu8slice ser);
23291 export function FundingLocked_read(ser: number): number {
23292 if(!isWasmInitialized) {
23293 throw new Error("initializeWasm() must be awaited first!");
23295 const nativeResponseValue = wasm.TS_FundingLocked_read(ser);
23296 return nativeResponseValue;
23298 // struct LDKCVec_u8Z Init_write(const struct LDKInit *NONNULL_PTR obj);
23300 export function Init_write(obj: number): number {
23301 if(!isWasmInitialized) {
23302 throw new Error("initializeWasm() must be awaited first!");
23304 const nativeResponseValue = wasm.TS_Init_write(obj);
23305 return nativeResponseValue;
23307 // struct LDKCResult_InitDecodeErrorZ Init_read(struct LDKu8slice ser);
23309 export function Init_read(ser: number): number {
23310 if(!isWasmInitialized) {
23311 throw new Error("initializeWasm() must be awaited first!");
23313 const nativeResponseValue = wasm.TS_Init_read(ser);
23314 return nativeResponseValue;
23316 // struct LDKCVec_u8Z OpenChannel_write(const struct LDKOpenChannel *NONNULL_PTR obj);
23318 export function OpenChannel_write(obj: number): number {
23319 if(!isWasmInitialized) {
23320 throw new Error("initializeWasm() must be awaited first!");
23322 const nativeResponseValue = wasm.TS_OpenChannel_write(obj);
23323 return nativeResponseValue;
23325 // struct LDKCResult_OpenChannelDecodeErrorZ OpenChannel_read(struct LDKu8slice ser);
23327 export function OpenChannel_read(ser: number): number {
23328 if(!isWasmInitialized) {
23329 throw new Error("initializeWasm() must be awaited first!");
23331 const nativeResponseValue = wasm.TS_OpenChannel_read(ser);
23332 return nativeResponseValue;
23334 // struct LDKCVec_u8Z RevokeAndACK_write(const struct LDKRevokeAndACK *NONNULL_PTR obj);
23336 export function RevokeAndACK_write(obj: number): number {
23337 if(!isWasmInitialized) {
23338 throw new Error("initializeWasm() must be awaited first!");
23340 const nativeResponseValue = wasm.TS_RevokeAndACK_write(obj);
23341 return nativeResponseValue;
23343 // struct LDKCResult_RevokeAndACKDecodeErrorZ RevokeAndACK_read(struct LDKu8slice ser);
23345 export function RevokeAndACK_read(ser: number): number {
23346 if(!isWasmInitialized) {
23347 throw new Error("initializeWasm() must be awaited first!");
23349 const nativeResponseValue = wasm.TS_RevokeAndACK_read(ser);
23350 return nativeResponseValue;
23352 // struct LDKCVec_u8Z Shutdown_write(const struct LDKShutdown *NONNULL_PTR obj);
23354 export function Shutdown_write(obj: number): number {
23355 if(!isWasmInitialized) {
23356 throw new Error("initializeWasm() must be awaited first!");
23358 const nativeResponseValue = wasm.TS_Shutdown_write(obj);
23359 return nativeResponseValue;
23361 // struct LDKCResult_ShutdownDecodeErrorZ Shutdown_read(struct LDKu8slice ser);
23363 export function Shutdown_read(ser: number): number {
23364 if(!isWasmInitialized) {
23365 throw new Error("initializeWasm() must be awaited first!");
23367 const nativeResponseValue = wasm.TS_Shutdown_read(ser);
23368 return nativeResponseValue;
23370 // struct LDKCVec_u8Z UpdateFailHTLC_write(const struct LDKUpdateFailHTLC *NONNULL_PTR obj);
23372 export function UpdateFailHTLC_write(obj: number): number {
23373 if(!isWasmInitialized) {
23374 throw new Error("initializeWasm() must be awaited first!");
23376 const nativeResponseValue = wasm.TS_UpdateFailHTLC_write(obj);
23377 return nativeResponseValue;
23379 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ UpdateFailHTLC_read(struct LDKu8slice ser);
23381 export function UpdateFailHTLC_read(ser: number): number {
23382 if(!isWasmInitialized) {
23383 throw new Error("initializeWasm() must be awaited first!");
23385 const nativeResponseValue = wasm.TS_UpdateFailHTLC_read(ser);
23386 return nativeResponseValue;
23388 // struct LDKCVec_u8Z UpdateFailMalformedHTLC_write(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR obj);
23390 export function UpdateFailMalformedHTLC_write(obj: number): number {
23391 if(!isWasmInitialized) {
23392 throw new Error("initializeWasm() must be awaited first!");
23394 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_write(obj);
23395 return nativeResponseValue;
23397 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ UpdateFailMalformedHTLC_read(struct LDKu8slice ser);
23399 export function UpdateFailMalformedHTLC_read(ser: number): number {
23400 if(!isWasmInitialized) {
23401 throw new Error("initializeWasm() must be awaited first!");
23403 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_read(ser);
23404 return nativeResponseValue;
23406 // struct LDKCVec_u8Z UpdateFee_write(const struct LDKUpdateFee *NONNULL_PTR obj);
23408 export function UpdateFee_write(obj: number): number {
23409 if(!isWasmInitialized) {
23410 throw new Error("initializeWasm() must be awaited first!");
23412 const nativeResponseValue = wasm.TS_UpdateFee_write(obj);
23413 return nativeResponseValue;
23415 // struct LDKCResult_UpdateFeeDecodeErrorZ UpdateFee_read(struct LDKu8slice ser);
23417 export function UpdateFee_read(ser: number): number {
23418 if(!isWasmInitialized) {
23419 throw new Error("initializeWasm() must be awaited first!");
23421 const nativeResponseValue = wasm.TS_UpdateFee_read(ser);
23422 return nativeResponseValue;
23424 // struct LDKCVec_u8Z UpdateFulfillHTLC_write(const struct LDKUpdateFulfillHTLC *NONNULL_PTR obj);
23426 export function UpdateFulfillHTLC_write(obj: number): number {
23427 if(!isWasmInitialized) {
23428 throw new Error("initializeWasm() must be awaited first!");
23430 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_write(obj);
23431 return nativeResponseValue;
23433 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ UpdateFulfillHTLC_read(struct LDKu8slice ser);
23435 export function UpdateFulfillHTLC_read(ser: number): number {
23436 if(!isWasmInitialized) {
23437 throw new Error("initializeWasm() must be awaited first!");
23439 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_read(ser);
23440 return nativeResponseValue;
23442 // struct LDKCVec_u8Z UpdateAddHTLC_write(const struct LDKUpdateAddHTLC *NONNULL_PTR obj);
23444 export function UpdateAddHTLC_write(obj: number): number {
23445 if(!isWasmInitialized) {
23446 throw new Error("initializeWasm() must be awaited first!");
23448 const nativeResponseValue = wasm.TS_UpdateAddHTLC_write(obj);
23449 return nativeResponseValue;
23451 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ UpdateAddHTLC_read(struct LDKu8slice ser);
23453 export function UpdateAddHTLC_read(ser: number): number {
23454 if(!isWasmInitialized) {
23455 throw new Error("initializeWasm() must be awaited first!");
23457 const nativeResponseValue = wasm.TS_UpdateAddHTLC_read(ser);
23458 return nativeResponseValue;
23460 // struct LDKCVec_u8Z Ping_write(const struct LDKPing *NONNULL_PTR obj);
23462 export function Ping_write(obj: number): number {
23463 if(!isWasmInitialized) {
23464 throw new Error("initializeWasm() must be awaited first!");
23466 const nativeResponseValue = wasm.TS_Ping_write(obj);
23467 return nativeResponseValue;
23469 // struct LDKCResult_PingDecodeErrorZ Ping_read(struct LDKu8slice ser);
23471 export function Ping_read(ser: number): number {
23472 if(!isWasmInitialized) {
23473 throw new Error("initializeWasm() must be awaited first!");
23475 const nativeResponseValue = wasm.TS_Ping_read(ser);
23476 return nativeResponseValue;
23478 // struct LDKCVec_u8Z Pong_write(const struct LDKPong *NONNULL_PTR obj);
23480 export function Pong_write(obj: number): number {
23481 if(!isWasmInitialized) {
23482 throw new Error("initializeWasm() must be awaited first!");
23484 const nativeResponseValue = wasm.TS_Pong_write(obj);
23485 return nativeResponseValue;
23487 // struct LDKCResult_PongDecodeErrorZ Pong_read(struct LDKu8slice ser);
23489 export function Pong_read(ser: number): number {
23490 if(!isWasmInitialized) {
23491 throw new Error("initializeWasm() must be awaited first!");
23493 const nativeResponseValue = wasm.TS_Pong_read(ser);
23494 return nativeResponseValue;
23496 // struct LDKCVec_u8Z UnsignedChannelAnnouncement_write(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR obj);
23498 export function UnsignedChannelAnnouncement_write(obj: number): number {
23499 if(!isWasmInitialized) {
23500 throw new Error("initializeWasm() must be awaited first!");
23502 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_write(obj);
23503 return nativeResponseValue;
23505 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ UnsignedChannelAnnouncement_read(struct LDKu8slice ser);
23507 export function UnsignedChannelAnnouncement_read(ser: number): number {
23508 if(!isWasmInitialized) {
23509 throw new Error("initializeWasm() must be awaited first!");
23511 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_read(ser);
23512 return nativeResponseValue;
23514 // struct LDKCVec_u8Z ChannelAnnouncement_write(const struct LDKChannelAnnouncement *NONNULL_PTR obj);
23516 export function ChannelAnnouncement_write(obj: number): number {
23517 if(!isWasmInitialized) {
23518 throw new Error("initializeWasm() must be awaited first!");
23520 const nativeResponseValue = wasm.TS_ChannelAnnouncement_write(obj);
23521 return nativeResponseValue;
23523 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ ChannelAnnouncement_read(struct LDKu8slice ser);
23525 export function ChannelAnnouncement_read(ser: number): number {
23526 if(!isWasmInitialized) {
23527 throw new Error("initializeWasm() must be awaited first!");
23529 const nativeResponseValue = wasm.TS_ChannelAnnouncement_read(ser);
23530 return nativeResponseValue;
23532 // struct LDKCVec_u8Z UnsignedChannelUpdate_write(const struct LDKUnsignedChannelUpdate *NONNULL_PTR obj);
23534 export function UnsignedChannelUpdate_write(obj: number): number {
23535 if(!isWasmInitialized) {
23536 throw new Error("initializeWasm() must be awaited first!");
23538 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_write(obj);
23539 return nativeResponseValue;
23541 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ UnsignedChannelUpdate_read(struct LDKu8slice ser);
23543 export function UnsignedChannelUpdate_read(ser: number): number {
23544 if(!isWasmInitialized) {
23545 throw new Error("initializeWasm() must be awaited first!");
23547 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_read(ser);
23548 return nativeResponseValue;
23550 // struct LDKCVec_u8Z ChannelUpdate_write(const struct LDKChannelUpdate *NONNULL_PTR obj);
23552 export function ChannelUpdate_write(obj: number): number {
23553 if(!isWasmInitialized) {
23554 throw new Error("initializeWasm() must be awaited first!");
23556 const nativeResponseValue = wasm.TS_ChannelUpdate_write(obj);
23557 return nativeResponseValue;
23559 // struct LDKCResult_ChannelUpdateDecodeErrorZ ChannelUpdate_read(struct LDKu8slice ser);
23561 export function ChannelUpdate_read(ser: number): number {
23562 if(!isWasmInitialized) {
23563 throw new Error("initializeWasm() must be awaited first!");
23565 const nativeResponseValue = wasm.TS_ChannelUpdate_read(ser);
23566 return nativeResponseValue;
23568 // struct LDKCVec_u8Z ErrorMessage_write(const struct LDKErrorMessage *NONNULL_PTR obj);
23570 export function ErrorMessage_write(obj: number): number {
23571 if(!isWasmInitialized) {
23572 throw new Error("initializeWasm() must be awaited first!");
23574 const nativeResponseValue = wasm.TS_ErrorMessage_write(obj);
23575 return nativeResponseValue;
23577 // struct LDKCResult_ErrorMessageDecodeErrorZ ErrorMessage_read(struct LDKu8slice ser);
23579 export function ErrorMessage_read(ser: number): number {
23580 if(!isWasmInitialized) {
23581 throw new Error("initializeWasm() must be awaited first!");
23583 const nativeResponseValue = wasm.TS_ErrorMessage_read(ser);
23584 return nativeResponseValue;
23586 // struct LDKCVec_u8Z WarningMessage_write(const struct LDKWarningMessage *NONNULL_PTR obj);
23588 export function WarningMessage_write(obj: number): number {
23589 if(!isWasmInitialized) {
23590 throw new Error("initializeWasm() must be awaited first!");
23592 const nativeResponseValue = wasm.TS_WarningMessage_write(obj);
23593 return nativeResponseValue;
23595 // struct LDKCResult_WarningMessageDecodeErrorZ WarningMessage_read(struct LDKu8slice ser);
23597 export function WarningMessage_read(ser: number): number {
23598 if(!isWasmInitialized) {
23599 throw new Error("initializeWasm() must be awaited first!");
23601 const nativeResponseValue = wasm.TS_WarningMessage_read(ser);
23602 return nativeResponseValue;
23604 // struct LDKCVec_u8Z UnsignedNodeAnnouncement_write(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR obj);
23606 export function UnsignedNodeAnnouncement_write(obj: number): number {
23607 if(!isWasmInitialized) {
23608 throw new Error("initializeWasm() must be awaited first!");
23610 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_write(obj);
23611 return nativeResponseValue;
23613 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ UnsignedNodeAnnouncement_read(struct LDKu8slice ser);
23615 export function UnsignedNodeAnnouncement_read(ser: number): number {
23616 if(!isWasmInitialized) {
23617 throw new Error("initializeWasm() must be awaited first!");
23619 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_read(ser);
23620 return nativeResponseValue;
23622 // struct LDKCVec_u8Z NodeAnnouncement_write(const struct LDKNodeAnnouncement *NONNULL_PTR obj);
23624 export function NodeAnnouncement_write(obj: number): number {
23625 if(!isWasmInitialized) {
23626 throw new Error("initializeWasm() must be awaited first!");
23628 const nativeResponseValue = wasm.TS_NodeAnnouncement_write(obj);
23629 return nativeResponseValue;
23631 // struct LDKCResult_NodeAnnouncementDecodeErrorZ NodeAnnouncement_read(struct LDKu8slice ser);
23633 export function NodeAnnouncement_read(ser: number): number {
23634 if(!isWasmInitialized) {
23635 throw new Error("initializeWasm() must be awaited first!");
23637 const nativeResponseValue = wasm.TS_NodeAnnouncement_read(ser);
23638 return nativeResponseValue;
23640 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ QueryShortChannelIds_read(struct LDKu8slice ser);
23642 export function QueryShortChannelIds_read(ser: number): number {
23643 if(!isWasmInitialized) {
23644 throw new Error("initializeWasm() must be awaited first!");
23646 const nativeResponseValue = wasm.TS_QueryShortChannelIds_read(ser);
23647 return nativeResponseValue;
23649 // struct LDKCVec_u8Z QueryShortChannelIds_write(const struct LDKQueryShortChannelIds *NONNULL_PTR obj);
23651 export function QueryShortChannelIds_write(obj: number): number {
23652 if(!isWasmInitialized) {
23653 throw new Error("initializeWasm() must be awaited first!");
23655 const nativeResponseValue = wasm.TS_QueryShortChannelIds_write(obj);
23656 return nativeResponseValue;
23658 // struct LDKCVec_u8Z ReplyShortChannelIdsEnd_write(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR obj);
23660 export function ReplyShortChannelIdsEnd_write(obj: number): number {
23661 if(!isWasmInitialized) {
23662 throw new Error("initializeWasm() must be awaited first!");
23664 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_write(obj);
23665 return nativeResponseValue;
23667 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ ReplyShortChannelIdsEnd_read(struct LDKu8slice ser);
23669 export function ReplyShortChannelIdsEnd_read(ser: number): number {
23670 if(!isWasmInitialized) {
23671 throw new Error("initializeWasm() must be awaited first!");
23673 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_read(ser);
23674 return nativeResponseValue;
23676 // MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
23678 export function QueryChannelRange_end_blocknum(this_arg: number): number {
23679 if(!isWasmInitialized) {
23680 throw new Error("initializeWasm() must be awaited first!");
23682 const nativeResponseValue = wasm.TS_QueryChannelRange_end_blocknum(this_arg);
23683 return nativeResponseValue;
23685 // struct LDKCVec_u8Z QueryChannelRange_write(const struct LDKQueryChannelRange *NONNULL_PTR obj);
23687 export function QueryChannelRange_write(obj: number): number {
23688 if(!isWasmInitialized) {
23689 throw new Error("initializeWasm() must be awaited first!");
23691 const nativeResponseValue = wasm.TS_QueryChannelRange_write(obj);
23692 return nativeResponseValue;
23694 // struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
23696 export function QueryChannelRange_read(ser: number): number {
23697 if(!isWasmInitialized) {
23698 throw new Error("initializeWasm() must be awaited first!");
23700 const nativeResponseValue = wasm.TS_QueryChannelRange_read(ser);
23701 return nativeResponseValue;
23703 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ ReplyChannelRange_read(struct LDKu8slice ser);
23705 export function ReplyChannelRange_read(ser: number): number {
23706 if(!isWasmInitialized) {
23707 throw new Error("initializeWasm() must be awaited first!");
23709 const nativeResponseValue = wasm.TS_ReplyChannelRange_read(ser);
23710 return nativeResponseValue;
23712 // struct LDKCVec_u8Z ReplyChannelRange_write(const struct LDKReplyChannelRange *NONNULL_PTR obj);
23714 export function ReplyChannelRange_write(obj: number): number {
23715 if(!isWasmInitialized) {
23716 throw new Error("initializeWasm() must be awaited first!");
23718 const nativeResponseValue = wasm.TS_ReplyChannelRange_write(obj);
23719 return nativeResponseValue;
23721 // struct LDKCVec_u8Z GossipTimestampFilter_write(const struct LDKGossipTimestampFilter *NONNULL_PTR obj);
23723 export function GossipTimestampFilter_write(obj: number): number {
23724 if(!isWasmInitialized) {
23725 throw new Error("initializeWasm() must be awaited first!");
23727 const nativeResponseValue = wasm.TS_GossipTimestampFilter_write(obj);
23728 return nativeResponseValue;
23730 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ GossipTimestampFilter_read(struct LDKu8slice ser);
23732 export function GossipTimestampFilter_read(ser: number): number {
23733 if(!isWasmInitialized) {
23734 throw new Error("initializeWasm() must be awaited first!");
23736 const nativeResponseValue = wasm.TS_GossipTimestampFilter_read(ser);
23737 return nativeResponseValue;
23739 // void CustomMessageHandler_free(struct LDKCustomMessageHandler this_ptr);
23741 export function CustomMessageHandler_free(this_ptr: number): void {
23742 if(!isWasmInitialized) {
23743 throw new Error("initializeWasm() must be awaited first!");
23745 const nativeResponseValue = wasm.TS_CustomMessageHandler_free(this_ptr);
23746 // debug statements here
23748 // void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_obj);
23750 export function IgnoringMessageHandler_free(this_obj: number): void {
23751 if(!isWasmInitialized) {
23752 throw new Error("initializeWasm() must be awaited first!");
23754 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_free(this_obj);
23755 // debug statements here
23757 // MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void);
23759 export function IgnoringMessageHandler_new(): number {
23760 if(!isWasmInitialized) {
23761 throw new Error("initializeWasm() must be awaited first!");
23763 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_new();
23764 return nativeResponseValue;
23766 // struct LDKMessageSendEventsProvider IgnoringMessageHandler_as_MessageSendEventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
23768 export function IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number {
23769 if(!isWasmInitialized) {
23770 throw new Error("initializeWasm() must be awaited first!");
23772 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg);
23773 return nativeResponseValue;
23775 // struct LDKRoutingMessageHandler IgnoringMessageHandler_as_RoutingMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
23777 export function IgnoringMessageHandler_as_RoutingMessageHandler(this_arg: number): number {
23778 if(!isWasmInitialized) {
23779 throw new Error("initializeWasm() must be awaited first!");
23781 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_RoutingMessageHandler(this_arg);
23782 return nativeResponseValue;
23784 // struct LDKCustomMessageReader IgnoringMessageHandler_as_CustomMessageReader(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
23786 export function IgnoringMessageHandler_as_CustomMessageReader(this_arg: number): number {
23787 if(!isWasmInitialized) {
23788 throw new Error("initializeWasm() must be awaited first!");
23790 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageReader(this_arg);
23791 return nativeResponseValue;
23793 // struct LDKCustomMessageHandler IgnoringMessageHandler_as_CustomMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
23795 export function IgnoringMessageHandler_as_CustomMessageHandler(this_arg: number): number {
23796 if(!isWasmInitialized) {
23797 throw new Error("initializeWasm() must be awaited first!");
23799 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageHandler(this_arg);
23800 return nativeResponseValue;
23802 // void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_obj);
23804 export function ErroringMessageHandler_free(this_obj: number): void {
23805 if(!isWasmInitialized) {
23806 throw new Error("initializeWasm() must be awaited first!");
23808 const nativeResponseValue = wasm.TS_ErroringMessageHandler_free(this_obj);
23809 // debug statements here
23811 // MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void);
23813 export function ErroringMessageHandler_new(): number {
23814 if(!isWasmInitialized) {
23815 throw new Error("initializeWasm() must be awaited first!");
23817 const nativeResponseValue = wasm.TS_ErroringMessageHandler_new();
23818 return nativeResponseValue;
23820 // struct LDKMessageSendEventsProvider ErroringMessageHandler_as_MessageSendEventsProvider(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
23822 export function ErroringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number {
23823 if(!isWasmInitialized) {
23824 throw new Error("initializeWasm() must be awaited first!");
23826 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_MessageSendEventsProvider(this_arg);
23827 return nativeResponseValue;
23829 // struct LDKChannelMessageHandler ErroringMessageHandler_as_ChannelMessageHandler(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
23831 export function ErroringMessageHandler_as_ChannelMessageHandler(this_arg: number): number {
23832 if(!isWasmInitialized) {
23833 throw new Error("initializeWasm() must be awaited first!");
23835 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_ChannelMessageHandler(this_arg);
23836 return nativeResponseValue;
23838 // void MessageHandler_free(struct LDKMessageHandler this_obj);
23840 export function MessageHandler_free(this_obj: number): void {
23841 if(!isWasmInitialized) {
23842 throw new Error("initializeWasm() must be awaited first!");
23844 const nativeResponseValue = wasm.TS_MessageHandler_free(this_obj);
23845 // debug statements here
23847 // const struct LDKChannelMessageHandler *MessageHandler_get_chan_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
23849 export function MessageHandler_get_chan_handler(this_ptr: number): number {
23850 if(!isWasmInitialized) {
23851 throw new Error("initializeWasm() must be awaited first!");
23853 const nativeResponseValue = wasm.TS_MessageHandler_get_chan_handler(this_ptr);
23854 return nativeResponseValue;
23856 // void MessageHandler_set_chan_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKChannelMessageHandler val);
23858 export function MessageHandler_set_chan_handler(this_ptr: number, val: number): void {
23859 if(!isWasmInitialized) {
23860 throw new Error("initializeWasm() must be awaited first!");
23862 const nativeResponseValue = wasm.TS_MessageHandler_set_chan_handler(this_ptr, val);
23863 // debug statements here
23865 // const struct LDKRoutingMessageHandler *MessageHandler_get_route_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
23867 export function MessageHandler_get_route_handler(this_ptr: number): number {
23868 if(!isWasmInitialized) {
23869 throw new Error("initializeWasm() must be awaited first!");
23871 const nativeResponseValue = wasm.TS_MessageHandler_get_route_handler(this_ptr);
23872 return nativeResponseValue;
23874 // void MessageHandler_set_route_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKRoutingMessageHandler val);
23876 export function MessageHandler_set_route_handler(this_ptr: number, val: number): void {
23877 if(!isWasmInitialized) {
23878 throw new Error("initializeWasm() must be awaited first!");
23880 const nativeResponseValue = wasm.TS_MessageHandler_set_route_handler(this_ptr, val);
23881 // debug statements here
23883 // MUST_USE_RES struct LDKMessageHandler MessageHandler_new(struct LDKChannelMessageHandler chan_handler_arg, struct LDKRoutingMessageHandler route_handler_arg);
23885 export function MessageHandler_new(chan_handler_arg: number, route_handler_arg: number): number {
23886 if(!isWasmInitialized) {
23887 throw new Error("initializeWasm() must be awaited first!");
23889 const nativeResponseValue = wasm.TS_MessageHandler_new(chan_handler_arg, route_handler_arg);
23890 return nativeResponseValue;
23892 // uintptr_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg);
23894 export function SocketDescriptor_clone_ptr(arg: number): number {
23895 if(!isWasmInitialized) {
23896 throw new Error("initializeWasm() must be awaited first!");
23898 const nativeResponseValue = wasm.TS_SocketDescriptor_clone_ptr(arg);
23899 return nativeResponseValue;
23901 // struct LDKSocketDescriptor SocketDescriptor_clone(const struct LDKSocketDescriptor *NONNULL_PTR orig);
23903 export function SocketDescriptor_clone(orig: number): number {
23904 if(!isWasmInitialized) {
23905 throw new Error("initializeWasm() must be awaited first!");
23907 const nativeResponseValue = wasm.TS_SocketDescriptor_clone(orig);
23908 return nativeResponseValue;
23910 // void SocketDescriptor_free(struct LDKSocketDescriptor this_ptr);
23912 export function SocketDescriptor_free(this_ptr: number): void {
23913 if(!isWasmInitialized) {
23914 throw new Error("initializeWasm() must be awaited first!");
23916 const nativeResponseValue = wasm.TS_SocketDescriptor_free(this_ptr);
23917 // debug statements here
23919 // void PeerHandleError_free(struct LDKPeerHandleError this_obj);
23921 export function PeerHandleError_free(this_obj: number): void {
23922 if(!isWasmInitialized) {
23923 throw new Error("initializeWasm() must be awaited first!");
23925 const nativeResponseValue = wasm.TS_PeerHandleError_free(this_obj);
23926 // debug statements here
23928 // bool PeerHandleError_get_no_connection_possible(const struct LDKPeerHandleError *NONNULL_PTR this_ptr);
23930 export function PeerHandleError_get_no_connection_possible(this_ptr: number): boolean {
23931 if(!isWasmInitialized) {
23932 throw new Error("initializeWasm() must be awaited first!");
23934 const nativeResponseValue = wasm.TS_PeerHandleError_get_no_connection_possible(this_ptr);
23935 return nativeResponseValue;
23937 // void PeerHandleError_set_no_connection_possible(struct LDKPeerHandleError *NONNULL_PTR this_ptr, bool val);
23939 export function PeerHandleError_set_no_connection_possible(this_ptr: number, val: boolean): void {
23940 if(!isWasmInitialized) {
23941 throw new Error("initializeWasm() must be awaited first!");
23943 const nativeResponseValue = wasm.TS_PeerHandleError_set_no_connection_possible(this_ptr, val);
23944 // debug statements here
23946 // MUST_USE_RES struct LDKPeerHandleError PeerHandleError_new(bool no_connection_possible_arg);
23948 export function PeerHandleError_new(no_connection_possible_arg: boolean): number {
23949 if(!isWasmInitialized) {
23950 throw new Error("initializeWasm() must be awaited first!");
23952 const nativeResponseValue = wasm.TS_PeerHandleError_new(no_connection_possible_arg);
23953 return nativeResponseValue;
23955 // uintptr_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg);
23957 export function PeerHandleError_clone_ptr(arg: number): number {
23958 if(!isWasmInitialized) {
23959 throw new Error("initializeWasm() must be awaited first!");
23961 const nativeResponseValue = wasm.TS_PeerHandleError_clone_ptr(arg);
23962 return nativeResponseValue;
23964 // struct LDKPeerHandleError PeerHandleError_clone(const struct LDKPeerHandleError *NONNULL_PTR orig);
23966 export function PeerHandleError_clone(orig: number): number {
23967 if(!isWasmInitialized) {
23968 throw new Error("initializeWasm() must be awaited first!");
23970 const nativeResponseValue = wasm.TS_PeerHandleError_clone(orig);
23971 return nativeResponseValue;
23973 // void PeerManager_free(struct LDKPeerManager this_obj);
23975 export function PeerManager_free(this_obj: number): void {
23976 if(!isWasmInitialized) {
23977 throw new Error("initializeWasm() must be awaited first!");
23979 const nativeResponseValue = wasm.TS_PeerManager_free(this_obj);
23980 // debug statements here
23982 // 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);
23984 export function PeerManager_new(message_handler: number, our_node_secret: number, ephemeral_random_data: number, logger: number, custom_message_handler: number): number {
23985 if(!isWasmInitialized) {
23986 throw new Error("initializeWasm() must be awaited first!");
23988 const nativeResponseValue = wasm.TS_PeerManager_new(message_handler, our_node_secret, ephemeral_random_data, logger, custom_message_handler);
23989 return nativeResponseValue;
23991 // MUST_USE_RES struct LDKCVec_PublicKeyZ PeerManager_get_peer_node_ids(const struct LDKPeerManager *NONNULL_PTR this_arg);
23993 export function PeerManager_get_peer_node_ids(this_arg: number): number {
23994 if(!isWasmInitialized) {
23995 throw new Error("initializeWasm() must be awaited first!");
23997 const nativeResponseValue = wasm.TS_PeerManager_get_peer_node_ids(this_arg);
23998 return nativeResponseValue;
24000 // 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);
24002 export function PeerManager_new_outbound_connection(this_arg: number, their_node_id: number, descriptor: number): number {
24003 if(!isWasmInitialized) {
24004 throw new Error("initializeWasm() must be awaited first!");
24006 const nativeResponseValue = wasm.TS_PeerManager_new_outbound_connection(this_arg, their_node_id, descriptor);
24007 return nativeResponseValue;
24009 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_new_inbound_connection(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor descriptor);
24011 export function PeerManager_new_inbound_connection(this_arg: number, descriptor: number): number {
24012 if(!isWasmInitialized) {
24013 throw new Error("initializeWasm() must be awaited first!");
24015 const nativeResponseValue = wasm.TS_PeerManager_new_inbound_connection(this_arg, descriptor);
24016 return nativeResponseValue;
24018 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_write_buffer_space_avail(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor *NONNULL_PTR descriptor);
24020 export function PeerManager_write_buffer_space_avail(this_arg: number, descriptor: number): number {
24021 if(!isWasmInitialized) {
24022 throw new Error("initializeWasm() must be awaited first!");
24024 const nativeResponseValue = wasm.TS_PeerManager_write_buffer_space_avail(this_arg, descriptor);
24025 return nativeResponseValue;
24027 // 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);
24029 export function PeerManager_read_event(this_arg: number, peer_descriptor: number, data: number): number {
24030 if(!isWasmInitialized) {
24031 throw new Error("initializeWasm() must be awaited first!");
24033 const nativeResponseValue = wasm.TS_PeerManager_read_event(this_arg, peer_descriptor, data);
24034 return nativeResponseValue;
24036 // void PeerManager_process_events(const struct LDKPeerManager *NONNULL_PTR this_arg);
24038 export function PeerManager_process_events(this_arg: number): void {
24039 if(!isWasmInitialized) {
24040 throw new Error("initializeWasm() must be awaited first!");
24042 const nativeResponseValue = wasm.TS_PeerManager_process_events(this_arg);
24043 // debug statements here
24045 // void PeerManager_socket_disconnected(const struct LDKPeerManager *NONNULL_PTR this_arg, const struct LDKSocketDescriptor *NONNULL_PTR descriptor);
24047 export function PeerManager_socket_disconnected(this_arg: number, descriptor: number): void {
24048 if(!isWasmInitialized) {
24049 throw new Error("initializeWasm() must be awaited first!");
24051 const nativeResponseValue = wasm.TS_PeerManager_socket_disconnected(this_arg, descriptor);
24052 // debug statements here
24054 // void PeerManager_disconnect_by_node_id(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id, bool no_connection_possible);
24056 export function PeerManager_disconnect_by_node_id(this_arg: number, node_id: number, no_connection_possible: boolean): void {
24057 if(!isWasmInitialized) {
24058 throw new Error("initializeWasm() must be awaited first!");
24060 const nativeResponseValue = wasm.TS_PeerManager_disconnect_by_node_id(this_arg, node_id, no_connection_possible);
24061 // debug statements here
24063 // void PeerManager_disconnect_all_peers(const struct LDKPeerManager *NONNULL_PTR this_arg);
24065 export function PeerManager_disconnect_all_peers(this_arg: number): void {
24066 if(!isWasmInitialized) {
24067 throw new Error("initializeWasm() must be awaited first!");
24069 const nativeResponseValue = wasm.TS_PeerManager_disconnect_all_peers(this_arg);
24070 // debug statements here
24072 // void PeerManager_timer_tick_occurred(const struct LDKPeerManager *NONNULL_PTR this_arg);
24074 export function PeerManager_timer_tick_occurred(this_arg: number): void {
24075 if(!isWasmInitialized) {
24076 throw new Error("initializeWasm() must be awaited first!");
24078 const nativeResponseValue = wasm.TS_PeerManager_timer_tick_occurred(this_arg);
24079 // debug statements here
24081 // uint64_t htlc_success_tx_weight(bool opt_anchors);
24083 export function htlc_success_tx_weight(opt_anchors: boolean): bigint {
24084 if(!isWasmInitialized) {
24085 throw new Error("initializeWasm() must be awaited first!");
24087 const nativeResponseValue = wasm.TS_htlc_success_tx_weight(opt_anchors);
24088 return nativeResponseValue;
24090 // uint64_t htlc_timeout_tx_weight(bool opt_anchors);
24092 export function htlc_timeout_tx_weight(opt_anchors: boolean): bigint {
24093 if(!isWasmInitialized) {
24094 throw new Error("initializeWasm() must be awaited first!");
24096 const nativeResponseValue = wasm.TS_htlc_timeout_tx_weight(opt_anchors);
24097 return nativeResponseValue;
24099 // struct LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx);
24101 export function build_commitment_secret(commitment_seed: number, idx: bigint): number {
24102 if(!isWasmInitialized) {
24103 throw new Error("initializeWasm() must be awaited first!");
24105 const nativeResponseValue = wasm.TS_build_commitment_secret(commitment_seed, idx);
24106 return nativeResponseValue;
24108 // 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);
24110 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 {
24111 if(!isWasmInitialized) {
24112 throw new Error("initializeWasm() must be awaited first!");
24114 const nativeResponseValue = wasm.TS_build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
24115 return nativeResponseValue;
24117 // void CounterpartyCommitmentSecrets_free(struct LDKCounterpartyCommitmentSecrets this_obj);
24119 export function CounterpartyCommitmentSecrets_free(this_obj: number): void {
24120 if(!isWasmInitialized) {
24121 throw new Error("initializeWasm() must be awaited first!");
24123 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_free(this_obj);
24124 // debug statements here
24126 // uintptr_t CounterpartyCommitmentSecrets_clone_ptr(LDKCounterpartyCommitmentSecrets *NONNULL_PTR arg);
24128 export function CounterpartyCommitmentSecrets_clone_ptr(arg: number): number {
24129 if(!isWasmInitialized) {
24130 throw new Error("initializeWasm() must be awaited first!");
24132 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone_ptr(arg);
24133 return nativeResponseValue;
24135 // struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_clone(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR orig);
24137 export function CounterpartyCommitmentSecrets_clone(orig: number): number {
24138 if(!isWasmInitialized) {
24139 throw new Error("initializeWasm() must be awaited first!");
24141 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone(orig);
24142 return nativeResponseValue;
24144 // MUST_USE_RES struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_new(void);
24146 export function CounterpartyCommitmentSecrets_new(): number {
24147 if(!isWasmInitialized) {
24148 throw new Error("initializeWasm() must be awaited first!");
24150 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_new();
24151 return nativeResponseValue;
24153 // MUST_USE_RES uint64_t CounterpartyCommitmentSecrets_get_min_seen_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg);
24155 export function CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg: number): bigint {
24156 if(!isWasmInitialized) {
24157 throw new Error("initializeWasm() must be awaited first!");
24159 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg);
24160 return nativeResponseValue;
24162 // MUST_USE_RES struct LDKCResult_NoneNoneZ CounterpartyCommitmentSecrets_provide_secret(struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx, struct LDKThirtyTwoBytes secret);
24164 export function CounterpartyCommitmentSecrets_provide_secret(this_arg: number, idx: bigint, secret: number): number {
24165 if(!isWasmInitialized) {
24166 throw new Error("initializeWasm() must be awaited first!");
24168 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_provide_secret(this_arg, idx, secret);
24169 return nativeResponseValue;
24171 // MUST_USE_RES struct LDKThirtyTwoBytes CounterpartyCommitmentSecrets_get_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx);
24173 export function CounterpartyCommitmentSecrets_get_secret(this_arg: number, idx: bigint): number {
24174 if(!isWasmInitialized) {
24175 throw new Error("initializeWasm() must be awaited first!");
24177 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_secret(this_arg, idx);
24178 return nativeResponseValue;
24180 // struct LDKCVec_u8Z CounterpartyCommitmentSecrets_write(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR obj);
24182 export function CounterpartyCommitmentSecrets_write(obj: number): number {
24183 if(!isWasmInitialized) {
24184 throw new Error("initializeWasm() must be awaited first!");
24186 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_write(obj);
24187 return nativeResponseValue;
24189 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CounterpartyCommitmentSecrets_read(struct LDKu8slice ser);
24191 export function CounterpartyCommitmentSecrets_read(ser: number): number {
24192 if(!isWasmInitialized) {
24193 throw new Error("initializeWasm() must be awaited first!");
24195 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_read(ser);
24196 return nativeResponseValue;
24198 // struct LDKCResult_SecretKeyErrorZ derive_private_key(struct LDKPublicKey per_commitment_point, const uint8_t (*base_secret)[32]);
24200 export function derive_private_key(per_commitment_point: number, base_secret: number): number {
24201 if(!isWasmInitialized) {
24202 throw new Error("initializeWasm() must be awaited first!");
24204 const nativeResponseValue = wasm.TS_derive_private_key(per_commitment_point, base_secret);
24205 return nativeResponseValue;
24207 // struct LDKCResult_PublicKeyErrorZ derive_public_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey base_point);
24209 export function derive_public_key(per_commitment_point: number, base_point: number): number {
24210 if(!isWasmInitialized) {
24211 throw new Error("initializeWasm() must be awaited first!");
24213 const nativeResponseValue = wasm.TS_derive_public_key(per_commitment_point, base_point);
24214 return nativeResponseValue;
24216 // struct LDKCResult_SecretKeyErrorZ derive_private_revocation_key(const uint8_t (*per_commitment_secret)[32], const uint8_t (*countersignatory_revocation_base_secret)[32]);
24218 export function derive_private_revocation_key(per_commitment_secret: number, countersignatory_revocation_base_secret: number): number {
24219 if(!isWasmInitialized) {
24220 throw new Error("initializeWasm() must be awaited first!");
24222 const nativeResponseValue = wasm.TS_derive_private_revocation_key(per_commitment_secret, countersignatory_revocation_base_secret);
24223 return nativeResponseValue;
24225 // struct LDKCResult_PublicKeyErrorZ derive_public_revocation_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey countersignatory_revocation_base_point);
24227 export function derive_public_revocation_key(per_commitment_point: number, countersignatory_revocation_base_point: number): number {
24228 if(!isWasmInitialized) {
24229 throw new Error("initializeWasm() must be awaited first!");
24231 const nativeResponseValue = wasm.TS_derive_public_revocation_key(per_commitment_point, countersignatory_revocation_base_point);
24232 return nativeResponseValue;
24234 // void TxCreationKeys_free(struct LDKTxCreationKeys this_obj);
24236 export function TxCreationKeys_free(this_obj: number): void {
24237 if(!isWasmInitialized) {
24238 throw new Error("initializeWasm() must be awaited first!");
24240 const nativeResponseValue = wasm.TS_TxCreationKeys_free(this_obj);
24241 // debug statements here
24243 // struct LDKPublicKey TxCreationKeys_get_per_commitment_point(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
24245 export function TxCreationKeys_get_per_commitment_point(this_ptr: number): number {
24246 if(!isWasmInitialized) {
24247 throw new Error("initializeWasm() must be awaited first!");
24249 const nativeResponseValue = wasm.TS_TxCreationKeys_get_per_commitment_point(this_ptr);
24250 return nativeResponseValue;
24252 // void TxCreationKeys_set_per_commitment_point(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24254 export function TxCreationKeys_set_per_commitment_point(this_ptr: number, val: number): void {
24255 if(!isWasmInitialized) {
24256 throw new Error("initializeWasm() must be awaited first!");
24258 const nativeResponseValue = wasm.TS_TxCreationKeys_set_per_commitment_point(this_ptr, val);
24259 // debug statements here
24261 // struct LDKPublicKey TxCreationKeys_get_revocation_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
24263 export function TxCreationKeys_get_revocation_key(this_ptr: number): number {
24264 if(!isWasmInitialized) {
24265 throw new Error("initializeWasm() must be awaited first!");
24267 const nativeResponseValue = wasm.TS_TxCreationKeys_get_revocation_key(this_ptr);
24268 return nativeResponseValue;
24270 // void TxCreationKeys_set_revocation_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24272 export function TxCreationKeys_set_revocation_key(this_ptr: number, val: number): void {
24273 if(!isWasmInitialized) {
24274 throw new Error("initializeWasm() must be awaited first!");
24276 const nativeResponseValue = wasm.TS_TxCreationKeys_set_revocation_key(this_ptr, val);
24277 // debug statements here
24279 // struct LDKPublicKey TxCreationKeys_get_broadcaster_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
24281 export function TxCreationKeys_get_broadcaster_htlc_key(this_ptr: number): number {
24282 if(!isWasmInitialized) {
24283 throw new Error("initializeWasm() must be awaited first!");
24285 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_htlc_key(this_ptr);
24286 return nativeResponseValue;
24288 // void TxCreationKeys_set_broadcaster_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24290 export function TxCreationKeys_set_broadcaster_htlc_key(this_ptr: number, val: number): void {
24291 if(!isWasmInitialized) {
24292 throw new Error("initializeWasm() must be awaited first!");
24294 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_htlc_key(this_ptr, val);
24295 // debug statements here
24297 // struct LDKPublicKey TxCreationKeys_get_countersignatory_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
24299 export function TxCreationKeys_get_countersignatory_htlc_key(this_ptr: number): number {
24300 if(!isWasmInitialized) {
24301 throw new Error("initializeWasm() must be awaited first!");
24303 const nativeResponseValue = wasm.TS_TxCreationKeys_get_countersignatory_htlc_key(this_ptr);
24304 return nativeResponseValue;
24306 // void TxCreationKeys_set_countersignatory_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24308 export function TxCreationKeys_set_countersignatory_htlc_key(this_ptr: number, val: number): void {
24309 if(!isWasmInitialized) {
24310 throw new Error("initializeWasm() must be awaited first!");
24312 const nativeResponseValue = wasm.TS_TxCreationKeys_set_countersignatory_htlc_key(this_ptr, val);
24313 // debug statements here
24315 // struct LDKPublicKey TxCreationKeys_get_broadcaster_delayed_payment_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
24317 export function TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr: number): number {
24318 if(!isWasmInitialized) {
24319 throw new Error("initializeWasm() must be awaited first!");
24321 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr);
24322 return nativeResponseValue;
24324 // void TxCreationKeys_set_broadcaster_delayed_payment_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24326 export function TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr: number, val: number): void {
24327 if(!isWasmInitialized) {
24328 throw new Error("initializeWasm() must be awaited first!");
24330 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr, val);
24331 // debug statements here
24333 // 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);
24335 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 {
24336 if(!isWasmInitialized) {
24337 throw new Error("initializeWasm() must be awaited first!");
24339 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);
24340 return nativeResponseValue;
24342 // uintptr_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg);
24344 export function TxCreationKeys_clone_ptr(arg: number): number {
24345 if(!isWasmInitialized) {
24346 throw new Error("initializeWasm() must be awaited first!");
24348 const nativeResponseValue = wasm.TS_TxCreationKeys_clone_ptr(arg);
24349 return nativeResponseValue;
24351 // struct LDKTxCreationKeys TxCreationKeys_clone(const struct LDKTxCreationKeys *NONNULL_PTR orig);
24353 export function TxCreationKeys_clone(orig: number): number {
24354 if(!isWasmInitialized) {
24355 throw new Error("initializeWasm() must be awaited first!");
24357 const nativeResponseValue = wasm.TS_TxCreationKeys_clone(orig);
24358 return nativeResponseValue;
24360 // struct LDKCVec_u8Z TxCreationKeys_write(const struct LDKTxCreationKeys *NONNULL_PTR obj);
24362 export function TxCreationKeys_write(obj: number): number {
24363 if(!isWasmInitialized) {
24364 throw new Error("initializeWasm() must be awaited first!");
24366 const nativeResponseValue = wasm.TS_TxCreationKeys_write(obj);
24367 return nativeResponseValue;
24369 // struct LDKCResult_TxCreationKeysDecodeErrorZ TxCreationKeys_read(struct LDKu8slice ser);
24371 export function TxCreationKeys_read(ser: number): number {
24372 if(!isWasmInitialized) {
24373 throw new Error("initializeWasm() must be awaited first!");
24375 const nativeResponseValue = wasm.TS_TxCreationKeys_read(ser);
24376 return nativeResponseValue;
24378 // void ChannelPublicKeys_free(struct LDKChannelPublicKeys this_obj);
24380 export function ChannelPublicKeys_free(this_obj: number): void {
24381 if(!isWasmInitialized) {
24382 throw new Error("initializeWasm() must be awaited first!");
24384 const nativeResponseValue = wasm.TS_ChannelPublicKeys_free(this_obj);
24385 // debug statements here
24387 // struct LDKPublicKey ChannelPublicKeys_get_funding_pubkey(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
24389 export function ChannelPublicKeys_get_funding_pubkey(this_ptr: number): number {
24390 if(!isWasmInitialized) {
24391 throw new Error("initializeWasm() must be awaited first!");
24393 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_funding_pubkey(this_ptr);
24394 return nativeResponseValue;
24396 // void ChannelPublicKeys_set_funding_pubkey(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24398 export function ChannelPublicKeys_set_funding_pubkey(this_ptr: number, val: number): void {
24399 if(!isWasmInitialized) {
24400 throw new Error("initializeWasm() must be awaited first!");
24402 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_funding_pubkey(this_ptr, val);
24403 // debug statements here
24405 // struct LDKPublicKey ChannelPublicKeys_get_revocation_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
24407 export function ChannelPublicKeys_get_revocation_basepoint(this_ptr: number): number {
24408 if(!isWasmInitialized) {
24409 throw new Error("initializeWasm() must be awaited first!");
24411 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_revocation_basepoint(this_ptr);
24412 return nativeResponseValue;
24414 // void ChannelPublicKeys_set_revocation_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24416 export function ChannelPublicKeys_set_revocation_basepoint(this_ptr: number, val: number): void {
24417 if(!isWasmInitialized) {
24418 throw new Error("initializeWasm() must be awaited first!");
24420 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_revocation_basepoint(this_ptr, val);
24421 // debug statements here
24423 // struct LDKPublicKey ChannelPublicKeys_get_payment_point(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
24425 export function ChannelPublicKeys_get_payment_point(this_ptr: number): number {
24426 if(!isWasmInitialized) {
24427 throw new Error("initializeWasm() must be awaited first!");
24429 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_payment_point(this_ptr);
24430 return nativeResponseValue;
24432 // void ChannelPublicKeys_set_payment_point(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24434 export function ChannelPublicKeys_set_payment_point(this_ptr: number, val: number): void {
24435 if(!isWasmInitialized) {
24436 throw new Error("initializeWasm() must be awaited first!");
24438 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_payment_point(this_ptr, val);
24439 // debug statements here
24441 // struct LDKPublicKey ChannelPublicKeys_get_delayed_payment_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
24443 export function ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr: number): number {
24444 if(!isWasmInitialized) {
24445 throw new Error("initializeWasm() must be awaited first!");
24447 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr);
24448 return nativeResponseValue;
24450 // void ChannelPublicKeys_set_delayed_payment_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24452 export function ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
24453 if(!isWasmInitialized) {
24454 throw new Error("initializeWasm() must be awaited first!");
24456 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr, val);
24457 // debug statements here
24459 // struct LDKPublicKey ChannelPublicKeys_get_htlc_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
24461 export function ChannelPublicKeys_get_htlc_basepoint(this_ptr: number): number {
24462 if(!isWasmInitialized) {
24463 throw new Error("initializeWasm() must be awaited first!");
24465 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_htlc_basepoint(this_ptr);
24466 return nativeResponseValue;
24468 // void ChannelPublicKeys_set_htlc_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24470 export function ChannelPublicKeys_set_htlc_basepoint(this_ptr: number, val: number): void {
24471 if(!isWasmInitialized) {
24472 throw new Error("initializeWasm() must be awaited first!");
24474 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_htlc_basepoint(this_ptr, val);
24475 // debug statements here
24477 // 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);
24479 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 {
24480 if(!isWasmInitialized) {
24481 throw new Error("initializeWasm() must be awaited first!");
24483 const nativeResponseValue = wasm.TS_ChannelPublicKeys_new(funding_pubkey_arg, revocation_basepoint_arg, payment_point_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg);
24484 return nativeResponseValue;
24486 // uintptr_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg);
24488 export function ChannelPublicKeys_clone_ptr(arg: number): number {
24489 if(!isWasmInitialized) {
24490 throw new Error("initializeWasm() must be awaited first!");
24492 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone_ptr(arg);
24493 return nativeResponseValue;
24495 // struct LDKChannelPublicKeys ChannelPublicKeys_clone(const struct LDKChannelPublicKeys *NONNULL_PTR orig);
24497 export function ChannelPublicKeys_clone(orig: number): number {
24498 if(!isWasmInitialized) {
24499 throw new Error("initializeWasm() must be awaited first!");
24501 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone(orig);
24502 return nativeResponseValue;
24504 // struct LDKCVec_u8Z ChannelPublicKeys_write(const struct LDKChannelPublicKeys *NONNULL_PTR obj);
24506 export function ChannelPublicKeys_write(obj: number): number {
24507 if(!isWasmInitialized) {
24508 throw new Error("initializeWasm() must be awaited first!");
24510 const nativeResponseValue = wasm.TS_ChannelPublicKeys_write(obj);
24511 return nativeResponseValue;
24513 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ ChannelPublicKeys_read(struct LDKu8slice ser);
24515 export function ChannelPublicKeys_read(ser: number): number {
24516 if(!isWasmInitialized) {
24517 throw new Error("initializeWasm() must be awaited first!");
24519 const nativeResponseValue = wasm.TS_ChannelPublicKeys_read(ser);
24520 return nativeResponseValue;
24522 // 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);
24524 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 {
24525 if(!isWasmInitialized) {
24526 throw new Error("initializeWasm() must be awaited first!");
24528 const nativeResponseValue = wasm.TS_TxCreationKeys_derive_new(per_commitment_point, broadcaster_delayed_payment_base, broadcaster_htlc_base, countersignatory_revocation_base, countersignatory_htlc_base);
24529 return nativeResponseValue;
24531 // 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);
24533 export function TxCreationKeys_from_channel_static_keys(per_commitment_point: number, broadcaster_keys: number, countersignatory_keys: number): number {
24534 if(!isWasmInitialized) {
24535 throw new Error("initializeWasm() must be awaited first!");
24537 const nativeResponseValue = wasm.TS_TxCreationKeys_from_channel_static_keys(per_commitment_point, broadcaster_keys, countersignatory_keys);
24538 return nativeResponseValue;
24540 // struct LDKCVec_u8Z get_revokeable_redeemscript(struct LDKPublicKey revocation_key, uint16_t contest_delay, struct LDKPublicKey broadcaster_delayed_payment_key);
24542 export function get_revokeable_redeemscript(revocation_key: number, contest_delay: number, broadcaster_delayed_payment_key: number): number {
24543 if(!isWasmInitialized) {
24544 throw new Error("initializeWasm() must be awaited first!");
24546 const nativeResponseValue = wasm.TS_get_revokeable_redeemscript(revocation_key, contest_delay, broadcaster_delayed_payment_key);
24547 return nativeResponseValue;
24549 // void HTLCOutputInCommitment_free(struct LDKHTLCOutputInCommitment this_obj);
24551 export function HTLCOutputInCommitment_free(this_obj: number): void {
24552 if(!isWasmInitialized) {
24553 throw new Error("initializeWasm() must be awaited first!");
24555 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_free(this_obj);
24556 // debug statements here
24558 // bool HTLCOutputInCommitment_get_offered(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
24560 export function HTLCOutputInCommitment_get_offered(this_ptr: number): boolean {
24561 if(!isWasmInitialized) {
24562 throw new Error("initializeWasm() must be awaited first!");
24564 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_offered(this_ptr);
24565 return nativeResponseValue;
24567 // void HTLCOutputInCommitment_set_offered(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, bool val);
24569 export function HTLCOutputInCommitment_set_offered(this_ptr: number, val: boolean): void {
24570 if(!isWasmInitialized) {
24571 throw new Error("initializeWasm() must be awaited first!");
24573 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_offered(this_ptr, val);
24574 // debug statements here
24576 // uint64_t HTLCOutputInCommitment_get_amount_msat(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
24578 export function HTLCOutputInCommitment_get_amount_msat(this_ptr: number): bigint {
24579 if(!isWasmInitialized) {
24580 throw new Error("initializeWasm() must be awaited first!");
24582 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_amount_msat(this_ptr);
24583 return nativeResponseValue;
24585 // void HTLCOutputInCommitment_set_amount_msat(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint64_t val);
24587 export function HTLCOutputInCommitment_set_amount_msat(this_ptr: number, val: bigint): void {
24588 if(!isWasmInitialized) {
24589 throw new Error("initializeWasm() must be awaited first!");
24591 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_amount_msat(this_ptr, val);
24592 // debug statements here
24594 // uint32_t HTLCOutputInCommitment_get_cltv_expiry(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
24596 export function HTLCOutputInCommitment_get_cltv_expiry(this_ptr: number): number {
24597 if(!isWasmInitialized) {
24598 throw new Error("initializeWasm() must be awaited first!");
24600 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_cltv_expiry(this_ptr);
24601 return nativeResponseValue;
24603 // void HTLCOutputInCommitment_set_cltv_expiry(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint32_t val);
24605 export function HTLCOutputInCommitment_set_cltv_expiry(this_ptr: number, val: number): void {
24606 if(!isWasmInitialized) {
24607 throw new Error("initializeWasm() must be awaited first!");
24609 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_cltv_expiry(this_ptr, val);
24610 // debug statements here
24612 // const uint8_t (*HTLCOutputInCommitment_get_payment_hash(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr))[32];
24614 export function HTLCOutputInCommitment_get_payment_hash(this_ptr: number): number {
24615 if(!isWasmInitialized) {
24616 throw new Error("initializeWasm() must be awaited first!");
24618 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_payment_hash(this_ptr);
24619 return nativeResponseValue;
24621 // void HTLCOutputInCommitment_set_payment_hash(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24623 export function HTLCOutputInCommitment_set_payment_hash(this_ptr: number, val: number): void {
24624 if(!isWasmInitialized) {
24625 throw new Error("initializeWasm() must be awaited first!");
24627 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_payment_hash(this_ptr, val);
24628 // debug statements here
24630 // struct LDKCOption_u32Z HTLCOutputInCommitment_get_transaction_output_index(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
24632 export function HTLCOutputInCommitment_get_transaction_output_index(this_ptr: number): number {
24633 if(!isWasmInitialized) {
24634 throw new Error("initializeWasm() must be awaited first!");
24636 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_transaction_output_index(this_ptr);
24637 return nativeResponseValue;
24639 // void HTLCOutputInCommitment_set_transaction_output_index(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
24641 export function HTLCOutputInCommitment_set_transaction_output_index(this_ptr: number, val: number): void {
24642 if(!isWasmInitialized) {
24643 throw new Error("initializeWasm() must be awaited first!");
24645 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_transaction_output_index(this_ptr, val);
24646 // debug statements here
24648 // 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);
24650 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 {
24651 if(!isWasmInitialized) {
24652 throw new Error("initializeWasm() must be awaited first!");
24654 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg, transaction_output_index_arg);
24655 return nativeResponseValue;
24657 // uintptr_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg);
24659 export function HTLCOutputInCommitment_clone_ptr(arg: number): number {
24660 if(!isWasmInitialized) {
24661 throw new Error("initializeWasm() must be awaited first!");
24663 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone_ptr(arg);
24664 return nativeResponseValue;
24666 // struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_clone(const struct LDKHTLCOutputInCommitment *NONNULL_PTR orig);
24668 export function HTLCOutputInCommitment_clone(orig: number): number {
24669 if(!isWasmInitialized) {
24670 throw new Error("initializeWasm() must be awaited first!");
24672 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone(orig);
24673 return nativeResponseValue;
24675 // struct LDKCVec_u8Z HTLCOutputInCommitment_write(const struct LDKHTLCOutputInCommitment *NONNULL_PTR obj);
24677 export function HTLCOutputInCommitment_write(obj: number): number {
24678 if(!isWasmInitialized) {
24679 throw new Error("initializeWasm() must be awaited first!");
24681 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_write(obj);
24682 return nativeResponseValue;
24684 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ HTLCOutputInCommitment_read(struct LDKu8slice ser);
24686 export function HTLCOutputInCommitment_read(ser: number): number {
24687 if(!isWasmInitialized) {
24688 throw new Error("initializeWasm() must be awaited first!");
24690 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_read(ser);
24691 return nativeResponseValue;
24693 // struct LDKCVec_u8Z get_htlc_redeemscript(const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc, bool opt_anchors, const struct LDKTxCreationKeys *NONNULL_PTR keys);
24695 export function get_htlc_redeemscript(htlc: number, opt_anchors: boolean, keys: number): number {
24696 if(!isWasmInitialized) {
24697 throw new Error("initializeWasm() must be awaited first!");
24699 const nativeResponseValue = wasm.TS_get_htlc_redeemscript(htlc, opt_anchors, keys);
24700 return nativeResponseValue;
24702 // struct LDKCVec_u8Z make_funding_redeemscript(struct LDKPublicKey broadcaster, struct LDKPublicKey countersignatory);
24704 export function make_funding_redeemscript(broadcaster: number, countersignatory: number): number {
24705 if(!isWasmInitialized) {
24706 throw new Error("initializeWasm() must be awaited first!");
24708 const nativeResponseValue = wasm.TS_make_funding_redeemscript(broadcaster, countersignatory);
24709 return nativeResponseValue;
24711 // 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);
24713 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 {
24714 if(!isWasmInitialized) {
24715 throw new Error("initializeWasm() must be awaited first!");
24717 const nativeResponseValue = wasm.TS_build_htlc_transaction(commitment_txid, feerate_per_kw, contest_delay, htlc, opt_anchors, broadcaster_delayed_payment_key, revocation_key);
24718 return nativeResponseValue;
24720 // struct LDKCVec_u8Z get_anchor_redeemscript(struct LDKPublicKey funding_pubkey);
24722 export function get_anchor_redeemscript(funding_pubkey: number): number {
24723 if(!isWasmInitialized) {
24724 throw new Error("initializeWasm() must be awaited first!");
24726 const nativeResponseValue = wasm.TS_get_anchor_redeemscript(funding_pubkey);
24727 return nativeResponseValue;
24729 // void ChannelTransactionParameters_free(struct LDKChannelTransactionParameters this_obj);
24731 export function ChannelTransactionParameters_free(this_obj: number): void {
24732 if(!isWasmInitialized) {
24733 throw new Error("initializeWasm() must be awaited first!");
24735 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_free(this_obj);
24736 // debug statements here
24738 // struct LDKChannelPublicKeys ChannelTransactionParameters_get_holder_pubkeys(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
24740 export function ChannelTransactionParameters_get_holder_pubkeys(this_ptr: number): number {
24741 if(!isWasmInitialized) {
24742 throw new Error("initializeWasm() must be awaited first!");
24744 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_pubkeys(this_ptr);
24745 return nativeResponseValue;
24747 // void ChannelTransactionParameters_set_holder_pubkeys(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
24749 export function ChannelTransactionParameters_set_holder_pubkeys(this_ptr: number, val: number): void {
24750 if(!isWasmInitialized) {
24751 throw new Error("initializeWasm() must be awaited first!");
24753 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_pubkeys(this_ptr, val);
24754 // debug statements here
24756 // uint16_t ChannelTransactionParameters_get_holder_selected_contest_delay(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
24758 export function ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr: number): number {
24759 if(!isWasmInitialized) {
24760 throw new Error("initializeWasm() must be awaited first!");
24762 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr);
24763 return nativeResponseValue;
24765 // void ChannelTransactionParameters_set_holder_selected_contest_delay(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
24767 export function ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr: number, val: number): void {
24768 if(!isWasmInitialized) {
24769 throw new Error("initializeWasm() must be awaited first!");
24771 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr, val);
24772 // debug statements here
24774 // bool ChannelTransactionParameters_get_is_outbound_from_holder(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
24776 export function ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr: number): boolean {
24777 if(!isWasmInitialized) {
24778 throw new Error("initializeWasm() must be awaited first!");
24780 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr);
24781 return nativeResponseValue;
24783 // void ChannelTransactionParameters_set_is_outbound_from_holder(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, bool val);
24785 export function ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr: number, val: boolean): void {
24786 if(!isWasmInitialized) {
24787 throw new Error("initializeWasm() must be awaited first!");
24789 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr, val);
24790 // debug statements here
24792 // struct LDKCounterpartyChannelTransactionParameters ChannelTransactionParameters_get_counterparty_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
24794 export function ChannelTransactionParameters_get_counterparty_parameters(this_ptr: number): number {
24795 if(!isWasmInitialized) {
24796 throw new Error("initializeWasm() must be awaited first!");
24798 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_counterparty_parameters(this_ptr);
24799 return nativeResponseValue;
24801 // void ChannelTransactionParameters_set_counterparty_parameters(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKCounterpartyChannelTransactionParameters val);
24803 export function ChannelTransactionParameters_set_counterparty_parameters(this_ptr: number, val: number): void {
24804 if(!isWasmInitialized) {
24805 throw new Error("initializeWasm() must be awaited first!");
24807 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_counterparty_parameters(this_ptr, val);
24808 // debug statements here
24810 // struct LDKOutPoint ChannelTransactionParameters_get_funding_outpoint(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
24812 export function ChannelTransactionParameters_get_funding_outpoint(this_ptr: number): number {
24813 if(!isWasmInitialized) {
24814 throw new Error("initializeWasm() must be awaited first!");
24816 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_funding_outpoint(this_ptr);
24817 return nativeResponseValue;
24819 // void ChannelTransactionParameters_set_funding_outpoint(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKOutPoint val);
24821 export function ChannelTransactionParameters_set_funding_outpoint(this_ptr: number, val: number): void {
24822 if(!isWasmInitialized) {
24823 throw new Error("initializeWasm() must be awaited first!");
24825 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_funding_outpoint(this_ptr, val);
24826 // debug statements here
24828 // enum LDKCOption_NoneZ ChannelTransactionParameters_get_opt_anchors(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
24830 export function ChannelTransactionParameters_get_opt_anchors(this_ptr: number): COption_NoneZ {
24831 if(!isWasmInitialized) {
24832 throw new Error("initializeWasm() must be awaited first!");
24834 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_opt_anchors(this_ptr);
24835 return nativeResponseValue;
24837 // void ChannelTransactionParameters_set_opt_anchors(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
24839 export function ChannelTransactionParameters_set_opt_anchors(this_ptr: number, val: COption_NoneZ): void {
24840 if(!isWasmInitialized) {
24841 throw new Error("initializeWasm() must be awaited first!");
24843 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_opt_anchors(this_ptr, val);
24844 // debug statements here
24846 // 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);
24848 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 {
24849 if(!isWasmInitialized) {
24850 throw new Error("initializeWasm() must be awaited first!");
24852 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);
24853 return nativeResponseValue;
24855 // uintptr_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg);
24857 export function ChannelTransactionParameters_clone_ptr(arg: number): number {
24858 if(!isWasmInitialized) {
24859 throw new Error("initializeWasm() must be awaited first!");
24861 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone_ptr(arg);
24862 return nativeResponseValue;
24864 // struct LDKChannelTransactionParameters ChannelTransactionParameters_clone(const struct LDKChannelTransactionParameters *NONNULL_PTR orig);
24866 export function ChannelTransactionParameters_clone(orig: number): number {
24867 if(!isWasmInitialized) {
24868 throw new Error("initializeWasm() must be awaited first!");
24870 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone(orig);
24871 return nativeResponseValue;
24873 // void CounterpartyChannelTransactionParameters_free(struct LDKCounterpartyChannelTransactionParameters this_obj);
24875 export function CounterpartyChannelTransactionParameters_free(this_obj: number): void {
24876 if(!isWasmInitialized) {
24877 throw new Error("initializeWasm() must be awaited first!");
24879 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_free(this_obj);
24880 // debug statements here
24882 // struct LDKChannelPublicKeys CounterpartyChannelTransactionParameters_get_pubkeys(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
24884 export function CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr: number): number {
24885 if(!isWasmInitialized) {
24886 throw new Error("initializeWasm() must be awaited first!");
24888 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr);
24889 return nativeResponseValue;
24891 // void CounterpartyChannelTransactionParameters_set_pubkeys(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
24893 export function CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr: number, val: number): void {
24894 if(!isWasmInitialized) {
24895 throw new Error("initializeWasm() must be awaited first!");
24897 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr, val);
24898 // debug statements here
24900 // uint16_t CounterpartyChannelTransactionParameters_get_selected_contest_delay(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
24902 export function CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr: number): number {
24903 if(!isWasmInitialized) {
24904 throw new Error("initializeWasm() must be awaited first!");
24906 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr);
24907 return nativeResponseValue;
24909 // void CounterpartyChannelTransactionParameters_set_selected_contest_delay(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
24911 export function CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr: number, val: number): void {
24912 if(!isWasmInitialized) {
24913 throw new Error("initializeWasm() must be awaited first!");
24915 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr, val);
24916 // debug statements here
24918 // MUST_USE_RES struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_new(struct LDKChannelPublicKeys pubkeys_arg, uint16_t selected_contest_delay_arg);
24920 export function CounterpartyChannelTransactionParameters_new(pubkeys_arg: number, selected_contest_delay_arg: number): number {
24921 if(!isWasmInitialized) {
24922 throw new Error("initializeWasm() must be awaited first!");
24924 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_new(pubkeys_arg, selected_contest_delay_arg);
24925 return nativeResponseValue;
24927 // uintptr_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg);
24929 export function CounterpartyChannelTransactionParameters_clone_ptr(arg: number): number {
24930 if(!isWasmInitialized) {
24931 throw new Error("initializeWasm() must be awaited first!");
24933 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone_ptr(arg);
24934 return nativeResponseValue;
24936 // struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_clone(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR orig);
24938 export function CounterpartyChannelTransactionParameters_clone(orig: number): number {
24939 if(!isWasmInitialized) {
24940 throw new Error("initializeWasm() must be awaited first!");
24942 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone(orig);
24943 return nativeResponseValue;
24945 // MUST_USE_RES bool ChannelTransactionParameters_is_populated(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
24947 export function ChannelTransactionParameters_is_populated(this_arg: number): boolean {
24948 if(!isWasmInitialized) {
24949 throw new Error("initializeWasm() must be awaited first!");
24951 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_is_populated(this_arg);
24952 return nativeResponseValue;
24954 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_holder_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
24956 export function ChannelTransactionParameters_as_holder_broadcastable(this_arg: number): number {
24957 if(!isWasmInitialized) {
24958 throw new Error("initializeWasm() must be awaited first!");
24960 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_holder_broadcastable(this_arg);
24961 return nativeResponseValue;
24963 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_counterparty_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
24965 export function ChannelTransactionParameters_as_counterparty_broadcastable(this_arg: number): number {
24966 if(!isWasmInitialized) {
24967 throw new Error("initializeWasm() must be awaited first!");
24969 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_counterparty_broadcastable(this_arg);
24970 return nativeResponseValue;
24972 // struct LDKCVec_u8Z CounterpartyChannelTransactionParameters_write(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR obj);
24974 export function CounterpartyChannelTransactionParameters_write(obj: number): number {
24975 if(!isWasmInitialized) {
24976 throw new Error("initializeWasm() must be awaited first!");
24978 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_write(obj);
24979 return nativeResponseValue;
24981 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CounterpartyChannelTransactionParameters_read(struct LDKu8slice ser);
24983 export function CounterpartyChannelTransactionParameters_read(ser: number): number {
24984 if(!isWasmInitialized) {
24985 throw new Error("initializeWasm() must be awaited first!");
24987 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_read(ser);
24988 return nativeResponseValue;
24990 // struct LDKCVec_u8Z ChannelTransactionParameters_write(const struct LDKChannelTransactionParameters *NONNULL_PTR obj);
24992 export function ChannelTransactionParameters_write(obj: number): number {
24993 if(!isWasmInitialized) {
24994 throw new Error("initializeWasm() must be awaited first!");
24996 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_write(obj);
24997 return nativeResponseValue;
24999 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ ChannelTransactionParameters_read(struct LDKu8slice ser);
25001 export function ChannelTransactionParameters_read(ser: number): number {
25002 if(!isWasmInitialized) {
25003 throw new Error("initializeWasm() must be awaited first!");
25005 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_read(ser);
25006 return nativeResponseValue;
25008 // void DirectedChannelTransactionParameters_free(struct LDKDirectedChannelTransactionParameters this_obj);
25010 export function DirectedChannelTransactionParameters_free(this_obj: number): void {
25011 if(!isWasmInitialized) {
25012 throw new Error("initializeWasm() must be awaited first!");
25014 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_free(this_obj);
25015 // debug statements here
25017 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_broadcaster_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
25019 export function DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg: number): number {
25020 if(!isWasmInitialized) {
25021 throw new Error("initializeWasm() must be awaited first!");
25023 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg);
25024 return nativeResponseValue;
25026 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_countersignatory_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
25028 export function DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg: number): number {
25029 if(!isWasmInitialized) {
25030 throw new Error("initializeWasm() must be awaited first!");
25032 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg);
25033 return nativeResponseValue;
25035 // MUST_USE_RES uint16_t DirectedChannelTransactionParameters_contest_delay(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
25037 export function DirectedChannelTransactionParameters_contest_delay(this_arg: number): number {
25038 if(!isWasmInitialized) {
25039 throw new Error("initializeWasm() must be awaited first!");
25041 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_contest_delay(this_arg);
25042 return nativeResponseValue;
25044 // MUST_USE_RES bool DirectedChannelTransactionParameters_is_outbound(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
25046 export function DirectedChannelTransactionParameters_is_outbound(this_arg: number): boolean {
25047 if(!isWasmInitialized) {
25048 throw new Error("initializeWasm() must be awaited first!");
25050 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_is_outbound(this_arg);
25051 return nativeResponseValue;
25053 // MUST_USE_RES struct LDKOutPoint DirectedChannelTransactionParameters_funding_outpoint(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
25055 export function DirectedChannelTransactionParameters_funding_outpoint(this_arg: number): number {
25056 if(!isWasmInitialized) {
25057 throw new Error("initializeWasm() must be awaited first!");
25059 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_funding_outpoint(this_arg);
25060 return nativeResponseValue;
25062 // MUST_USE_RES bool DirectedChannelTransactionParameters_opt_anchors(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
25064 export function DirectedChannelTransactionParameters_opt_anchors(this_arg: number): boolean {
25065 if(!isWasmInitialized) {
25066 throw new Error("initializeWasm() must be awaited first!");
25068 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_opt_anchors(this_arg);
25069 return nativeResponseValue;
25071 // void HolderCommitmentTransaction_free(struct LDKHolderCommitmentTransaction this_obj);
25073 export function HolderCommitmentTransaction_free(this_obj: number): void {
25074 if(!isWasmInitialized) {
25075 throw new Error("initializeWasm() must be awaited first!");
25077 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_free(this_obj);
25078 // debug statements here
25080 // struct LDKSignature HolderCommitmentTransaction_get_counterparty_sig(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
25082 export function HolderCommitmentTransaction_get_counterparty_sig(this_ptr: number): number {
25083 if(!isWasmInitialized) {
25084 throw new Error("initializeWasm() must be awaited first!");
25086 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_sig(this_ptr);
25087 return nativeResponseValue;
25089 // void HolderCommitmentTransaction_set_counterparty_sig(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKSignature val);
25091 export function HolderCommitmentTransaction_set_counterparty_sig(this_ptr: number, val: number): void {
25092 if(!isWasmInitialized) {
25093 throw new Error("initializeWasm() must be awaited first!");
25095 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_sig(this_ptr, val);
25096 // debug statements here
25098 // void HolderCommitmentTransaction_set_counterparty_htlc_sigs(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
25100 export function HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr: number, val: number): void {
25101 if(!isWasmInitialized) {
25102 throw new Error("initializeWasm() must be awaited first!");
25104 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr, val);
25105 // debug statements here
25107 // uintptr_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg);
25109 export function HolderCommitmentTransaction_clone_ptr(arg: number): number {
25110 if(!isWasmInitialized) {
25111 throw new Error("initializeWasm() must be awaited first!");
25113 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone_ptr(arg);
25114 return nativeResponseValue;
25116 // struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_clone(const struct LDKHolderCommitmentTransaction *NONNULL_PTR orig);
25118 export function HolderCommitmentTransaction_clone(orig: number): number {
25119 if(!isWasmInitialized) {
25120 throw new Error("initializeWasm() must be awaited first!");
25122 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone(orig);
25123 return nativeResponseValue;
25125 // struct LDKCVec_u8Z HolderCommitmentTransaction_write(const struct LDKHolderCommitmentTransaction *NONNULL_PTR obj);
25127 export function HolderCommitmentTransaction_write(obj: number): number {
25128 if(!isWasmInitialized) {
25129 throw new Error("initializeWasm() must be awaited first!");
25131 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_write(obj);
25132 return nativeResponseValue;
25134 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ HolderCommitmentTransaction_read(struct LDKu8slice ser);
25136 export function HolderCommitmentTransaction_read(ser: number): number {
25137 if(!isWasmInitialized) {
25138 throw new Error("initializeWasm() must be awaited first!");
25140 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_read(ser);
25141 return nativeResponseValue;
25143 // 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);
25145 export function HolderCommitmentTransaction_new(commitment_tx: number, counterparty_sig: number, counterparty_htlc_sigs: number, holder_funding_key: number, counterparty_funding_key: number): number {
25146 if(!isWasmInitialized) {
25147 throw new Error("initializeWasm() must be awaited first!");
25149 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_new(commitment_tx, counterparty_sig, counterparty_htlc_sigs, holder_funding_key, counterparty_funding_key);
25150 return nativeResponseValue;
25152 // void BuiltCommitmentTransaction_free(struct LDKBuiltCommitmentTransaction this_obj);
25154 export function BuiltCommitmentTransaction_free(this_obj: number): void {
25155 if(!isWasmInitialized) {
25156 throw new Error("initializeWasm() must be awaited first!");
25158 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_free(this_obj);
25159 // debug statements here
25161 // struct LDKTransaction BuiltCommitmentTransaction_get_transaction(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr);
25163 export function BuiltCommitmentTransaction_get_transaction(this_ptr: number): number {
25164 if(!isWasmInitialized) {
25165 throw new Error("initializeWasm() must be awaited first!");
25167 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_transaction(this_ptr);
25168 return nativeResponseValue;
25170 // void BuiltCommitmentTransaction_set_transaction(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKTransaction val);
25172 export function BuiltCommitmentTransaction_set_transaction(this_ptr: number, val: number): void {
25173 if(!isWasmInitialized) {
25174 throw new Error("initializeWasm() must be awaited first!");
25176 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_transaction(this_ptr, val);
25177 // debug statements here
25179 // const uint8_t (*BuiltCommitmentTransaction_get_txid(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr))[32];
25181 export function BuiltCommitmentTransaction_get_txid(this_ptr: number): number {
25182 if(!isWasmInitialized) {
25183 throw new Error("initializeWasm() must be awaited first!");
25185 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_txid(this_ptr);
25186 return nativeResponseValue;
25188 // void BuiltCommitmentTransaction_set_txid(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25190 export function BuiltCommitmentTransaction_set_txid(this_ptr: number, val: number): void {
25191 if(!isWasmInitialized) {
25192 throw new Error("initializeWasm() must be awaited first!");
25194 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_txid(this_ptr, val);
25195 // debug statements here
25197 // MUST_USE_RES struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_new(struct LDKTransaction transaction_arg, struct LDKThirtyTwoBytes txid_arg);
25199 export function BuiltCommitmentTransaction_new(transaction_arg: number, txid_arg: number): number {
25200 if(!isWasmInitialized) {
25201 throw new Error("initializeWasm() must be awaited first!");
25203 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_new(transaction_arg, txid_arg);
25204 return nativeResponseValue;
25206 // uintptr_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg);
25208 export function BuiltCommitmentTransaction_clone_ptr(arg: number): number {
25209 if(!isWasmInitialized) {
25210 throw new Error("initializeWasm() must be awaited first!");
25212 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone_ptr(arg);
25213 return nativeResponseValue;
25215 // struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_clone(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR orig);
25217 export function BuiltCommitmentTransaction_clone(orig: number): number {
25218 if(!isWasmInitialized) {
25219 throw new Error("initializeWasm() must be awaited first!");
25221 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone(orig);
25222 return nativeResponseValue;
25224 // struct LDKCVec_u8Z BuiltCommitmentTransaction_write(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR obj);
25226 export function BuiltCommitmentTransaction_write(obj: number): number {
25227 if(!isWasmInitialized) {
25228 throw new Error("initializeWasm() must be awaited first!");
25230 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_write(obj);
25231 return nativeResponseValue;
25233 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ BuiltCommitmentTransaction_read(struct LDKu8slice ser);
25235 export function BuiltCommitmentTransaction_read(ser: number): number {
25236 if(!isWasmInitialized) {
25237 throw new Error("initializeWasm() must be awaited first!");
25239 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_read(ser);
25240 return nativeResponseValue;
25242 // 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);
25244 export function BuiltCommitmentTransaction_get_sighash_all(this_arg: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
25245 if(!isWasmInitialized) {
25246 throw new Error("initializeWasm() must be awaited first!");
25248 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
25249 return nativeResponseValue;
25251 // 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);
25253 export function BuiltCommitmentTransaction_sign(this_arg: number, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
25254 if(!isWasmInitialized) {
25255 throw new Error("initializeWasm() must be awaited first!");
25257 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
25258 return nativeResponseValue;
25260 // void ClosingTransaction_free(struct LDKClosingTransaction this_obj);
25262 export function ClosingTransaction_free(this_obj: number): void {
25263 if(!isWasmInitialized) {
25264 throw new Error("initializeWasm() must be awaited first!");
25266 const nativeResponseValue = wasm.TS_ClosingTransaction_free(this_obj);
25267 // debug statements here
25269 // uintptr_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg);
25271 export function ClosingTransaction_clone_ptr(arg: number): number {
25272 if(!isWasmInitialized) {
25273 throw new Error("initializeWasm() must be awaited first!");
25275 const nativeResponseValue = wasm.TS_ClosingTransaction_clone_ptr(arg);
25276 return nativeResponseValue;
25278 // struct LDKClosingTransaction ClosingTransaction_clone(const struct LDKClosingTransaction *NONNULL_PTR orig);
25280 export function ClosingTransaction_clone(orig: number): number {
25281 if(!isWasmInitialized) {
25282 throw new Error("initializeWasm() must be awaited first!");
25284 const nativeResponseValue = wasm.TS_ClosingTransaction_clone(orig);
25285 return nativeResponseValue;
25287 // uint64_t ClosingTransaction_hash(const struct LDKClosingTransaction *NONNULL_PTR o);
25289 export function ClosingTransaction_hash(o: number): bigint {
25290 if(!isWasmInitialized) {
25291 throw new Error("initializeWasm() must be awaited first!");
25293 const nativeResponseValue = wasm.TS_ClosingTransaction_hash(o);
25294 return nativeResponseValue;
25296 // 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);
25298 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 {
25299 if(!isWasmInitialized) {
25300 throw new Error("initializeWasm() must be awaited first!");
25302 const nativeResponseValue = wasm.TS_ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
25303 return nativeResponseValue;
25305 // MUST_USE_RES struct LDKTrustedClosingTransaction ClosingTransaction_trust(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
25307 export function ClosingTransaction_trust(this_arg: number): number {
25308 if(!isWasmInitialized) {
25309 throw new Error("initializeWasm() must be awaited first!");
25311 const nativeResponseValue = wasm.TS_ClosingTransaction_trust(this_arg);
25312 return nativeResponseValue;
25314 // MUST_USE_RES struct LDKCResult_TrustedClosingTransactionNoneZ ClosingTransaction_verify(const struct LDKClosingTransaction *NONNULL_PTR this_arg, struct LDKOutPoint funding_outpoint);
25316 export function ClosingTransaction_verify(this_arg: number, funding_outpoint: number): number {
25317 if(!isWasmInitialized) {
25318 throw new Error("initializeWasm() must be awaited first!");
25320 const nativeResponseValue = wasm.TS_ClosingTransaction_verify(this_arg, funding_outpoint);
25321 return nativeResponseValue;
25323 // MUST_USE_RES uint64_t ClosingTransaction_to_holder_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
25325 export function ClosingTransaction_to_holder_value_sat(this_arg: number): bigint {
25326 if(!isWasmInitialized) {
25327 throw new Error("initializeWasm() must be awaited first!");
25329 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_value_sat(this_arg);
25330 return nativeResponseValue;
25332 // MUST_USE_RES uint64_t ClosingTransaction_to_counterparty_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
25334 export function ClosingTransaction_to_counterparty_value_sat(this_arg: number): bigint {
25335 if(!isWasmInitialized) {
25336 throw new Error("initializeWasm() must be awaited first!");
25338 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_value_sat(this_arg);
25339 return nativeResponseValue;
25341 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_holder_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
25343 export function ClosingTransaction_to_holder_script(this_arg: number): number {
25344 if(!isWasmInitialized) {
25345 throw new Error("initializeWasm() must be awaited first!");
25347 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_script(this_arg);
25348 return nativeResponseValue;
25350 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_counterparty_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
25352 export function ClosingTransaction_to_counterparty_script(this_arg: number): number {
25353 if(!isWasmInitialized) {
25354 throw new Error("initializeWasm() must be awaited first!");
25356 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_script(this_arg);
25357 return nativeResponseValue;
25359 // void TrustedClosingTransaction_free(struct LDKTrustedClosingTransaction this_obj);
25361 export function TrustedClosingTransaction_free(this_obj: number): void {
25362 if(!isWasmInitialized) {
25363 throw new Error("initializeWasm() must be awaited first!");
25365 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_free(this_obj);
25366 // debug statements here
25368 // MUST_USE_RES struct LDKTransaction TrustedClosingTransaction_built_transaction(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg);
25370 export function TrustedClosingTransaction_built_transaction(this_arg: number): number {
25371 if(!isWasmInitialized) {
25372 throw new Error("initializeWasm() must be awaited first!");
25374 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_built_transaction(this_arg);
25375 return nativeResponseValue;
25377 // 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);
25379 export function TrustedClosingTransaction_get_sighash_all(this_arg: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
25380 if(!isWasmInitialized) {
25381 throw new Error("initializeWasm() must be awaited first!");
25383 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
25384 return nativeResponseValue;
25386 // 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);
25388 export function TrustedClosingTransaction_sign(this_arg: number, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
25389 if(!isWasmInitialized) {
25390 throw new Error("initializeWasm() must be awaited first!");
25392 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
25393 return nativeResponseValue;
25395 // void CommitmentTransaction_free(struct LDKCommitmentTransaction this_obj);
25397 export function CommitmentTransaction_free(this_obj: number): void {
25398 if(!isWasmInitialized) {
25399 throw new Error("initializeWasm() must be awaited first!");
25401 const nativeResponseValue = wasm.TS_CommitmentTransaction_free(this_obj);
25402 // debug statements here
25404 // uintptr_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg);
25406 export function CommitmentTransaction_clone_ptr(arg: number): number {
25407 if(!isWasmInitialized) {
25408 throw new Error("initializeWasm() must be awaited first!");
25410 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone_ptr(arg);
25411 return nativeResponseValue;
25413 // struct LDKCommitmentTransaction CommitmentTransaction_clone(const struct LDKCommitmentTransaction *NONNULL_PTR orig);
25415 export function CommitmentTransaction_clone(orig: number): number {
25416 if(!isWasmInitialized) {
25417 throw new Error("initializeWasm() must be awaited first!");
25419 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone(orig);
25420 return nativeResponseValue;
25422 // struct LDKCVec_u8Z CommitmentTransaction_write(const struct LDKCommitmentTransaction *NONNULL_PTR obj);
25424 export function CommitmentTransaction_write(obj: number): number {
25425 if(!isWasmInitialized) {
25426 throw new Error("initializeWasm() must be awaited first!");
25428 const nativeResponseValue = wasm.TS_CommitmentTransaction_write(obj);
25429 return nativeResponseValue;
25431 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CommitmentTransaction_read(struct LDKu8slice ser);
25433 export function CommitmentTransaction_read(ser: number): number {
25434 if(!isWasmInitialized) {
25435 throw new Error("initializeWasm() must be awaited first!");
25437 const nativeResponseValue = wasm.TS_CommitmentTransaction_read(ser);
25438 return nativeResponseValue;
25440 // MUST_USE_RES uint64_t CommitmentTransaction_commitment_number(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
25442 export function CommitmentTransaction_commitment_number(this_arg: number): bigint {
25443 if(!isWasmInitialized) {
25444 throw new Error("initializeWasm() must be awaited first!");
25446 const nativeResponseValue = wasm.TS_CommitmentTransaction_commitment_number(this_arg);
25447 return nativeResponseValue;
25449 // MUST_USE_RES uint64_t CommitmentTransaction_to_broadcaster_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
25451 export function CommitmentTransaction_to_broadcaster_value_sat(this_arg: number): bigint {
25452 if(!isWasmInitialized) {
25453 throw new Error("initializeWasm() must be awaited first!");
25455 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_broadcaster_value_sat(this_arg);
25456 return nativeResponseValue;
25458 // MUST_USE_RES uint64_t CommitmentTransaction_to_countersignatory_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
25460 export function CommitmentTransaction_to_countersignatory_value_sat(this_arg: number): bigint {
25461 if(!isWasmInitialized) {
25462 throw new Error("initializeWasm() must be awaited first!");
25464 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_countersignatory_value_sat(this_arg);
25465 return nativeResponseValue;
25467 // MUST_USE_RES uint32_t CommitmentTransaction_feerate_per_kw(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
25469 export function CommitmentTransaction_feerate_per_kw(this_arg: number): number {
25470 if(!isWasmInitialized) {
25471 throw new Error("initializeWasm() must be awaited first!");
25473 const nativeResponseValue = wasm.TS_CommitmentTransaction_feerate_per_kw(this_arg);
25474 return nativeResponseValue;
25476 // MUST_USE_RES struct LDKTrustedCommitmentTransaction CommitmentTransaction_trust(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
25478 export function CommitmentTransaction_trust(this_arg: number): number {
25479 if(!isWasmInitialized) {
25480 throw new Error("initializeWasm() must be awaited first!");
25482 const nativeResponseValue = wasm.TS_CommitmentTransaction_trust(this_arg);
25483 return nativeResponseValue;
25485 // 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);
25487 export function CommitmentTransaction_verify(this_arg: number, channel_parameters: number, broadcaster_keys: number, countersignatory_keys: number): number {
25488 if(!isWasmInitialized) {
25489 throw new Error("initializeWasm() must be awaited first!");
25491 const nativeResponseValue = wasm.TS_CommitmentTransaction_verify(this_arg, channel_parameters, broadcaster_keys, countersignatory_keys);
25492 return nativeResponseValue;
25494 // void TrustedCommitmentTransaction_free(struct LDKTrustedCommitmentTransaction this_obj);
25496 export function TrustedCommitmentTransaction_free(this_obj: number): void {
25497 if(!isWasmInitialized) {
25498 throw new Error("initializeWasm() must be awaited first!");
25500 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_free(this_obj);
25501 // debug statements here
25503 // MUST_USE_RES struct LDKThirtyTwoBytes TrustedCommitmentTransaction_txid(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
25505 export function TrustedCommitmentTransaction_txid(this_arg: number): number {
25506 if(!isWasmInitialized) {
25507 throw new Error("initializeWasm() must be awaited first!");
25509 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_txid(this_arg);
25510 return nativeResponseValue;
25512 // MUST_USE_RES struct LDKBuiltCommitmentTransaction TrustedCommitmentTransaction_built_transaction(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
25514 export function TrustedCommitmentTransaction_built_transaction(this_arg: number): number {
25515 if(!isWasmInitialized) {
25516 throw new Error("initializeWasm() must be awaited first!");
25518 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_built_transaction(this_arg);
25519 return nativeResponseValue;
25521 // MUST_USE_RES struct LDKTxCreationKeys TrustedCommitmentTransaction_keys(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
25523 export function TrustedCommitmentTransaction_keys(this_arg: number): number {
25524 if(!isWasmInitialized) {
25525 throw new Error("initializeWasm() must be awaited first!");
25527 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_keys(this_arg);
25528 return nativeResponseValue;
25530 // MUST_USE_RES bool TrustedCommitmentTransaction_opt_anchors(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
25532 export function TrustedCommitmentTransaction_opt_anchors(this_arg: number): boolean {
25533 if(!isWasmInitialized) {
25534 throw new Error("initializeWasm() must be awaited first!");
25536 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_opt_anchors(this_arg);
25537 return nativeResponseValue;
25539 // 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);
25541 export function TrustedCommitmentTransaction_get_htlc_sigs(this_arg: number, htlc_base_key: number, channel_parameters: number): number {
25542 if(!isWasmInitialized) {
25543 throw new Error("initializeWasm() must be awaited first!");
25545 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_get_htlc_sigs(this_arg, htlc_base_key, channel_parameters);
25546 return nativeResponseValue;
25548 // uint64_t get_commitment_transaction_number_obscure_factor(struct LDKPublicKey broadcaster_payment_basepoint, struct LDKPublicKey countersignatory_payment_basepoint, bool outbound_from_broadcaster);
25550 export function get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint: number, countersignatory_payment_basepoint: number, outbound_from_broadcaster: boolean): bigint {
25551 if(!isWasmInitialized) {
25552 throw new Error("initializeWasm() must be awaited first!");
25554 const nativeResponseValue = wasm.TS_get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint, countersignatory_payment_basepoint, outbound_from_broadcaster);
25555 return nativeResponseValue;
25557 // bool InitFeatures_eq(const struct LDKInitFeatures *NONNULL_PTR a, const struct LDKInitFeatures *NONNULL_PTR b);
25559 export function InitFeatures_eq(a: number, b: number): boolean {
25560 if(!isWasmInitialized) {
25561 throw new Error("initializeWasm() must be awaited first!");
25563 const nativeResponseValue = wasm.TS_InitFeatures_eq(a, b);
25564 return nativeResponseValue;
25566 // bool NodeFeatures_eq(const struct LDKNodeFeatures *NONNULL_PTR a, const struct LDKNodeFeatures *NONNULL_PTR b);
25568 export function NodeFeatures_eq(a: number, b: number): boolean {
25569 if(!isWasmInitialized) {
25570 throw new Error("initializeWasm() must be awaited first!");
25572 const nativeResponseValue = wasm.TS_NodeFeatures_eq(a, b);
25573 return nativeResponseValue;
25575 // bool ChannelFeatures_eq(const struct LDKChannelFeatures *NONNULL_PTR a, const struct LDKChannelFeatures *NONNULL_PTR b);
25577 export function ChannelFeatures_eq(a: number, b: number): boolean {
25578 if(!isWasmInitialized) {
25579 throw new Error("initializeWasm() must be awaited first!");
25581 const nativeResponseValue = wasm.TS_ChannelFeatures_eq(a, b);
25582 return nativeResponseValue;
25584 // bool InvoiceFeatures_eq(const struct LDKInvoiceFeatures *NONNULL_PTR a, const struct LDKInvoiceFeatures *NONNULL_PTR b);
25586 export function InvoiceFeatures_eq(a: number, b: number): boolean {
25587 if(!isWasmInitialized) {
25588 throw new Error("initializeWasm() must be awaited first!");
25590 const nativeResponseValue = wasm.TS_InvoiceFeatures_eq(a, b);
25591 return nativeResponseValue;
25593 // bool ChannelTypeFeatures_eq(const struct LDKChannelTypeFeatures *NONNULL_PTR a, const struct LDKChannelTypeFeatures *NONNULL_PTR b);
25595 export function ChannelTypeFeatures_eq(a: number, b: number): boolean {
25596 if(!isWasmInitialized) {
25597 throw new Error("initializeWasm() must be awaited first!");
25599 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_eq(a, b);
25600 return nativeResponseValue;
25602 // uintptr_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg);
25604 export function InitFeatures_clone_ptr(arg: number): number {
25605 if(!isWasmInitialized) {
25606 throw new Error("initializeWasm() must be awaited first!");
25608 const nativeResponseValue = wasm.TS_InitFeatures_clone_ptr(arg);
25609 return nativeResponseValue;
25611 // struct LDKInitFeatures InitFeatures_clone(const struct LDKInitFeatures *NONNULL_PTR orig);
25613 export function InitFeatures_clone(orig: number): number {
25614 if(!isWasmInitialized) {
25615 throw new Error("initializeWasm() must be awaited first!");
25617 const nativeResponseValue = wasm.TS_InitFeatures_clone(orig);
25618 return nativeResponseValue;
25620 // uintptr_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg);
25622 export function NodeFeatures_clone_ptr(arg: number): number {
25623 if(!isWasmInitialized) {
25624 throw new Error("initializeWasm() must be awaited first!");
25626 const nativeResponseValue = wasm.TS_NodeFeatures_clone_ptr(arg);
25627 return nativeResponseValue;
25629 // struct LDKNodeFeatures NodeFeatures_clone(const struct LDKNodeFeatures *NONNULL_PTR orig);
25631 export function NodeFeatures_clone(orig: number): number {
25632 if(!isWasmInitialized) {
25633 throw new Error("initializeWasm() must be awaited first!");
25635 const nativeResponseValue = wasm.TS_NodeFeatures_clone(orig);
25636 return nativeResponseValue;
25638 // uintptr_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg);
25640 export function ChannelFeatures_clone_ptr(arg: number): number {
25641 if(!isWasmInitialized) {
25642 throw new Error("initializeWasm() must be awaited first!");
25644 const nativeResponseValue = wasm.TS_ChannelFeatures_clone_ptr(arg);
25645 return nativeResponseValue;
25647 // struct LDKChannelFeatures ChannelFeatures_clone(const struct LDKChannelFeatures *NONNULL_PTR orig);
25649 export function ChannelFeatures_clone(orig: number): number {
25650 if(!isWasmInitialized) {
25651 throw new Error("initializeWasm() must be awaited first!");
25653 const nativeResponseValue = wasm.TS_ChannelFeatures_clone(orig);
25654 return nativeResponseValue;
25656 // uintptr_t InvoiceFeatures_clone_ptr(LDKInvoiceFeatures *NONNULL_PTR arg);
25658 export function InvoiceFeatures_clone_ptr(arg: number): number {
25659 if(!isWasmInitialized) {
25660 throw new Error("initializeWasm() must be awaited first!");
25662 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone_ptr(arg);
25663 return nativeResponseValue;
25665 // struct LDKInvoiceFeatures InvoiceFeatures_clone(const struct LDKInvoiceFeatures *NONNULL_PTR orig);
25667 export function InvoiceFeatures_clone(orig: number): number {
25668 if(!isWasmInitialized) {
25669 throw new Error("initializeWasm() must be awaited first!");
25671 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone(orig);
25672 return nativeResponseValue;
25674 // uintptr_t ChannelTypeFeatures_clone_ptr(LDKChannelTypeFeatures *NONNULL_PTR arg);
25676 export function ChannelTypeFeatures_clone_ptr(arg: number): number {
25677 if(!isWasmInitialized) {
25678 throw new Error("initializeWasm() must be awaited first!");
25680 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone_ptr(arg);
25681 return nativeResponseValue;
25683 // struct LDKChannelTypeFeatures ChannelTypeFeatures_clone(const struct LDKChannelTypeFeatures *NONNULL_PTR orig);
25685 export function ChannelTypeFeatures_clone(orig: number): number {
25686 if(!isWasmInitialized) {
25687 throw new Error("initializeWasm() must be awaited first!");
25689 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone(orig);
25690 return nativeResponseValue;
25692 // void InitFeatures_free(struct LDKInitFeatures this_obj);
25694 export function InitFeatures_free(this_obj: number): void {
25695 if(!isWasmInitialized) {
25696 throw new Error("initializeWasm() must be awaited first!");
25698 const nativeResponseValue = wasm.TS_InitFeatures_free(this_obj);
25699 // debug statements here
25701 // void NodeFeatures_free(struct LDKNodeFeatures this_obj);
25703 export function NodeFeatures_free(this_obj: number): void {
25704 if(!isWasmInitialized) {
25705 throw new Error("initializeWasm() must be awaited first!");
25707 const nativeResponseValue = wasm.TS_NodeFeatures_free(this_obj);
25708 // debug statements here
25710 // void ChannelFeatures_free(struct LDKChannelFeatures this_obj);
25712 export function ChannelFeatures_free(this_obj: number): void {
25713 if(!isWasmInitialized) {
25714 throw new Error("initializeWasm() must be awaited first!");
25716 const nativeResponseValue = wasm.TS_ChannelFeatures_free(this_obj);
25717 // debug statements here
25719 // void InvoiceFeatures_free(struct LDKInvoiceFeatures this_obj);
25721 export function InvoiceFeatures_free(this_obj: number): void {
25722 if(!isWasmInitialized) {
25723 throw new Error("initializeWasm() must be awaited first!");
25725 const nativeResponseValue = wasm.TS_InvoiceFeatures_free(this_obj);
25726 // debug statements here
25728 // void ChannelTypeFeatures_free(struct LDKChannelTypeFeatures this_obj);
25730 export function ChannelTypeFeatures_free(this_obj: number): void {
25731 if(!isWasmInitialized) {
25732 throw new Error("initializeWasm() must be awaited first!");
25734 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_free(this_obj);
25735 // debug statements here
25737 // MUST_USE_RES struct LDKInitFeatures InitFeatures_empty(void);
25739 export function InitFeatures_empty(): number {
25740 if(!isWasmInitialized) {
25741 throw new Error("initializeWasm() must be awaited first!");
25743 const nativeResponseValue = wasm.TS_InitFeatures_empty();
25744 return nativeResponseValue;
25746 // MUST_USE_RES struct LDKInitFeatures InitFeatures_known(void);
25748 export function InitFeatures_known(): number {
25749 if(!isWasmInitialized) {
25750 throw new Error("initializeWasm() must be awaited first!");
25752 const nativeResponseValue = wasm.TS_InitFeatures_known();
25753 return nativeResponseValue;
25755 // MUST_USE_RES bool InitFeatures_requires_unknown_bits(const struct LDKInitFeatures *NONNULL_PTR this_arg);
25757 export function InitFeatures_requires_unknown_bits(this_arg: number): boolean {
25758 if(!isWasmInitialized) {
25759 throw new Error("initializeWasm() must be awaited first!");
25761 const nativeResponseValue = wasm.TS_InitFeatures_requires_unknown_bits(this_arg);
25762 return nativeResponseValue;
25764 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_empty(void);
25766 export function NodeFeatures_empty(): number {
25767 if(!isWasmInitialized) {
25768 throw new Error("initializeWasm() must be awaited first!");
25770 const nativeResponseValue = wasm.TS_NodeFeatures_empty();
25771 return nativeResponseValue;
25773 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_known(void);
25775 export function NodeFeatures_known(): number {
25776 if(!isWasmInitialized) {
25777 throw new Error("initializeWasm() must be awaited first!");
25779 const nativeResponseValue = wasm.TS_NodeFeatures_known();
25780 return nativeResponseValue;
25782 // MUST_USE_RES bool NodeFeatures_requires_unknown_bits(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
25784 export function NodeFeatures_requires_unknown_bits(this_arg: number): boolean {
25785 if(!isWasmInitialized) {
25786 throw new Error("initializeWasm() must be awaited first!");
25788 const nativeResponseValue = wasm.TS_NodeFeatures_requires_unknown_bits(this_arg);
25789 return nativeResponseValue;
25791 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_empty(void);
25793 export function ChannelFeatures_empty(): number {
25794 if(!isWasmInitialized) {
25795 throw new Error("initializeWasm() must be awaited first!");
25797 const nativeResponseValue = wasm.TS_ChannelFeatures_empty();
25798 return nativeResponseValue;
25800 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_known(void);
25802 export function ChannelFeatures_known(): number {
25803 if(!isWasmInitialized) {
25804 throw new Error("initializeWasm() must be awaited first!");
25806 const nativeResponseValue = wasm.TS_ChannelFeatures_known();
25807 return nativeResponseValue;
25809 // MUST_USE_RES bool ChannelFeatures_requires_unknown_bits(const struct LDKChannelFeatures *NONNULL_PTR this_arg);
25811 export function ChannelFeatures_requires_unknown_bits(this_arg: number): boolean {
25812 if(!isWasmInitialized) {
25813 throw new Error("initializeWasm() must be awaited first!");
25815 const nativeResponseValue = wasm.TS_ChannelFeatures_requires_unknown_bits(this_arg);
25816 return nativeResponseValue;
25818 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_empty(void);
25820 export function InvoiceFeatures_empty(): number {
25821 if(!isWasmInitialized) {
25822 throw new Error("initializeWasm() must be awaited first!");
25824 const nativeResponseValue = wasm.TS_InvoiceFeatures_empty();
25825 return nativeResponseValue;
25827 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_known(void);
25829 export function InvoiceFeatures_known(): number {
25830 if(!isWasmInitialized) {
25831 throw new Error("initializeWasm() must be awaited first!");
25833 const nativeResponseValue = wasm.TS_InvoiceFeatures_known();
25834 return nativeResponseValue;
25836 // MUST_USE_RES bool InvoiceFeatures_requires_unknown_bits(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
25838 export function InvoiceFeatures_requires_unknown_bits(this_arg: number): boolean {
25839 if(!isWasmInitialized) {
25840 throw new Error("initializeWasm() must be awaited first!");
25842 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_unknown_bits(this_arg);
25843 return nativeResponseValue;
25845 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_empty(void);
25847 export function ChannelTypeFeatures_empty(): number {
25848 if(!isWasmInitialized) {
25849 throw new Error("initializeWasm() must be awaited first!");
25851 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_empty();
25852 return nativeResponseValue;
25854 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_known(void);
25856 export function ChannelTypeFeatures_known(): number {
25857 if(!isWasmInitialized) {
25858 throw new Error("initializeWasm() must be awaited first!");
25860 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_known();
25861 return nativeResponseValue;
25863 // MUST_USE_RES bool ChannelTypeFeatures_requires_unknown_bits(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
25865 export function ChannelTypeFeatures_requires_unknown_bits(this_arg: number): boolean {
25866 if(!isWasmInitialized) {
25867 throw new Error("initializeWasm() must be awaited first!");
25869 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_unknown_bits(this_arg);
25870 return nativeResponseValue;
25872 // struct LDKCVec_u8Z InitFeatures_write(const struct LDKInitFeatures *NONNULL_PTR obj);
25874 export function InitFeatures_write(obj: number): number {
25875 if(!isWasmInitialized) {
25876 throw new Error("initializeWasm() must be awaited first!");
25878 const nativeResponseValue = wasm.TS_InitFeatures_write(obj);
25879 return nativeResponseValue;
25881 // struct LDKCResult_InitFeaturesDecodeErrorZ InitFeatures_read(struct LDKu8slice ser);
25883 export function InitFeatures_read(ser: number): number {
25884 if(!isWasmInitialized) {
25885 throw new Error("initializeWasm() must be awaited first!");
25887 const nativeResponseValue = wasm.TS_InitFeatures_read(ser);
25888 return nativeResponseValue;
25890 // struct LDKCVec_u8Z ChannelFeatures_write(const struct LDKChannelFeatures *NONNULL_PTR obj);
25892 export function ChannelFeatures_write(obj: number): number {
25893 if(!isWasmInitialized) {
25894 throw new Error("initializeWasm() must be awaited first!");
25896 const nativeResponseValue = wasm.TS_ChannelFeatures_write(obj);
25897 return nativeResponseValue;
25899 // struct LDKCResult_ChannelFeaturesDecodeErrorZ ChannelFeatures_read(struct LDKu8slice ser);
25901 export function ChannelFeatures_read(ser: number): number {
25902 if(!isWasmInitialized) {
25903 throw new Error("initializeWasm() must be awaited first!");
25905 const nativeResponseValue = wasm.TS_ChannelFeatures_read(ser);
25906 return nativeResponseValue;
25908 // struct LDKCVec_u8Z NodeFeatures_write(const struct LDKNodeFeatures *NONNULL_PTR obj);
25910 export function NodeFeatures_write(obj: number): number {
25911 if(!isWasmInitialized) {
25912 throw new Error("initializeWasm() must be awaited first!");
25914 const nativeResponseValue = wasm.TS_NodeFeatures_write(obj);
25915 return nativeResponseValue;
25917 // struct LDKCResult_NodeFeaturesDecodeErrorZ NodeFeatures_read(struct LDKu8slice ser);
25919 export function NodeFeatures_read(ser: number): number {
25920 if(!isWasmInitialized) {
25921 throw new Error("initializeWasm() must be awaited first!");
25923 const nativeResponseValue = wasm.TS_NodeFeatures_read(ser);
25924 return nativeResponseValue;
25926 // struct LDKCVec_u8Z InvoiceFeatures_write(const struct LDKInvoiceFeatures *NONNULL_PTR obj);
25928 export function InvoiceFeatures_write(obj: number): number {
25929 if(!isWasmInitialized) {
25930 throw new Error("initializeWasm() must be awaited first!");
25932 const nativeResponseValue = wasm.TS_InvoiceFeatures_write(obj);
25933 return nativeResponseValue;
25935 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ InvoiceFeatures_read(struct LDKu8slice ser);
25937 export function InvoiceFeatures_read(ser: number): number {
25938 if(!isWasmInitialized) {
25939 throw new Error("initializeWasm() must be awaited first!");
25941 const nativeResponseValue = wasm.TS_InvoiceFeatures_read(ser);
25942 return nativeResponseValue;
25944 // struct LDKCVec_u8Z ChannelTypeFeatures_write(const struct LDKChannelTypeFeatures *NONNULL_PTR obj);
25946 export function ChannelTypeFeatures_write(obj: number): number {
25947 if(!isWasmInitialized) {
25948 throw new Error("initializeWasm() must be awaited first!");
25950 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_write(obj);
25951 return nativeResponseValue;
25953 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ ChannelTypeFeatures_read(struct LDKu8slice ser);
25955 export function ChannelTypeFeatures_read(ser: number): number {
25956 if(!isWasmInitialized) {
25957 throw new Error("initializeWasm() must be awaited first!");
25959 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_read(ser);
25960 return nativeResponseValue;
25962 // void ShutdownScript_free(struct LDKShutdownScript this_obj);
25964 export function ShutdownScript_free(this_obj: number): void {
25965 if(!isWasmInitialized) {
25966 throw new Error("initializeWasm() must be awaited first!");
25968 const nativeResponseValue = wasm.TS_ShutdownScript_free(this_obj);
25969 // debug statements here
25971 // uintptr_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg);
25973 export function ShutdownScript_clone_ptr(arg: number): number {
25974 if(!isWasmInitialized) {
25975 throw new Error("initializeWasm() must be awaited first!");
25977 const nativeResponseValue = wasm.TS_ShutdownScript_clone_ptr(arg);
25978 return nativeResponseValue;
25980 // struct LDKShutdownScript ShutdownScript_clone(const struct LDKShutdownScript *NONNULL_PTR orig);
25982 export function ShutdownScript_clone(orig: number): number {
25983 if(!isWasmInitialized) {
25984 throw new Error("initializeWasm() must be awaited first!");
25986 const nativeResponseValue = wasm.TS_ShutdownScript_clone(orig);
25987 return nativeResponseValue;
25989 // void InvalidShutdownScript_free(struct LDKInvalidShutdownScript this_obj);
25991 export function InvalidShutdownScript_free(this_obj: number): void {
25992 if(!isWasmInitialized) {
25993 throw new Error("initializeWasm() must be awaited first!");
25995 const nativeResponseValue = wasm.TS_InvalidShutdownScript_free(this_obj);
25996 // debug statements here
25998 // struct LDKu8slice InvalidShutdownScript_get_script(const struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr);
26000 export function InvalidShutdownScript_get_script(this_ptr: number): number {
26001 if(!isWasmInitialized) {
26002 throw new Error("initializeWasm() must be awaited first!");
26004 const nativeResponseValue = wasm.TS_InvalidShutdownScript_get_script(this_ptr);
26005 return nativeResponseValue;
26007 // void InvalidShutdownScript_set_script(struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
26009 export function InvalidShutdownScript_set_script(this_ptr: number, val: number): void {
26010 if(!isWasmInitialized) {
26011 throw new Error("initializeWasm() must be awaited first!");
26013 const nativeResponseValue = wasm.TS_InvalidShutdownScript_set_script(this_ptr, val);
26014 // debug statements here
26016 // MUST_USE_RES struct LDKInvalidShutdownScript InvalidShutdownScript_new(struct LDKCVec_u8Z script_arg);
26018 export function InvalidShutdownScript_new(script_arg: number): number {
26019 if(!isWasmInitialized) {
26020 throw new Error("initializeWasm() must be awaited first!");
26022 const nativeResponseValue = wasm.TS_InvalidShutdownScript_new(script_arg);
26023 return nativeResponseValue;
26025 // uintptr_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg);
26027 export function InvalidShutdownScript_clone_ptr(arg: number): number {
26028 if(!isWasmInitialized) {
26029 throw new Error("initializeWasm() must be awaited first!");
26031 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone_ptr(arg);
26032 return nativeResponseValue;
26034 // struct LDKInvalidShutdownScript InvalidShutdownScript_clone(const struct LDKInvalidShutdownScript *NONNULL_PTR orig);
26036 export function InvalidShutdownScript_clone(orig: number): number {
26037 if(!isWasmInitialized) {
26038 throw new Error("initializeWasm() must be awaited first!");
26040 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone(orig);
26041 return nativeResponseValue;
26043 // struct LDKCVec_u8Z ShutdownScript_write(const struct LDKShutdownScript *NONNULL_PTR obj);
26045 export function ShutdownScript_write(obj: number): number {
26046 if(!isWasmInitialized) {
26047 throw new Error("initializeWasm() must be awaited first!");
26049 const nativeResponseValue = wasm.TS_ShutdownScript_write(obj);
26050 return nativeResponseValue;
26052 // struct LDKCResult_ShutdownScriptDecodeErrorZ ShutdownScript_read(struct LDKu8slice ser);
26054 export function ShutdownScript_read(ser: number): number {
26055 if(!isWasmInitialized) {
26056 throw new Error("initializeWasm() must be awaited first!");
26058 const nativeResponseValue = wasm.TS_ShutdownScript_read(ser);
26059 return nativeResponseValue;
26061 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wpkh(const uint8_t (*pubkey_hash)[20]);
26063 export function ShutdownScript_new_p2wpkh(pubkey_hash: number): number {
26064 if(!isWasmInitialized) {
26065 throw new Error("initializeWasm() must be awaited first!");
26067 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wpkh(pubkey_hash);
26068 return nativeResponseValue;
26070 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wsh(const uint8_t (*script_hash)[32]);
26072 export function ShutdownScript_new_p2wsh(script_hash: number): number {
26073 if(!isWasmInitialized) {
26074 throw new Error("initializeWasm() must be awaited first!");
26076 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wsh(script_hash);
26077 return nativeResponseValue;
26079 // MUST_USE_RES struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ ShutdownScript_new_witness_program(uint8_t version, struct LDKu8slice program);
26081 export function ShutdownScript_new_witness_program(version: number, program: number): number {
26082 if(!isWasmInitialized) {
26083 throw new Error("initializeWasm() must be awaited first!");
26085 const nativeResponseValue = wasm.TS_ShutdownScript_new_witness_program(version, program);
26086 return nativeResponseValue;
26088 // MUST_USE_RES struct LDKCVec_u8Z ShutdownScript_into_inner(struct LDKShutdownScript this_arg);
26090 export function ShutdownScript_into_inner(this_arg: number): number {
26091 if(!isWasmInitialized) {
26092 throw new Error("initializeWasm() must be awaited first!");
26094 const nativeResponseValue = wasm.TS_ShutdownScript_into_inner(this_arg);
26095 return nativeResponseValue;
26097 // MUST_USE_RES struct LDKPublicKey ShutdownScript_as_legacy_pubkey(const struct LDKShutdownScript *NONNULL_PTR this_arg);
26099 export function ShutdownScript_as_legacy_pubkey(this_arg: number): number {
26100 if(!isWasmInitialized) {
26101 throw new Error("initializeWasm() must be awaited first!");
26103 const nativeResponseValue = wasm.TS_ShutdownScript_as_legacy_pubkey(this_arg);
26104 return nativeResponseValue;
26106 // MUST_USE_RES bool ShutdownScript_is_compatible(const struct LDKShutdownScript *NONNULL_PTR this_arg, const struct LDKInitFeatures *NONNULL_PTR features);
26108 export function ShutdownScript_is_compatible(this_arg: number, features: number): boolean {
26109 if(!isWasmInitialized) {
26110 throw new Error("initializeWasm() must be awaited first!");
26112 const nativeResponseValue = wasm.TS_ShutdownScript_is_compatible(this_arg, features);
26113 return nativeResponseValue;
26115 // void CustomMessageReader_free(struct LDKCustomMessageReader this_ptr);
26117 export function CustomMessageReader_free(this_ptr: number): void {
26118 if(!isWasmInitialized) {
26119 throw new Error("initializeWasm() must be awaited first!");
26121 const nativeResponseValue = wasm.TS_CustomMessageReader_free(this_ptr);
26122 // debug statements here
26124 // uintptr_t Type_clone_ptr(LDKType *NONNULL_PTR arg);
26126 export function Type_clone_ptr(arg: number): number {
26127 if(!isWasmInitialized) {
26128 throw new Error("initializeWasm() must be awaited first!");
26130 const nativeResponseValue = wasm.TS_Type_clone_ptr(arg);
26131 return nativeResponseValue;
26133 // struct LDKType Type_clone(const struct LDKType *NONNULL_PTR orig);
26135 export function Type_clone(orig: number): number {
26136 if(!isWasmInitialized) {
26137 throw new Error("initializeWasm() must be awaited first!");
26139 const nativeResponseValue = wasm.TS_Type_clone(orig);
26140 return nativeResponseValue;
26142 // void Type_free(struct LDKType this_ptr);
26144 export function Type_free(this_ptr: number): void {
26145 if(!isWasmInitialized) {
26146 throw new Error("initializeWasm() must be awaited first!");
26148 const nativeResponseValue = wasm.TS_Type_free(this_ptr);
26149 // debug statements here
26151 // void NodeId_free(struct LDKNodeId this_obj);
26153 export function NodeId_free(this_obj: number): void {
26154 if(!isWasmInitialized) {
26155 throw new Error("initializeWasm() must be awaited first!");
26157 const nativeResponseValue = wasm.TS_NodeId_free(this_obj);
26158 // debug statements here
26160 // uintptr_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg);
26162 export function NodeId_clone_ptr(arg: number): number {
26163 if(!isWasmInitialized) {
26164 throw new Error("initializeWasm() must be awaited first!");
26166 const nativeResponseValue = wasm.TS_NodeId_clone_ptr(arg);
26167 return nativeResponseValue;
26169 // struct LDKNodeId NodeId_clone(const struct LDKNodeId *NONNULL_PTR orig);
26171 export function NodeId_clone(orig: number): number {
26172 if(!isWasmInitialized) {
26173 throw new Error("initializeWasm() must be awaited first!");
26175 const nativeResponseValue = wasm.TS_NodeId_clone(orig);
26176 return nativeResponseValue;
26178 // MUST_USE_RES struct LDKNodeId NodeId_from_pubkey(struct LDKPublicKey pubkey);
26180 export function NodeId_from_pubkey(pubkey: number): number {
26181 if(!isWasmInitialized) {
26182 throw new Error("initializeWasm() must be awaited first!");
26184 const nativeResponseValue = wasm.TS_NodeId_from_pubkey(pubkey);
26185 return nativeResponseValue;
26187 // MUST_USE_RES struct LDKu8slice NodeId_as_slice(const struct LDKNodeId *NONNULL_PTR this_arg);
26189 export function NodeId_as_slice(this_arg: number): number {
26190 if(!isWasmInitialized) {
26191 throw new Error("initializeWasm() must be awaited first!");
26193 const nativeResponseValue = wasm.TS_NodeId_as_slice(this_arg);
26194 return nativeResponseValue;
26196 // uint64_t NodeId_hash(const struct LDKNodeId *NONNULL_PTR o);
26198 export function NodeId_hash(o: number): bigint {
26199 if(!isWasmInitialized) {
26200 throw new Error("initializeWasm() must be awaited first!");
26202 const nativeResponseValue = wasm.TS_NodeId_hash(o);
26203 return nativeResponseValue;
26205 // struct LDKCVec_u8Z NodeId_write(const struct LDKNodeId *NONNULL_PTR obj);
26207 export function NodeId_write(obj: number): number {
26208 if(!isWasmInitialized) {
26209 throw new Error("initializeWasm() must be awaited first!");
26211 const nativeResponseValue = wasm.TS_NodeId_write(obj);
26212 return nativeResponseValue;
26214 // struct LDKCResult_NodeIdDecodeErrorZ NodeId_read(struct LDKu8slice ser);
26216 export function NodeId_read(ser: number): number {
26217 if(!isWasmInitialized) {
26218 throw new Error("initializeWasm() must be awaited first!");
26220 const nativeResponseValue = wasm.TS_NodeId_read(ser);
26221 return nativeResponseValue;
26223 // void NetworkGraph_free(struct LDKNetworkGraph this_obj);
26225 export function NetworkGraph_free(this_obj: number): void {
26226 if(!isWasmInitialized) {
26227 throw new Error("initializeWasm() must be awaited first!");
26229 const nativeResponseValue = wasm.TS_NetworkGraph_free(this_obj);
26230 // debug statements here
26232 // uintptr_t NetworkGraph_clone_ptr(LDKNetworkGraph *NONNULL_PTR arg);
26234 export function NetworkGraph_clone_ptr(arg: number): number {
26235 if(!isWasmInitialized) {
26236 throw new Error("initializeWasm() must be awaited first!");
26238 const nativeResponseValue = wasm.TS_NetworkGraph_clone_ptr(arg);
26239 return nativeResponseValue;
26241 // struct LDKNetworkGraph NetworkGraph_clone(const struct LDKNetworkGraph *NONNULL_PTR orig);
26243 export function NetworkGraph_clone(orig: number): number {
26244 if(!isWasmInitialized) {
26245 throw new Error("initializeWasm() must be awaited first!");
26247 const nativeResponseValue = wasm.TS_NetworkGraph_clone(orig);
26248 return nativeResponseValue;
26250 // void ReadOnlyNetworkGraph_free(struct LDKReadOnlyNetworkGraph this_obj);
26252 export function ReadOnlyNetworkGraph_free(this_obj: number): void {
26253 if(!isWasmInitialized) {
26254 throw new Error("initializeWasm() must be awaited first!");
26256 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_free(this_obj);
26257 // debug statements here
26259 // void NetworkUpdate_free(struct LDKNetworkUpdate this_ptr);
26261 export function NetworkUpdate_free(this_ptr: number): void {
26262 if(!isWasmInitialized) {
26263 throw new Error("initializeWasm() must be awaited first!");
26265 const nativeResponseValue = wasm.TS_NetworkUpdate_free(this_ptr);
26266 // debug statements here
26268 // uintptr_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg);
26270 export function NetworkUpdate_clone_ptr(arg: number): number {
26271 if(!isWasmInitialized) {
26272 throw new Error("initializeWasm() must be awaited first!");
26274 const nativeResponseValue = wasm.TS_NetworkUpdate_clone_ptr(arg);
26275 return nativeResponseValue;
26277 // struct LDKNetworkUpdate NetworkUpdate_clone(const struct LDKNetworkUpdate *NONNULL_PTR orig);
26279 export function NetworkUpdate_clone(orig: number): number {
26280 if(!isWasmInitialized) {
26281 throw new Error("initializeWasm() must be awaited first!");
26283 const nativeResponseValue = wasm.TS_NetworkUpdate_clone(orig);
26284 return nativeResponseValue;
26286 // struct LDKNetworkUpdate NetworkUpdate_channel_update_message(struct LDKChannelUpdate msg);
26288 export function NetworkUpdate_channel_update_message(msg: number): number {
26289 if(!isWasmInitialized) {
26290 throw new Error("initializeWasm() must be awaited first!");
26292 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_update_message(msg);
26293 return nativeResponseValue;
26295 // struct LDKNetworkUpdate NetworkUpdate_channel_closed(uint64_t short_channel_id, bool is_permanent);
26297 export function NetworkUpdate_channel_closed(short_channel_id: bigint, is_permanent: boolean): number {
26298 if(!isWasmInitialized) {
26299 throw new Error("initializeWasm() must be awaited first!");
26301 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_closed(short_channel_id, is_permanent);
26302 return nativeResponseValue;
26304 // struct LDKNetworkUpdate NetworkUpdate_node_failure(struct LDKPublicKey node_id, bool is_permanent);
26306 export function NetworkUpdate_node_failure(node_id: number, is_permanent: boolean): number {
26307 if(!isWasmInitialized) {
26308 throw new Error("initializeWasm() must be awaited first!");
26310 const nativeResponseValue = wasm.TS_NetworkUpdate_node_failure(node_id, is_permanent);
26311 return nativeResponseValue;
26313 // struct LDKCVec_u8Z NetworkUpdate_write(const struct LDKNetworkUpdate *NONNULL_PTR obj);
26315 export function NetworkUpdate_write(obj: number): number {
26316 if(!isWasmInitialized) {
26317 throw new Error("initializeWasm() must be awaited first!");
26319 const nativeResponseValue = wasm.TS_NetworkUpdate_write(obj);
26320 return nativeResponseValue;
26322 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ NetworkUpdate_read(struct LDKu8slice ser);
26324 export function NetworkUpdate_read(ser: number): number {
26325 if(!isWasmInitialized) {
26326 throw new Error("initializeWasm() must be awaited first!");
26328 const nativeResponseValue = wasm.TS_NetworkUpdate_read(ser);
26329 return nativeResponseValue;
26331 // struct LDKEventHandler NetGraphMsgHandler_as_EventHandler(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
26333 export function NetGraphMsgHandler_as_EventHandler(this_arg: number): number {
26334 if(!isWasmInitialized) {
26335 throw new Error("initializeWasm() must be awaited first!");
26337 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_as_EventHandler(this_arg);
26338 return nativeResponseValue;
26340 // void NetGraphMsgHandler_free(struct LDKNetGraphMsgHandler this_obj);
26342 export function NetGraphMsgHandler_free(this_obj: number): void {
26343 if(!isWasmInitialized) {
26344 throw new Error("initializeWasm() must be awaited first!");
26346 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_free(this_obj);
26347 // debug statements here
26349 // MUST_USE_RES struct LDKNetGraphMsgHandler NetGraphMsgHandler_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCOption_AccessZ chain_access, struct LDKLogger logger);
26351 export function NetGraphMsgHandler_new(network_graph: number, chain_access: number, logger: number): number {
26352 if(!isWasmInitialized) {
26353 throw new Error("initializeWasm() must be awaited first!");
26355 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_new(network_graph, chain_access, logger);
26356 return nativeResponseValue;
26358 // void NetGraphMsgHandler_add_chain_access(struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg, struct LDKCOption_AccessZ chain_access);
26360 export function NetGraphMsgHandler_add_chain_access(this_arg: number, chain_access: number): void {
26361 if(!isWasmInitialized) {
26362 throw new Error("initializeWasm() must be awaited first!");
26364 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_add_chain_access(this_arg, chain_access);
26365 // debug statements here
26367 // struct LDKRoutingMessageHandler NetGraphMsgHandler_as_RoutingMessageHandler(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
26369 export function NetGraphMsgHandler_as_RoutingMessageHandler(this_arg: number): number {
26370 if(!isWasmInitialized) {
26371 throw new Error("initializeWasm() must be awaited first!");
26373 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_as_RoutingMessageHandler(this_arg);
26374 return nativeResponseValue;
26376 // struct LDKMessageSendEventsProvider NetGraphMsgHandler_as_MessageSendEventsProvider(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
26378 export function NetGraphMsgHandler_as_MessageSendEventsProvider(this_arg: number): number {
26379 if(!isWasmInitialized) {
26380 throw new Error("initializeWasm() must be awaited first!");
26382 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_as_MessageSendEventsProvider(this_arg);
26383 return nativeResponseValue;
26385 // void ChannelUpdateInfo_free(struct LDKChannelUpdateInfo this_obj);
26387 export function ChannelUpdateInfo_free(this_obj: number): void {
26388 if(!isWasmInitialized) {
26389 throw new Error("initializeWasm() must be awaited first!");
26391 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_free(this_obj);
26392 // debug statements here
26394 // uint32_t ChannelUpdateInfo_get_last_update(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
26396 export function ChannelUpdateInfo_get_last_update(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(this_ptr);
26401 return nativeResponseValue;
26403 // void ChannelUpdateInfo_set_last_update(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint32_t val);
26405 export function ChannelUpdateInfo_set_last_update(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(this_ptr, val);
26410 // debug statements here
26412 // bool ChannelUpdateInfo_get_enabled(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
26414 export function ChannelUpdateInfo_get_enabled(this_ptr: number): boolean {
26415 if(!isWasmInitialized) {
26416 throw new Error("initializeWasm() must be awaited first!");
26418 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_enabled(this_ptr);
26419 return nativeResponseValue;
26421 // void ChannelUpdateInfo_set_enabled(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, bool val);
26423 export function ChannelUpdateInfo_set_enabled(this_ptr: number, val: boolean): void {
26424 if(!isWasmInitialized) {
26425 throw new Error("initializeWasm() must be awaited first!");
26427 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_enabled(this_ptr, val);
26428 // debug statements here
26430 // uint16_t ChannelUpdateInfo_get_cltv_expiry_delta(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
26432 export function ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr: number): number {
26433 if(!isWasmInitialized) {
26434 throw new Error("initializeWasm() must be awaited first!");
26436 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr);
26437 return nativeResponseValue;
26439 // void ChannelUpdateInfo_set_cltv_expiry_delta(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint16_t val);
26441 export function ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr: number, val: number): void {
26442 if(!isWasmInitialized) {
26443 throw new Error("initializeWasm() must be awaited first!");
26445 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr, val);
26446 // debug statements here
26448 // uint64_t ChannelUpdateInfo_get_htlc_minimum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
26450 export function ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr: number): bigint {
26451 if(!isWasmInitialized) {
26452 throw new Error("initializeWasm() must be awaited first!");
26454 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr);
26455 return nativeResponseValue;
26457 // void ChannelUpdateInfo_set_htlc_minimum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
26459 export function ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
26460 if(!isWasmInitialized) {
26461 throw new Error("initializeWasm() must be awaited first!");
26463 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr, val);
26464 // debug statements here
26466 // struct LDKCOption_u64Z ChannelUpdateInfo_get_htlc_maximum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
26468 export function ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr: number): number {
26469 if(!isWasmInitialized) {
26470 throw new Error("initializeWasm() must be awaited first!");
26472 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr);
26473 return nativeResponseValue;
26475 // void ChannelUpdateInfo_set_htlc_maximum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
26477 export function ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr: number, val: number): void {
26478 if(!isWasmInitialized) {
26479 throw new Error("initializeWasm() must be awaited first!");
26481 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr, val);
26482 // debug statements here
26484 // struct LDKRoutingFees ChannelUpdateInfo_get_fees(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
26486 export function ChannelUpdateInfo_get_fees(this_ptr: number): number {
26487 if(!isWasmInitialized) {
26488 throw new Error("initializeWasm() must be awaited first!");
26490 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_fees(this_ptr);
26491 return nativeResponseValue;
26493 // void ChannelUpdateInfo_set_fees(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
26495 export function ChannelUpdateInfo_set_fees(this_ptr: number, val: number): void {
26496 if(!isWasmInitialized) {
26497 throw new Error("initializeWasm() must be awaited first!");
26499 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_fees(this_ptr, val);
26500 // debug statements here
26502 // struct LDKChannelUpdate ChannelUpdateInfo_get_last_update_message(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
26504 export function ChannelUpdateInfo_get_last_update_message(this_ptr: number): number {
26505 if(!isWasmInitialized) {
26506 throw new Error("initializeWasm() must be awaited first!");
26508 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update_message(this_ptr);
26509 return nativeResponseValue;
26511 // void ChannelUpdateInfo_set_last_update_message(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdate val);
26513 export function ChannelUpdateInfo_set_last_update_message(this_ptr: number, val: number): void {
26514 if(!isWasmInitialized) {
26515 throw new Error("initializeWasm() must be awaited first!");
26517 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update_message(this_ptr, val);
26518 // debug statements here
26520 // 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);
26522 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 {
26523 if(!isWasmInitialized) {
26524 throw new Error("initializeWasm() must be awaited first!");
26526 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);
26527 return nativeResponseValue;
26529 // uintptr_t ChannelUpdateInfo_clone_ptr(LDKChannelUpdateInfo *NONNULL_PTR arg);
26531 export function ChannelUpdateInfo_clone_ptr(arg: number): number {
26532 if(!isWasmInitialized) {
26533 throw new Error("initializeWasm() must be awaited first!");
26535 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone_ptr(arg);
26536 return nativeResponseValue;
26538 // struct LDKChannelUpdateInfo ChannelUpdateInfo_clone(const struct LDKChannelUpdateInfo *NONNULL_PTR orig);
26540 export function ChannelUpdateInfo_clone(orig: number): number {
26541 if(!isWasmInitialized) {
26542 throw new Error("initializeWasm() must be awaited first!");
26544 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone(orig);
26545 return nativeResponseValue;
26547 // struct LDKCVec_u8Z ChannelUpdateInfo_write(const struct LDKChannelUpdateInfo *NONNULL_PTR obj);
26549 export function ChannelUpdateInfo_write(obj: number): number {
26550 if(!isWasmInitialized) {
26551 throw new Error("initializeWasm() must be awaited first!");
26553 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_write(obj);
26554 return nativeResponseValue;
26556 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ ChannelUpdateInfo_read(struct LDKu8slice ser);
26558 export function ChannelUpdateInfo_read(ser: number): number {
26559 if(!isWasmInitialized) {
26560 throw new Error("initializeWasm() must be awaited first!");
26562 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_read(ser);
26563 return nativeResponseValue;
26565 // void ChannelInfo_free(struct LDKChannelInfo this_obj);
26567 export function ChannelInfo_free(this_obj: number): void {
26568 if(!isWasmInitialized) {
26569 throw new Error("initializeWasm() must be awaited first!");
26571 const nativeResponseValue = wasm.TS_ChannelInfo_free(this_obj);
26572 // debug statements here
26574 // struct LDKChannelFeatures ChannelInfo_get_features(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
26576 export function ChannelInfo_get_features(this_ptr: number): number {
26577 if(!isWasmInitialized) {
26578 throw new Error("initializeWasm() must be awaited first!");
26580 const nativeResponseValue = wasm.TS_ChannelInfo_get_features(this_ptr);
26581 return nativeResponseValue;
26583 // void ChannelInfo_set_features(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
26585 export function ChannelInfo_set_features(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_features(this_ptr, val);
26590 // debug statements here
26592 // struct LDKNodeId ChannelInfo_get_node_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
26594 export function ChannelInfo_get_node_one(this_ptr: number): number {
26595 if(!isWasmInitialized) {
26596 throw new Error("initializeWasm() must be awaited first!");
26598 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_one(this_ptr);
26599 return nativeResponseValue;
26601 // void ChannelInfo_set_node_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
26603 export function ChannelInfo_set_node_one(this_ptr: number, val: number): void {
26604 if(!isWasmInitialized) {
26605 throw new Error("initializeWasm() must be awaited first!");
26607 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_one(this_ptr, val);
26608 // debug statements here
26610 // struct LDKChannelUpdateInfo ChannelInfo_get_one_to_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
26612 export function ChannelInfo_get_one_to_two(this_ptr: number): number {
26613 if(!isWasmInitialized) {
26614 throw new Error("initializeWasm() must be awaited first!");
26616 const nativeResponseValue = wasm.TS_ChannelInfo_get_one_to_two(this_ptr);
26617 return nativeResponseValue;
26619 // void ChannelInfo_set_one_to_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
26621 export function ChannelInfo_set_one_to_two(this_ptr: number, val: number): void {
26622 if(!isWasmInitialized) {
26623 throw new Error("initializeWasm() must be awaited first!");
26625 const nativeResponseValue = wasm.TS_ChannelInfo_set_one_to_two(this_ptr, val);
26626 // debug statements here
26628 // struct LDKNodeId ChannelInfo_get_node_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
26630 export function ChannelInfo_get_node_two(this_ptr: number): number {
26631 if(!isWasmInitialized) {
26632 throw new Error("initializeWasm() must be awaited first!");
26634 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_two(this_ptr);
26635 return nativeResponseValue;
26637 // void ChannelInfo_set_node_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
26639 export function ChannelInfo_set_node_two(this_ptr: number, val: number): void {
26640 if(!isWasmInitialized) {
26641 throw new Error("initializeWasm() must be awaited first!");
26643 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_two(this_ptr, val);
26644 // debug statements here
26646 // struct LDKChannelUpdateInfo ChannelInfo_get_two_to_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
26648 export function ChannelInfo_get_two_to_one(this_ptr: number): number {
26649 if(!isWasmInitialized) {
26650 throw new Error("initializeWasm() must be awaited first!");
26652 const nativeResponseValue = wasm.TS_ChannelInfo_get_two_to_one(this_ptr);
26653 return nativeResponseValue;
26655 // void ChannelInfo_set_two_to_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
26657 export function ChannelInfo_set_two_to_one(this_ptr: number, val: number): void {
26658 if(!isWasmInitialized) {
26659 throw new Error("initializeWasm() must be awaited first!");
26661 const nativeResponseValue = wasm.TS_ChannelInfo_set_two_to_one(this_ptr, val);
26662 // debug statements here
26664 // struct LDKCOption_u64Z ChannelInfo_get_capacity_sats(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
26666 export function ChannelInfo_get_capacity_sats(this_ptr: number): number {
26667 if(!isWasmInitialized) {
26668 throw new Error("initializeWasm() must be awaited first!");
26670 const nativeResponseValue = wasm.TS_ChannelInfo_get_capacity_sats(this_ptr);
26671 return nativeResponseValue;
26673 // void ChannelInfo_set_capacity_sats(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
26675 export function ChannelInfo_set_capacity_sats(this_ptr: number, val: number): void {
26676 if(!isWasmInitialized) {
26677 throw new Error("initializeWasm() must be awaited first!");
26679 const nativeResponseValue = wasm.TS_ChannelInfo_set_capacity_sats(this_ptr, val);
26680 // debug statements here
26682 // struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
26684 export function ChannelInfo_get_announcement_message(this_ptr: number): number {
26685 if(!isWasmInitialized) {
26686 throw new Error("initializeWasm() must be awaited first!");
26688 const nativeResponseValue = wasm.TS_ChannelInfo_get_announcement_message(this_ptr);
26689 return nativeResponseValue;
26691 // void ChannelInfo_set_announcement_message(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelAnnouncement val);
26693 export function ChannelInfo_set_announcement_message(this_ptr: number, val: number): void {
26694 if(!isWasmInitialized) {
26695 throw new Error("initializeWasm() must be awaited first!");
26697 const nativeResponseValue = wasm.TS_ChannelInfo_set_announcement_message(this_ptr, val);
26698 // debug statements here
26700 // uintptr_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg);
26702 export function ChannelInfo_clone_ptr(arg: number): number {
26703 if(!isWasmInitialized) {
26704 throw new Error("initializeWasm() must be awaited first!");
26706 const nativeResponseValue = wasm.TS_ChannelInfo_clone_ptr(arg);
26707 return nativeResponseValue;
26709 // struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
26711 export function ChannelInfo_clone(orig: number): number {
26712 if(!isWasmInitialized) {
26713 throw new Error("initializeWasm() must be awaited first!");
26715 const nativeResponseValue = wasm.TS_ChannelInfo_clone(orig);
26716 return nativeResponseValue;
26718 // struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
26720 export function ChannelInfo_write(obj: number): number {
26721 if(!isWasmInitialized) {
26722 throw new Error("initializeWasm() must be awaited first!");
26724 const nativeResponseValue = wasm.TS_ChannelInfo_write(obj);
26725 return nativeResponseValue;
26727 // struct LDKCResult_ChannelInfoDecodeErrorZ ChannelInfo_read(struct LDKu8slice ser);
26729 export function ChannelInfo_read(ser: number): number {
26730 if(!isWasmInitialized) {
26731 throw new Error("initializeWasm() must be awaited first!");
26733 const nativeResponseValue = wasm.TS_ChannelInfo_read(ser);
26734 return nativeResponseValue;
26736 // void DirectedChannelInfo_free(struct LDKDirectedChannelInfo this_obj);
26738 export function DirectedChannelInfo_free(this_obj: number): void {
26739 if(!isWasmInitialized) {
26740 throw new Error("initializeWasm() must be awaited first!");
26742 const nativeResponseValue = wasm.TS_DirectedChannelInfo_free(this_obj);
26743 // debug statements here
26745 // uintptr_t DirectedChannelInfo_clone_ptr(LDKDirectedChannelInfo *NONNULL_PTR arg);
26747 export function DirectedChannelInfo_clone_ptr(arg: number): number {
26748 if(!isWasmInitialized) {
26749 throw new Error("initializeWasm() must be awaited first!");
26751 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone_ptr(arg);
26752 return nativeResponseValue;
26754 // struct LDKDirectedChannelInfo DirectedChannelInfo_clone(const struct LDKDirectedChannelInfo *NONNULL_PTR orig);
26756 export function DirectedChannelInfo_clone(orig: number): number {
26757 if(!isWasmInitialized) {
26758 throw new Error("initializeWasm() must be awaited first!");
26760 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone(orig);
26761 return nativeResponseValue;
26763 // MUST_USE_RES struct LDKChannelInfo DirectedChannelInfo_channel(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
26765 export function DirectedChannelInfo_channel(this_arg: number): number {
26766 if(!isWasmInitialized) {
26767 throw new Error("initializeWasm() must be awaited first!");
26769 const nativeResponseValue = wasm.TS_DirectedChannelInfo_channel(this_arg);
26770 return nativeResponseValue;
26772 // MUST_USE_RES struct LDKChannelUpdateInfo DirectedChannelInfo_direction(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
26774 export function DirectedChannelInfo_direction(this_arg: number): number {
26775 if(!isWasmInitialized) {
26776 throw new Error("initializeWasm() must be awaited first!");
26778 const nativeResponseValue = wasm.TS_DirectedChannelInfo_direction(this_arg);
26779 return nativeResponseValue;
26781 // MUST_USE_RES struct LDKEffectiveCapacity DirectedChannelInfo_effective_capacity(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
26783 export function DirectedChannelInfo_effective_capacity(this_arg: number): number {
26784 if(!isWasmInitialized) {
26785 throw new Error("initializeWasm() must be awaited first!");
26787 const nativeResponseValue = wasm.TS_DirectedChannelInfo_effective_capacity(this_arg);
26788 return nativeResponseValue;
26790 // void EffectiveCapacity_free(struct LDKEffectiveCapacity this_ptr);
26792 export function EffectiveCapacity_free(this_ptr: number): void {
26793 if(!isWasmInitialized) {
26794 throw new Error("initializeWasm() must be awaited first!");
26796 const nativeResponseValue = wasm.TS_EffectiveCapacity_free(this_ptr);
26797 // debug statements here
26799 // uintptr_t EffectiveCapacity_clone_ptr(LDKEffectiveCapacity *NONNULL_PTR arg);
26801 export function EffectiveCapacity_clone_ptr(arg: number): number {
26802 if(!isWasmInitialized) {
26803 throw new Error("initializeWasm() must be awaited first!");
26805 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone_ptr(arg);
26806 return nativeResponseValue;
26808 // struct LDKEffectiveCapacity EffectiveCapacity_clone(const struct LDKEffectiveCapacity *NONNULL_PTR orig);
26810 export function EffectiveCapacity_clone(orig: number): number {
26811 if(!isWasmInitialized) {
26812 throw new Error("initializeWasm() must be awaited first!");
26814 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone(orig);
26815 return nativeResponseValue;
26817 // struct LDKEffectiveCapacity EffectiveCapacity_exact_liquidity(uint64_t liquidity_msat);
26819 export function EffectiveCapacity_exact_liquidity(liquidity_msat: bigint): number {
26820 if(!isWasmInitialized) {
26821 throw new Error("initializeWasm() must be awaited first!");
26823 const nativeResponseValue = wasm.TS_EffectiveCapacity_exact_liquidity(liquidity_msat);
26824 return nativeResponseValue;
26826 // struct LDKEffectiveCapacity EffectiveCapacity_maximum_htlc(uint64_t amount_msat);
26828 export function EffectiveCapacity_maximum_htlc(amount_msat: bigint): number {
26829 if(!isWasmInitialized) {
26830 throw new Error("initializeWasm() must be awaited first!");
26832 const nativeResponseValue = wasm.TS_EffectiveCapacity_maximum_htlc(amount_msat);
26833 return nativeResponseValue;
26835 // struct LDKEffectiveCapacity EffectiveCapacity_total(uint64_t capacity_msat);
26837 export function EffectiveCapacity_total(capacity_msat: bigint): number {
26838 if(!isWasmInitialized) {
26839 throw new Error("initializeWasm() must be awaited first!");
26841 const nativeResponseValue = wasm.TS_EffectiveCapacity_total(capacity_msat);
26842 return nativeResponseValue;
26844 // struct LDKEffectiveCapacity EffectiveCapacity_infinite(void);
26846 export function EffectiveCapacity_infinite(): number {
26847 if(!isWasmInitialized) {
26848 throw new Error("initializeWasm() must be awaited first!");
26850 const nativeResponseValue = wasm.TS_EffectiveCapacity_infinite();
26851 return nativeResponseValue;
26853 // struct LDKEffectiveCapacity EffectiveCapacity_unknown(void);
26855 export function EffectiveCapacity_unknown(): number {
26856 if(!isWasmInitialized) {
26857 throw new Error("initializeWasm() must be awaited first!");
26859 const nativeResponseValue = wasm.TS_EffectiveCapacity_unknown();
26860 return nativeResponseValue;
26862 // MUST_USE_RES uint64_t EffectiveCapacity_as_msat(const struct LDKEffectiveCapacity *NONNULL_PTR this_arg);
26864 export function EffectiveCapacity_as_msat(this_arg: number): bigint {
26865 if(!isWasmInitialized) {
26866 throw new Error("initializeWasm() must be awaited first!");
26868 const nativeResponseValue = wasm.TS_EffectiveCapacity_as_msat(this_arg);
26869 return nativeResponseValue;
26871 // void RoutingFees_free(struct LDKRoutingFees this_obj);
26873 export function RoutingFees_free(this_obj: number): void {
26874 if(!isWasmInitialized) {
26875 throw new Error("initializeWasm() must be awaited first!");
26877 const nativeResponseValue = wasm.TS_RoutingFees_free(this_obj);
26878 // debug statements here
26880 // uint32_t RoutingFees_get_base_msat(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
26882 export function RoutingFees_get_base_msat(this_ptr: number): number {
26883 if(!isWasmInitialized) {
26884 throw new Error("initializeWasm() must be awaited first!");
26886 const nativeResponseValue = wasm.TS_RoutingFees_get_base_msat(this_ptr);
26887 return nativeResponseValue;
26889 // void RoutingFees_set_base_msat(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
26891 export function RoutingFees_set_base_msat(this_ptr: number, val: number): void {
26892 if(!isWasmInitialized) {
26893 throw new Error("initializeWasm() must be awaited first!");
26895 const nativeResponseValue = wasm.TS_RoutingFees_set_base_msat(this_ptr, val);
26896 // debug statements here
26898 // uint32_t RoutingFees_get_proportional_millionths(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
26900 export function RoutingFees_get_proportional_millionths(this_ptr: number): number {
26901 if(!isWasmInitialized) {
26902 throw new Error("initializeWasm() must be awaited first!");
26904 const nativeResponseValue = wasm.TS_RoutingFees_get_proportional_millionths(this_ptr);
26905 return nativeResponseValue;
26907 // void RoutingFees_set_proportional_millionths(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
26909 export function RoutingFees_set_proportional_millionths(this_ptr: number, val: number): void {
26910 if(!isWasmInitialized) {
26911 throw new Error("initializeWasm() must be awaited first!");
26913 const nativeResponseValue = wasm.TS_RoutingFees_set_proportional_millionths(this_ptr, val);
26914 // debug statements here
26916 // MUST_USE_RES struct LDKRoutingFees RoutingFees_new(uint32_t base_msat_arg, uint32_t proportional_millionths_arg);
26918 export function RoutingFees_new(base_msat_arg: number, proportional_millionths_arg: number): number {
26919 if(!isWasmInitialized) {
26920 throw new Error("initializeWasm() must be awaited first!");
26922 const nativeResponseValue = wasm.TS_RoutingFees_new(base_msat_arg, proportional_millionths_arg);
26923 return nativeResponseValue;
26925 // bool RoutingFees_eq(const struct LDKRoutingFees *NONNULL_PTR a, const struct LDKRoutingFees *NONNULL_PTR b);
26927 export function RoutingFees_eq(a: number, b: number): boolean {
26928 if(!isWasmInitialized) {
26929 throw new Error("initializeWasm() must be awaited first!");
26931 const nativeResponseValue = wasm.TS_RoutingFees_eq(a, b);
26932 return nativeResponseValue;
26934 // uintptr_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg);
26936 export function RoutingFees_clone_ptr(arg: number): number {
26937 if(!isWasmInitialized) {
26938 throw new Error("initializeWasm() must be awaited first!");
26940 const nativeResponseValue = wasm.TS_RoutingFees_clone_ptr(arg);
26941 return nativeResponseValue;
26943 // struct LDKRoutingFees RoutingFees_clone(const struct LDKRoutingFees *NONNULL_PTR orig);
26945 export function RoutingFees_clone(orig: number): number {
26946 if(!isWasmInitialized) {
26947 throw new Error("initializeWasm() must be awaited first!");
26949 const nativeResponseValue = wasm.TS_RoutingFees_clone(orig);
26950 return nativeResponseValue;
26952 // uint64_t RoutingFees_hash(const struct LDKRoutingFees *NONNULL_PTR o);
26954 export function RoutingFees_hash(o: number): bigint {
26955 if(!isWasmInitialized) {
26956 throw new Error("initializeWasm() must be awaited first!");
26958 const nativeResponseValue = wasm.TS_RoutingFees_hash(o);
26959 return nativeResponseValue;
26961 // struct LDKCVec_u8Z RoutingFees_write(const struct LDKRoutingFees *NONNULL_PTR obj);
26963 export function RoutingFees_write(obj: number): number {
26964 if(!isWasmInitialized) {
26965 throw new Error("initializeWasm() must be awaited first!");
26967 const nativeResponseValue = wasm.TS_RoutingFees_write(obj);
26968 return nativeResponseValue;
26970 // struct LDKCResult_RoutingFeesDecodeErrorZ RoutingFees_read(struct LDKu8slice ser);
26972 export function RoutingFees_read(ser: number): number {
26973 if(!isWasmInitialized) {
26974 throw new Error("initializeWasm() must be awaited first!");
26976 const nativeResponseValue = wasm.TS_RoutingFees_read(ser);
26977 return nativeResponseValue;
26979 // void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_obj);
26981 export function NodeAnnouncementInfo_free(this_obj: number): void {
26982 if(!isWasmInitialized) {
26983 throw new Error("initializeWasm() must be awaited first!");
26985 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_free(this_obj);
26986 // debug statements here
26988 // struct LDKNodeFeatures NodeAnnouncementInfo_get_features(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
26990 export function NodeAnnouncementInfo_get_features(this_ptr: number): number {
26991 if(!isWasmInitialized) {
26992 throw new Error("initializeWasm() must be awaited first!");
26994 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_features(this_ptr);
26995 return nativeResponseValue;
26997 // void NodeAnnouncementInfo_set_features(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
26999 export function NodeAnnouncementInfo_set_features(this_ptr: number, val: number): void {
27000 if(!isWasmInitialized) {
27001 throw new Error("initializeWasm() must be awaited first!");
27003 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_features(this_ptr, val);
27004 // debug statements here
27006 // uint32_t NodeAnnouncementInfo_get_last_update(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
27008 export function NodeAnnouncementInfo_get_last_update(this_ptr: number): number {
27009 if(!isWasmInitialized) {
27010 throw new Error("initializeWasm() must be awaited first!");
27012 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_last_update(this_ptr);
27013 return nativeResponseValue;
27015 // void NodeAnnouncementInfo_set_last_update(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, uint32_t val);
27017 export function NodeAnnouncementInfo_set_last_update(this_ptr: number, val: number): void {
27018 if(!isWasmInitialized) {
27019 throw new Error("initializeWasm() must be awaited first!");
27021 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_last_update(this_ptr, val);
27022 // debug statements here
27024 // const uint8_t (*NodeAnnouncementInfo_get_rgb(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[3];
27026 export function NodeAnnouncementInfo_get_rgb(this_ptr: number): number {
27027 if(!isWasmInitialized) {
27028 throw new Error("initializeWasm() must be awaited first!");
27030 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_rgb(this_ptr);
27031 return nativeResponseValue;
27033 // void NodeAnnouncementInfo_set_rgb(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
27035 export function NodeAnnouncementInfo_set_rgb(this_ptr: number, val: number): void {
27036 if(!isWasmInitialized) {
27037 throw new Error("initializeWasm() must be awaited first!");
27039 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_rgb(this_ptr, val);
27040 // debug statements here
27042 // const uint8_t (*NodeAnnouncementInfo_get_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[32];
27044 export function NodeAnnouncementInfo_get_alias(this_ptr: number): number {
27045 if(!isWasmInitialized) {
27046 throw new Error("initializeWasm() must be awaited first!");
27048 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_alias(this_ptr);
27049 return nativeResponseValue;
27051 // void NodeAnnouncementInfo_set_alias(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
27053 export function NodeAnnouncementInfo_set_alias(this_ptr: number, val: number): void {
27054 if(!isWasmInitialized) {
27055 throw new Error("initializeWasm() must be awaited first!");
27057 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_alias(this_ptr, val);
27058 // debug statements here
27060 // void NodeAnnouncementInfo_set_addresses(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
27062 export function NodeAnnouncementInfo_set_addresses(this_ptr: number, val: number): void {
27063 if(!isWasmInitialized) {
27064 throw new Error("initializeWasm() must be awaited first!");
27066 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_addresses(this_ptr, val);
27067 // debug statements here
27069 // struct LDKNodeAnnouncement NodeAnnouncementInfo_get_announcement_message(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
27071 export function NodeAnnouncementInfo_get_announcement_message(this_ptr: number): number {
27072 if(!isWasmInitialized) {
27073 throw new Error("initializeWasm() must be awaited first!");
27075 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_announcement_message(this_ptr);
27076 return nativeResponseValue;
27078 // void NodeAnnouncementInfo_set_announcement_message(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncement val);
27080 export function NodeAnnouncementInfo_set_announcement_message(this_ptr: number, val: number): void {
27081 if(!isWasmInitialized) {
27082 throw new Error("initializeWasm() must be awaited first!");
27084 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_announcement_message(this_ptr, val);
27085 // debug statements here
27087 // 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);
27089 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 {
27090 if(!isWasmInitialized) {
27091 throw new Error("initializeWasm() must be awaited first!");
27093 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_new(features_arg, last_update_arg, rgb_arg, alias_arg, addresses_arg, announcement_message_arg);
27094 return nativeResponseValue;
27096 // uintptr_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg);
27098 export function NodeAnnouncementInfo_clone_ptr(arg: number): number {
27099 if(!isWasmInitialized) {
27100 throw new Error("initializeWasm() must be awaited first!");
27102 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone_ptr(arg);
27103 return nativeResponseValue;
27105 // struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
27107 export function NodeAnnouncementInfo_clone(orig: number): number {
27108 if(!isWasmInitialized) {
27109 throw new Error("initializeWasm() must be awaited first!");
27111 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone(orig);
27112 return nativeResponseValue;
27114 // struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementInfo *NONNULL_PTR obj);
27116 export function NodeAnnouncementInfo_write(obj: number): number {
27117 if(!isWasmInitialized) {
27118 throw new Error("initializeWasm() must be awaited first!");
27120 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_write(obj);
27121 return nativeResponseValue;
27123 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ NodeAnnouncementInfo_read(struct LDKu8slice ser);
27125 export function NodeAnnouncementInfo_read(ser: number): number {
27126 if(!isWasmInitialized) {
27127 throw new Error("initializeWasm() must be awaited first!");
27129 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_read(ser);
27130 return nativeResponseValue;
27132 // void NodeInfo_free(struct LDKNodeInfo this_obj);
27134 export function NodeInfo_free(this_obj: number): void {
27135 if(!isWasmInitialized) {
27136 throw new Error("initializeWasm() must be awaited first!");
27138 const nativeResponseValue = wasm.TS_NodeInfo_free(this_obj);
27139 // debug statements here
27141 // void NodeInfo_set_channels(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
27143 export function NodeInfo_set_channels(this_ptr: number, val: number): void {
27144 if(!isWasmInitialized) {
27145 throw new Error("initializeWasm() must be awaited first!");
27147 const nativeResponseValue = wasm.TS_NodeInfo_set_channels(this_ptr, val);
27148 // debug statements here
27150 // struct LDKRoutingFees NodeInfo_get_lowest_inbound_channel_fees(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
27152 export function NodeInfo_get_lowest_inbound_channel_fees(this_ptr: number): number {
27153 if(!isWasmInitialized) {
27154 throw new Error("initializeWasm() must be awaited first!");
27156 const nativeResponseValue = wasm.TS_NodeInfo_get_lowest_inbound_channel_fees(this_ptr);
27157 return nativeResponseValue;
27159 // void NodeInfo_set_lowest_inbound_channel_fees(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
27161 export function NodeInfo_set_lowest_inbound_channel_fees(this_ptr: number, val: number): void {
27162 if(!isWasmInitialized) {
27163 throw new Error("initializeWasm() must be awaited first!");
27165 const nativeResponseValue = wasm.TS_NodeInfo_set_lowest_inbound_channel_fees(this_ptr, val);
27166 // debug statements here
27168 // struct LDKNodeAnnouncementInfo NodeInfo_get_announcement_info(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
27170 export function NodeInfo_get_announcement_info(this_ptr: number): number {
27171 if(!isWasmInitialized) {
27172 throw new Error("initializeWasm() must be awaited first!");
27174 const nativeResponseValue = wasm.TS_NodeInfo_get_announcement_info(this_ptr);
27175 return nativeResponseValue;
27177 // void NodeInfo_set_announcement_info(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncementInfo val);
27179 export function NodeInfo_set_announcement_info(this_ptr: number, val: number): void {
27180 if(!isWasmInitialized) {
27181 throw new Error("initializeWasm() must be awaited first!");
27183 const nativeResponseValue = wasm.TS_NodeInfo_set_announcement_info(this_ptr, val);
27184 // debug statements here
27186 // MUST_USE_RES struct LDKNodeInfo NodeInfo_new(struct LDKCVec_u64Z channels_arg, struct LDKRoutingFees lowest_inbound_channel_fees_arg, struct LDKNodeAnnouncementInfo announcement_info_arg);
27188 export function NodeInfo_new(channels_arg: number, lowest_inbound_channel_fees_arg: number, announcement_info_arg: number): number {
27189 if(!isWasmInitialized) {
27190 throw new Error("initializeWasm() must be awaited first!");
27192 const nativeResponseValue = wasm.TS_NodeInfo_new(channels_arg, lowest_inbound_channel_fees_arg, announcement_info_arg);
27193 return nativeResponseValue;
27195 // uintptr_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg);
27197 export function NodeInfo_clone_ptr(arg: number): number {
27198 if(!isWasmInitialized) {
27199 throw new Error("initializeWasm() must be awaited first!");
27201 const nativeResponseValue = wasm.TS_NodeInfo_clone_ptr(arg);
27202 return nativeResponseValue;
27204 // struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
27206 export function NodeInfo_clone(orig: number): number {
27207 if(!isWasmInitialized) {
27208 throw new Error("initializeWasm() must be awaited first!");
27210 const nativeResponseValue = wasm.TS_NodeInfo_clone(orig);
27211 return nativeResponseValue;
27213 // struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
27215 export function NodeInfo_write(obj: number): number {
27216 if(!isWasmInitialized) {
27217 throw new Error("initializeWasm() must be awaited first!");
27219 const nativeResponseValue = wasm.TS_NodeInfo_write(obj);
27220 return nativeResponseValue;
27222 // struct LDKCResult_NodeInfoDecodeErrorZ NodeInfo_read(struct LDKu8slice ser);
27224 export function NodeInfo_read(ser: number): number {
27225 if(!isWasmInitialized) {
27226 throw new Error("initializeWasm() must be awaited first!");
27228 const nativeResponseValue = wasm.TS_NodeInfo_read(ser);
27229 return nativeResponseValue;
27231 // struct LDKCVec_u8Z NetworkGraph_write(const struct LDKNetworkGraph *NONNULL_PTR obj);
27233 export function NetworkGraph_write(obj: number): number {
27234 if(!isWasmInitialized) {
27235 throw new Error("initializeWasm() must be awaited first!");
27237 const nativeResponseValue = wasm.TS_NetworkGraph_write(obj);
27238 return nativeResponseValue;
27240 // struct LDKCResult_NetworkGraphDecodeErrorZ NetworkGraph_read(struct LDKu8slice ser);
27242 export function NetworkGraph_read(ser: number): number {
27243 if(!isWasmInitialized) {
27244 throw new Error("initializeWasm() must be awaited first!");
27246 const nativeResponseValue = wasm.TS_NetworkGraph_read(ser);
27247 return nativeResponseValue;
27249 // MUST_USE_RES struct LDKNetworkGraph NetworkGraph_new(struct LDKThirtyTwoBytes genesis_hash);
27251 export function NetworkGraph_new(genesis_hash: number): number {
27252 if(!isWasmInitialized) {
27253 throw new Error("initializeWasm() must be awaited first!");
27255 const nativeResponseValue = wasm.TS_NetworkGraph_new(genesis_hash);
27256 return nativeResponseValue;
27258 // MUST_USE_RES struct LDKReadOnlyNetworkGraph NetworkGraph_read_only(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
27260 export function NetworkGraph_read_only(this_arg: number): number {
27261 if(!isWasmInitialized) {
27262 throw new Error("initializeWasm() must be awaited first!");
27264 const nativeResponseValue = wasm.TS_NetworkGraph_read_only(this_arg);
27265 return nativeResponseValue;
27267 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
27269 export function NetworkGraph_update_node_from_announcement(this_arg: number, msg: number): number {
27270 if(!isWasmInitialized) {
27271 throw new Error("initializeWasm() must be awaited first!");
27273 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_announcement(this_arg, msg);
27274 return nativeResponseValue;
27276 // 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);
27278 export function NetworkGraph_update_node_from_unsigned_announcement(this_arg: number, msg: number): number {
27279 if(!isWasmInitialized) {
27280 throw new Error("initializeWasm() must be awaited first!");
27282 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_unsigned_announcement(this_arg, msg);
27283 return nativeResponseValue;
27285 // 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);
27287 export function NetworkGraph_update_channel_from_announcement(this_arg: number, msg: number, chain_access: number): number {
27288 if(!isWasmInitialized) {
27289 throw new Error("initializeWasm() must be awaited first!");
27291 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement(this_arg, msg, chain_access);
27292 return nativeResponseValue;
27294 // 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);
27296 export function NetworkGraph_update_channel_from_unsigned_announcement(this_arg: number, msg: number, chain_access: number): number {
27297 if(!isWasmInitialized) {
27298 throw new Error("initializeWasm() must be awaited first!");
27300 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_unsigned_announcement(this_arg, msg, chain_access);
27301 return nativeResponseValue;
27303 // void NetworkGraph_close_channel_from_update(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id, bool is_permanent);
27305 export function NetworkGraph_close_channel_from_update(this_arg: number, short_channel_id: bigint, is_permanent: boolean): void {
27306 if(!isWasmInitialized) {
27307 throw new Error("initializeWasm() must be awaited first!");
27309 const nativeResponseValue = wasm.TS_NetworkGraph_close_channel_from_update(this_arg, short_channel_id, is_permanent);
27310 // debug statements here
27312 // void NetworkGraph_fail_node(const struct LDKNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey _node_id, bool is_permanent);
27314 export function NetworkGraph_fail_node(this_arg: number, _node_id: number, is_permanent: boolean): void {
27315 if(!isWasmInitialized) {
27316 throw new Error("initializeWasm() must be awaited first!");
27318 const nativeResponseValue = wasm.TS_NetworkGraph_fail_node(this_arg, _node_id, is_permanent);
27319 // debug statements here
27321 // void NetworkGraph_remove_stale_channels_with_time(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t current_time_unix);
27323 export function NetworkGraph_remove_stale_channels_with_time(this_arg: number, current_time_unix: bigint): void {
27324 if(!isWasmInitialized) {
27325 throw new Error("initializeWasm() must be awaited first!");
27327 const nativeResponseValue = wasm.TS_NetworkGraph_remove_stale_channels_with_time(this_arg, current_time_unix);
27328 // debug statements here
27330 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
27332 export function NetworkGraph_update_channel(this_arg: number, msg: number): number {
27333 if(!isWasmInitialized) {
27334 throw new Error("initializeWasm() must be awaited first!");
27336 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel(this_arg, msg);
27337 return nativeResponseValue;
27339 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_unsigned(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelUpdate *NONNULL_PTR msg);
27341 export function NetworkGraph_update_channel_unsigned(this_arg: number, msg: number): number {
27342 if(!isWasmInitialized) {
27343 throw new Error("initializeWasm() must be awaited first!");
27345 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_unsigned(this_arg, msg);
27346 return nativeResponseValue;
27348 // MUST_USE_RES struct LDKCOption_CVec_NetAddressZZ ReadOnlyNetworkGraph_get_addresses(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey pubkey);
27350 export function ReadOnlyNetworkGraph_get_addresses(this_arg: number, pubkey: number): number {
27351 if(!isWasmInitialized) {
27352 throw new Error("initializeWasm() must be awaited first!");
27354 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_get_addresses(this_arg, pubkey);
27355 return nativeResponseValue;
27357 // void RouteHop_free(struct LDKRouteHop this_obj);
27359 export function RouteHop_free(this_obj: number): void {
27360 if(!isWasmInitialized) {
27361 throw new Error("initializeWasm() must be awaited first!");
27363 const nativeResponseValue = wasm.TS_RouteHop_free(this_obj);
27364 // debug statements here
27366 // struct LDKPublicKey RouteHop_get_pubkey(const struct LDKRouteHop *NONNULL_PTR this_ptr);
27368 export function RouteHop_get_pubkey(this_ptr: number): number {
27369 if(!isWasmInitialized) {
27370 throw new Error("initializeWasm() must be awaited first!");
27372 const nativeResponseValue = wasm.TS_RouteHop_get_pubkey(this_ptr);
27373 return nativeResponseValue;
27375 // void RouteHop_set_pubkey(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
27377 export function RouteHop_set_pubkey(this_ptr: number, val: number): void {
27378 if(!isWasmInitialized) {
27379 throw new Error("initializeWasm() must be awaited first!");
27381 const nativeResponseValue = wasm.TS_RouteHop_set_pubkey(this_ptr, val);
27382 // debug statements here
27384 // struct LDKNodeFeatures RouteHop_get_node_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
27386 export function RouteHop_get_node_features(this_ptr: number): number {
27387 if(!isWasmInitialized) {
27388 throw new Error("initializeWasm() must be awaited first!");
27390 const nativeResponseValue = wasm.TS_RouteHop_get_node_features(this_ptr);
27391 return nativeResponseValue;
27393 // void RouteHop_set_node_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
27395 export function RouteHop_set_node_features(this_ptr: number, val: number): void {
27396 if(!isWasmInitialized) {
27397 throw new Error("initializeWasm() must be awaited first!");
27399 const nativeResponseValue = wasm.TS_RouteHop_set_node_features(this_ptr, val);
27400 // debug statements here
27402 // uint64_t RouteHop_get_short_channel_id(const struct LDKRouteHop *NONNULL_PTR this_ptr);
27404 export function RouteHop_get_short_channel_id(this_ptr: number): bigint {
27405 if(!isWasmInitialized) {
27406 throw new Error("initializeWasm() must be awaited first!");
27408 const nativeResponseValue = wasm.TS_RouteHop_get_short_channel_id(this_ptr);
27409 return nativeResponseValue;
27411 // void RouteHop_set_short_channel_id(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
27413 export function RouteHop_set_short_channel_id(this_ptr: number, val: bigint): void {
27414 if(!isWasmInitialized) {
27415 throw new Error("initializeWasm() must be awaited first!");
27417 const nativeResponseValue = wasm.TS_RouteHop_set_short_channel_id(this_ptr, val);
27418 // debug statements here
27420 // struct LDKChannelFeatures RouteHop_get_channel_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
27422 export function RouteHop_get_channel_features(this_ptr: number): number {
27423 if(!isWasmInitialized) {
27424 throw new Error("initializeWasm() must be awaited first!");
27426 const nativeResponseValue = wasm.TS_RouteHop_get_channel_features(this_ptr);
27427 return nativeResponseValue;
27429 // void RouteHop_set_channel_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
27431 export function RouteHop_set_channel_features(this_ptr: number, val: number): void {
27432 if(!isWasmInitialized) {
27433 throw new Error("initializeWasm() must be awaited first!");
27435 const nativeResponseValue = wasm.TS_RouteHop_set_channel_features(this_ptr, val);
27436 // debug statements here
27438 // uint64_t RouteHop_get_fee_msat(const struct LDKRouteHop *NONNULL_PTR this_ptr);
27440 export function RouteHop_get_fee_msat(this_ptr: number): bigint {
27441 if(!isWasmInitialized) {
27442 throw new Error("initializeWasm() must be awaited first!");
27444 const nativeResponseValue = wasm.TS_RouteHop_get_fee_msat(this_ptr);
27445 return nativeResponseValue;
27447 // void RouteHop_set_fee_msat(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
27449 export function RouteHop_set_fee_msat(this_ptr: number, val: bigint): void {
27450 if(!isWasmInitialized) {
27451 throw new Error("initializeWasm() must be awaited first!");
27453 const nativeResponseValue = wasm.TS_RouteHop_set_fee_msat(this_ptr, val);
27454 // debug statements here
27456 // uint32_t RouteHop_get_cltv_expiry_delta(const struct LDKRouteHop *NONNULL_PTR this_ptr);
27458 export function RouteHop_get_cltv_expiry_delta(this_ptr: number): number {
27459 if(!isWasmInitialized) {
27460 throw new Error("initializeWasm() must be awaited first!");
27462 const nativeResponseValue = wasm.TS_RouteHop_get_cltv_expiry_delta(this_ptr);
27463 return nativeResponseValue;
27465 // void RouteHop_set_cltv_expiry_delta(struct LDKRouteHop *NONNULL_PTR this_ptr, uint32_t val);
27467 export function RouteHop_set_cltv_expiry_delta(this_ptr: number, val: number): void {
27468 if(!isWasmInitialized) {
27469 throw new Error("initializeWasm() must be awaited first!");
27471 const nativeResponseValue = wasm.TS_RouteHop_set_cltv_expiry_delta(this_ptr, val);
27472 // debug statements here
27474 // 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);
27476 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 {
27477 if(!isWasmInitialized) {
27478 throw new Error("initializeWasm() must be awaited first!");
27480 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);
27481 return nativeResponseValue;
27483 // uintptr_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg);
27485 export function RouteHop_clone_ptr(arg: number): number {
27486 if(!isWasmInitialized) {
27487 throw new Error("initializeWasm() must be awaited first!");
27489 const nativeResponseValue = wasm.TS_RouteHop_clone_ptr(arg);
27490 return nativeResponseValue;
27492 // struct LDKRouteHop RouteHop_clone(const struct LDKRouteHop *NONNULL_PTR orig);
27494 export function RouteHop_clone(orig: number): number {
27495 if(!isWasmInitialized) {
27496 throw new Error("initializeWasm() must be awaited first!");
27498 const nativeResponseValue = wasm.TS_RouteHop_clone(orig);
27499 return nativeResponseValue;
27501 // uint64_t RouteHop_hash(const struct LDKRouteHop *NONNULL_PTR o);
27503 export function RouteHop_hash(o: number): bigint {
27504 if(!isWasmInitialized) {
27505 throw new Error("initializeWasm() must be awaited first!");
27507 const nativeResponseValue = wasm.TS_RouteHop_hash(o);
27508 return nativeResponseValue;
27510 // bool RouteHop_eq(const struct LDKRouteHop *NONNULL_PTR a, const struct LDKRouteHop *NONNULL_PTR b);
27512 export function RouteHop_eq(a: number, b: number): boolean {
27513 if(!isWasmInitialized) {
27514 throw new Error("initializeWasm() must be awaited first!");
27516 const nativeResponseValue = wasm.TS_RouteHop_eq(a, b);
27517 return nativeResponseValue;
27519 // struct LDKCVec_u8Z RouteHop_write(const struct LDKRouteHop *NONNULL_PTR obj);
27521 export function RouteHop_write(obj: number): number {
27522 if(!isWasmInitialized) {
27523 throw new Error("initializeWasm() must be awaited first!");
27525 const nativeResponseValue = wasm.TS_RouteHop_write(obj);
27526 return nativeResponseValue;
27528 // struct LDKCResult_RouteHopDecodeErrorZ RouteHop_read(struct LDKu8slice ser);
27530 export function RouteHop_read(ser: number): number {
27531 if(!isWasmInitialized) {
27532 throw new Error("initializeWasm() must be awaited first!");
27534 const nativeResponseValue = wasm.TS_RouteHop_read(ser);
27535 return nativeResponseValue;
27537 // void Route_free(struct LDKRoute this_obj);
27539 export function Route_free(this_obj: number): void {
27540 if(!isWasmInitialized) {
27541 throw new Error("initializeWasm() must be awaited first!");
27543 const nativeResponseValue = wasm.TS_Route_free(this_obj);
27544 // debug statements here
27546 // struct LDKCVec_CVec_RouteHopZZ Route_get_paths(const struct LDKRoute *NONNULL_PTR this_ptr);
27548 export function Route_get_paths(this_ptr: number): number {
27549 if(!isWasmInitialized) {
27550 throw new Error("initializeWasm() must be awaited first!");
27552 const nativeResponseValue = wasm.TS_Route_get_paths(this_ptr);
27553 return nativeResponseValue;
27555 // void Route_set_paths(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKCVec_CVec_RouteHopZZ val);
27557 export function Route_set_paths(this_ptr: number, val: number): void {
27558 if(!isWasmInitialized) {
27559 throw new Error("initializeWasm() must be awaited first!");
27561 const nativeResponseValue = wasm.TS_Route_set_paths(this_ptr, val);
27562 // debug statements here
27564 // struct LDKPaymentParameters Route_get_payment_params(const struct LDKRoute *NONNULL_PTR this_ptr);
27566 export function Route_get_payment_params(this_ptr: number): number {
27567 if(!isWasmInitialized) {
27568 throw new Error("initializeWasm() must be awaited first!");
27570 const nativeResponseValue = wasm.TS_Route_get_payment_params(this_ptr);
27571 return nativeResponseValue;
27573 // void Route_set_payment_params(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
27575 export function Route_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_Route_set_payment_params(this_ptr, val);
27580 // debug statements here
27582 // MUST_USE_RES struct LDKRoute Route_new(struct LDKCVec_CVec_RouteHopZZ paths_arg, struct LDKPaymentParameters payment_params_arg);
27584 export function Route_new(paths_arg: number, payment_params_arg: number): number {
27585 if(!isWasmInitialized) {
27586 throw new Error("initializeWasm() must be awaited first!");
27588 const nativeResponseValue = wasm.TS_Route_new(paths_arg, payment_params_arg);
27589 return nativeResponseValue;
27591 // uintptr_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg);
27593 export function Route_clone_ptr(arg: number): number {
27594 if(!isWasmInitialized) {
27595 throw new Error("initializeWasm() must be awaited first!");
27597 const nativeResponseValue = wasm.TS_Route_clone_ptr(arg);
27598 return nativeResponseValue;
27600 // struct LDKRoute Route_clone(const struct LDKRoute *NONNULL_PTR orig);
27602 export function Route_clone(orig: number): number {
27603 if(!isWasmInitialized) {
27604 throw new Error("initializeWasm() must be awaited first!");
27606 const nativeResponseValue = wasm.TS_Route_clone(orig);
27607 return nativeResponseValue;
27609 // uint64_t Route_hash(const struct LDKRoute *NONNULL_PTR o);
27611 export function Route_hash(o: number): bigint {
27612 if(!isWasmInitialized) {
27613 throw new Error("initializeWasm() must be awaited first!");
27615 const nativeResponseValue = wasm.TS_Route_hash(o);
27616 return nativeResponseValue;
27618 // bool Route_eq(const struct LDKRoute *NONNULL_PTR a, const struct LDKRoute *NONNULL_PTR b);
27620 export function Route_eq(a: number, b: number): boolean {
27621 if(!isWasmInitialized) {
27622 throw new Error("initializeWasm() must be awaited first!");
27624 const nativeResponseValue = wasm.TS_Route_eq(a, b);
27625 return nativeResponseValue;
27627 // MUST_USE_RES uint64_t Route_get_total_fees(const struct LDKRoute *NONNULL_PTR this_arg);
27629 export function Route_get_total_fees(this_arg: number): bigint {
27630 if(!isWasmInitialized) {
27631 throw new Error("initializeWasm() must be awaited first!");
27633 const nativeResponseValue = wasm.TS_Route_get_total_fees(this_arg);
27634 return nativeResponseValue;
27636 // MUST_USE_RES uint64_t Route_get_total_amount(const struct LDKRoute *NONNULL_PTR this_arg);
27638 export function Route_get_total_amount(this_arg: number): bigint {
27639 if(!isWasmInitialized) {
27640 throw new Error("initializeWasm() must be awaited first!");
27642 const nativeResponseValue = wasm.TS_Route_get_total_amount(this_arg);
27643 return nativeResponseValue;
27645 // struct LDKCVec_u8Z Route_write(const struct LDKRoute *NONNULL_PTR obj);
27647 export function Route_write(obj: number): number {
27648 if(!isWasmInitialized) {
27649 throw new Error("initializeWasm() must be awaited first!");
27651 const nativeResponseValue = wasm.TS_Route_write(obj);
27652 return nativeResponseValue;
27654 // struct LDKCResult_RouteDecodeErrorZ Route_read(struct LDKu8slice ser);
27656 export function Route_read(ser: number): number {
27657 if(!isWasmInitialized) {
27658 throw new Error("initializeWasm() must be awaited first!");
27660 const nativeResponseValue = wasm.TS_Route_read(ser);
27661 return nativeResponseValue;
27663 // void RouteParameters_free(struct LDKRouteParameters this_obj);
27665 export function RouteParameters_free(this_obj: number): void {
27666 if(!isWasmInitialized) {
27667 throw new Error("initializeWasm() must be awaited first!");
27669 const nativeResponseValue = wasm.TS_RouteParameters_free(this_obj);
27670 // debug statements here
27672 // struct LDKPaymentParameters RouteParameters_get_payment_params(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
27674 export function RouteParameters_get_payment_params(this_ptr: number): number {
27675 if(!isWasmInitialized) {
27676 throw new Error("initializeWasm() must be awaited first!");
27678 const nativeResponseValue = wasm.TS_RouteParameters_get_payment_params(this_ptr);
27679 return nativeResponseValue;
27681 // void RouteParameters_set_payment_params(struct LDKRouteParameters *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
27683 export function RouteParameters_set_payment_params(this_ptr: number, val: number): void {
27684 if(!isWasmInitialized) {
27685 throw new Error("initializeWasm() must be awaited first!");
27687 const nativeResponseValue = wasm.TS_RouteParameters_set_payment_params(this_ptr, val);
27688 // debug statements here
27690 // uint64_t RouteParameters_get_final_value_msat(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
27692 export function RouteParameters_get_final_value_msat(this_ptr: number): bigint {
27693 if(!isWasmInitialized) {
27694 throw new Error("initializeWasm() must be awaited first!");
27696 const nativeResponseValue = wasm.TS_RouteParameters_get_final_value_msat(this_ptr);
27697 return nativeResponseValue;
27699 // void RouteParameters_set_final_value_msat(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint64_t val);
27701 export function RouteParameters_set_final_value_msat(this_ptr: number, val: bigint): void {
27702 if(!isWasmInitialized) {
27703 throw new Error("initializeWasm() must be awaited first!");
27705 const nativeResponseValue = wasm.TS_RouteParameters_set_final_value_msat(this_ptr, val);
27706 // debug statements here
27708 // uint32_t RouteParameters_get_final_cltv_expiry_delta(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
27710 export function RouteParameters_get_final_cltv_expiry_delta(this_ptr: number): number {
27711 if(!isWasmInitialized) {
27712 throw new Error("initializeWasm() must be awaited first!");
27714 const nativeResponseValue = wasm.TS_RouteParameters_get_final_cltv_expiry_delta(this_ptr);
27715 return nativeResponseValue;
27717 // void RouteParameters_set_final_cltv_expiry_delta(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint32_t val);
27719 export function RouteParameters_set_final_cltv_expiry_delta(this_ptr: number, val: number): void {
27720 if(!isWasmInitialized) {
27721 throw new Error("initializeWasm() must be awaited first!");
27723 const nativeResponseValue = wasm.TS_RouteParameters_set_final_cltv_expiry_delta(this_ptr, val);
27724 // debug statements here
27726 // 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);
27728 export function RouteParameters_new(payment_params_arg: number, final_value_msat_arg: bigint, final_cltv_expiry_delta_arg: number): number {
27729 if(!isWasmInitialized) {
27730 throw new Error("initializeWasm() must be awaited first!");
27732 const nativeResponseValue = wasm.TS_RouteParameters_new(payment_params_arg, final_value_msat_arg, final_cltv_expiry_delta_arg);
27733 return nativeResponseValue;
27735 // uintptr_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg);
27737 export function RouteParameters_clone_ptr(arg: number): number {
27738 if(!isWasmInitialized) {
27739 throw new Error("initializeWasm() must be awaited first!");
27741 const nativeResponseValue = wasm.TS_RouteParameters_clone_ptr(arg);
27742 return nativeResponseValue;
27744 // struct LDKRouteParameters RouteParameters_clone(const struct LDKRouteParameters *NONNULL_PTR orig);
27746 export function RouteParameters_clone(orig: number): number {
27747 if(!isWasmInitialized) {
27748 throw new Error("initializeWasm() must be awaited first!");
27750 const nativeResponseValue = wasm.TS_RouteParameters_clone(orig);
27751 return nativeResponseValue;
27753 // struct LDKCVec_u8Z RouteParameters_write(const struct LDKRouteParameters *NONNULL_PTR obj);
27755 export function RouteParameters_write(obj: number): number {
27756 if(!isWasmInitialized) {
27757 throw new Error("initializeWasm() must be awaited first!");
27759 const nativeResponseValue = wasm.TS_RouteParameters_write(obj);
27760 return nativeResponseValue;
27762 // struct LDKCResult_RouteParametersDecodeErrorZ RouteParameters_read(struct LDKu8slice ser);
27764 export function RouteParameters_read(ser: number): number {
27765 if(!isWasmInitialized) {
27766 throw new Error("initializeWasm() must be awaited first!");
27768 const nativeResponseValue = wasm.TS_RouteParameters_read(ser);
27769 return nativeResponseValue;
27771 // void PaymentParameters_free(struct LDKPaymentParameters this_obj);
27773 export function PaymentParameters_free(this_obj: number): void {
27774 if(!isWasmInitialized) {
27775 throw new Error("initializeWasm() must be awaited first!");
27777 const nativeResponseValue = wasm.TS_PaymentParameters_free(this_obj);
27778 // debug statements here
27780 // struct LDKPublicKey PaymentParameters_get_payee_pubkey(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
27782 export function PaymentParameters_get_payee_pubkey(this_ptr: number): number {
27783 if(!isWasmInitialized) {
27784 throw new Error("initializeWasm() must be awaited first!");
27786 const nativeResponseValue = wasm.TS_PaymentParameters_get_payee_pubkey(this_ptr);
27787 return nativeResponseValue;
27789 // void PaymentParameters_set_payee_pubkey(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKPublicKey val);
27791 export function PaymentParameters_set_payee_pubkey(this_ptr: number, val: number): void {
27792 if(!isWasmInitialized) {
27793 throw new Error("initializeWasm() must be awaited first!");
27795 const nativeResponseValue = wasm.TS_PaymentParameters_set_payee_pubkey(this_ptr, val);
27796 // debug statements here
27798 // struct LDKInvoiceFeatures PaymentParameters_get_features(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
27800 export function PaymentParameters_get_features(this_ptr: number): number {
27801 if(!isWasmInitialized) {
27802 throw new Error("initializeWasm() must be awaited first!");
27804 const nativeResponseValue = wasm.TS_PaymentParameters_get_features(this_ptr);
27805 return nativeResponseValue;
27807 // void PaymentParameters_set_features(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKInvoiceFeatures val);
27809 export function PaymentParameters_set_features(this_ptr: number, val: number): void {
27810 if(!isWasmInitialized) {
27811 throw new Error("initializeWasm() must be awaited first!");
27813 const nativeResponseValue = wasm.TS_PaymentParameters_set_features(this_ptr, val);
27814 // debug statements here
27816 // struct LDKCVec_RouteHintZ PaymentParameters_get_route_hints(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
27818 export function PaymentParameters_get_route_hints(this_ptr: number): number {
27819 if(!isWasmInitialized) {
27820 throw new Error("initializeWasm() must be awaited first!");
27822 const nativeResponseValue = wasm.TS_PaymentParameters_get_route_hints(this_ptr);
27823 return nativeResponseValue;
27825 // void PaymentParameters_set_route_hints(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintZ val);
27827 export function PaymentParameters_set_route_hints(this_ptr: number, val: number): void {
27828 if(!isWasmInitialized) {
27829 throw new Error("initializeWasm() must be awaited first!");
27831 const nativeResponseValue = wasm.TS_PaymentParameters_set_route_hints(this_ptr, val);
27832 // debug statements here
27834 // struct LDKCOption_u64Z PaymentParameters_get_expiry_time(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
27836 export function PaymentParameters_get_expiry_time(this_ptr: number): number {
27837 if(!isWasmInitialized) {
27838 throw new Error("initializeWasm() must be awaited first!");
27840 const nativeResponseValue = wasm.TS_PaymentParameters_get_expiry_time(this_ptr);
27841 return nativeResponseValue;
27843 // void PaymentParameters_set_expiry_time(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
27845 export function PaymentParameters_set_expiry_time(this_ptr: number, val: number): void {
27846 if(!isWasmInitialized) {
27847 throw new Error("initializeWasm() must be awaited first!");
27849 const nativeResponseValue = wasm.TS_PaymentParameters_set_expiry_time(this_ptr, val);
27850 // debug statements here
27852 // uint32_t PaymentParameters_get_max_total_cltv_expiry_delta(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
27854 export function PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr: number): number {
27855 if(!isWasmInitialized) {
27856 throw new Error("initializeWasm() must be awaited first!");
27858 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr);
27859 return nativeResponseValue;
27861 // void PaymentParameters_set_max_total_cltv_expiry_delta(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint32_t val);
27863 export function PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr: number, val: number): void {
27864 if(!isWasmInitialized) {
27865 throw new Error("initializeWasm() must be awaited first!");
27867 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr, val);
27868 // debug statements here
27870 // 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);
27872 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 {
27873 if(!isWasmInitialized) {
27874 throw new Error("initializeWasm() must be awaited first!");
27876 const nativeResponseValue = wasm.TS_PaymentParameters_new(payee_pubkey_arg, features_arg, route_hints_arg, expiry_time_arg, max_total_cltv_expiry_delta_arg);
27877 return nativeResponseValue;
27879 // uintptr_t PaymentParameters_clone_ptr(LDKPaymentParameters *NONNULL_PTR arg);
27881 export function PaymentParameters_clone_ptr(arg: number): number {
27882 if(!isWasmInitialized) {
27883 throw new Error("initializeWasm() must be awaited first!");
27885 const nativeResponseValue = wasm.TS_PaymentParameters_clone_ptr(arg);
27886 return nativeResponseValue;
27888 // struct LDKPaymentParameters PaymentParameters_clone(const struct LDKPaymentParameters *NONNULL_PTR orig);
27890 export function PaymentParameters_clone(orig: number): number {
27891 if(!isWasmInitialized) {
27892 throw new Error("initializeWasm() must be awaited first!");
27894 const nativeResponseValue = wasm.TS_PaymentParameters_clone(orig);
27895 return nativeResponseValue;
27897 // uint64_t PaymentParameters_hash(const struct LDKPaymentParameters *NONNULL_PTR o);
27899 export function PaymentParameters_hash(o: number): bigint {
27900 if(!isWasmInitialized) {
27901 throw new Error("initializeWasm() must be awaited first!");
27903 const nativeResponseValue = wasm.TS_PaymentParameters_hash(o);
27904 return nativeResponseValue;
27906 // bool PaymentParameters_eq(const struct LDKPaymentParameters *NONNULL_PTR a, const struct LDKPaymentParameters *NONNULL_PTR b);
27908 export function PaymentParameters_eq(a: number, b: number): boolean {
27909 if(!isWasmInitialized) {
27910 throw new Error("initializeWasm() must be awaited first!");
27912 const nativeResponseValue = wasm.TS_PaymentParameters_eq(a, b);
27913 return nativeResponseValue;
27915 // struct LDKCVec_u8Z PaymentParameters_write(const struct LDKPaymentParameters *NONNULL_PTR obj);
27917 export function PaymentParameters_write(obj: number): number {
27918 if(!isWasmInitialized) {
27919 throw new Error("initializeWasm() must be awaited first!");
27921 const nativeResponseValue = wasm.TS_PaymentParameters_write(obj);
27922 return nativeResponseValue;
27924 // struct LDKCResult_PaymentParametersDecodeErrorZ PaymentParameters_read(struct LDKu8slice ser);
27926 export function PaymentParameters_read(ser: number): number {
27927 if(!isWasmInitialized) {
27928 throw new Error("initializeWasm() must be awaited first!");
27930 const nativeResponseValue = wasm.TS_PaymentParameters_read(ser);
27931 return nativeResponseValue;
27933 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_from_node_id(struct LDKPublicKey payee_pubkey);
27935 export function PaymentParameters_from_node_id(payee_pubkey: number): number {
27936 if(!isWasmInitialized) {
27937 throw new Error("initializeWasm() must be awaited first!");
27939 const nativeResponseValue = wasm.TS_PaymentParameters_from_node_id(payee_pubkey);
27940 return nativeResponseValue;
27942 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_for_keysend(struct LDKPublicKey payee_pubkey);
27944 export function PaymentParameters_for_keysend(payee_pubkey: number): number {
27945 if(!isWasmInitialized) {
27946 throw new Error("initializeWasm() must be awaited first!");
27948 const nativeResponseValue = wasm.TS_PaymentParameters_for_keysend(payee_pubkey);
27949 return nativeResponseValue;
27951 // void RouteHint_free(struct LDKRouteHint this_obj);
27953 export function RouteHint_free(this_obj: number): void {
27954 if(!isWasmInitialized) {
27955 throw new Error("initializeWasm() must be awaited first!");
27957 const nativeResponseValue = wasm.TS_RouteHint_free(this_obj);
27958 // debug statements here
27960 // struct LDKCVec_RouteHintHopZ RouteHint_get_a(const struct LDKRouteHint *NONNULL_PTR this_ptr);
27962 export function RouteHint_get_a(this_ptr: number): number {
27963 if(!isWasmInitialized) {
27964 throw new Error("initializeWasm() must be awaited first!");
27966 const nativeResponseValue = wasm.TS_RouteHint_get_a(this_ptr);
27967 return nativeResponseValue;
27969 // void RouteHint_set_a(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintHopZ val);
27971 export function RouteHint_set_a(this_ptr: number, val: number): void {
27972 if(!isWasmInitialized) {
27973 throw new Error("initializeWasm() must be awaited first!");
27975 const nativeResponseValue = wasm.TS_RouteHint_set_a(this_ptr, val);
27976 // debug statements here
27978 // MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKCVec_RouteHintHopZ a_arg);
27980 export function RouteHint_new(a_arg: number): number {
27981 if(!isWasmInitialized) {
27982 throw new Error("initializeWasm() must be awaited first!");
27984 const nativeResponseValue = wasm.TS_RouteHint_new(a_arg);
27985 return nativeResponseValue;
27987 // uintptr_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg);
27989 export function RouteHint_clone_ptr(arg: number): number {
27990 if(!isWasmInitialized) {
27991 throw new Error("initializeWasm() must be awaited first!");
27993 const nativeResponseValue = wasm.TS_RouteHint_clone_ptr(arg);
27994 return nativeResponseValue;
27996 // struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
27998 export function RouteHint_clone(orig: number): number {
27999 if(!isWasmInitialized) {
28000 throw new Error("initializeWasm() must be awaited first!");
28002 const nativeResponseValue = wasm.TS_RouteHint_clone(orig);
28003 return nativeResponseValue;
28005 // uint64_t RouteHint_hash(const struct LDKRouteHint *NONNULL_PTR o);
28007 export function RouteHint_hash(o: number): bigint {
28008 if(!isWasmInitialized) {
28009 throw new Error("initializeWasm() must be awaited first!");
28011 const nativeResponseValue = wasm.TS_RouteHint_hash(o);
28012 return nativeResponseValue;
28014 // bool RouteHint_eq(const struct LDKRouteHint *NONNULL_PTR a, const struct LDKRouteHint *NONNULL_PTR b);
28016 export function RouteHint_eq(a: number, b: number): boolean {
28017 if(!isWasmInitialized) {
28018 throw new Error("initializeWasm() must be awaited first!");
28020 const nativeResponseValue = wasm.TS_RouteHint_eq(a, b);
28021 return nativeResponseValue;
28023 // struct LDKCVec_u8Z RouteHint_write(const struct LDKRouteHint *NONNULL_PTR obj);
28025 export function RouteHint_write(obj: number): number {
28026 if(!isWasmInitialized) {
28027 throw new Error("initializeWasm() must be awaited first!");
28029 const nativeResponseValue = wasm.TS_RouteHint_write(obj);
28030 return nativeResponseValue;
28032 // struct LDKCResult_RouteHintDecodeErrorZ RouteHint_read(struct LDKu8slice ser);
28034 export function RouteHint_read(ser: number): number {
28035 if(!isWasmInitialized) {
28036 throw new Error("initializeWasm() must be awaited first!");
28038 const nativeResponseValue = wasm.TS_RouteHint_read(ser);
28039 return nativeResponseValue;
28041 // void RouteHintHop_free(struct LDKRouteHintHop this_obj);
28043 export function RouteHintHop_free(this_obj: number): void {
28044 if(!isWasmInitialized) {
28045 throw new Error("initializeWasm() must be awaited first!");
28047 const nativeResponseValue = wasm.TS_RouteHintHop_free(this_obj);
28048 // debug statements here
28050 // struct LDKPublicKey RouteHintHop_get_src_node_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
28052 export function RouteHintHop_get_src_node_id(this_ptr: number): number {
28053 if(!isWasmInitialized) {
28054 throw new Error("initializeWasm() must be awaited first!");
28056 const nativeResponseValue = wasm.TS_RouteHintHop_get_src_node_id(this_ptr);
28057 return nativeResponseValue;
28059 // void RouteHintHop_set_src_node_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28061 export function RouteHintHop_set_src_node_id(this_ptr: number, val: number): void {
28062 if(!isWasmInitialized) {
28063 throw new Error("initializeWasm() must be awaited first!");
28065 const nativeResponseValue = wasm.TS_RouteHintHop_set_src_node_id(this_ptr, val);
28066 // debug statements here
28068 // uint64_t RouteHintHop_get_short_channel_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
28070 export function RouteHintHop_get_short_channel_id(this_ptr: number): bigint {
28071 if(!isWasmInitialized) {
28072 throw new Error("initializeWasm() must be awaited first!");
28074 const nativeResponseValue = wasm.TS_RouteHintHop_get_short_channel_id(this_ptr);
28075 return nativeResponseValue;
28077 // void RouteHintHop_set_short_channel_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint64_t val);
28079 export function RouteHintHop_set_short_channel_id(this_ptr: number, val: bigint): void {
28080 if(!isWasmInitialized) {
28081 throw new Error("initializeWasm() must be awaited first!");
28083 const nativeResponseValue = wasm.TS_RouteHintHop_set_short_channel_id(this_ptr, val);
28084 // debug statements here
28086 // struct LDKRoutingFees RouteHintHop_get_fees(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
28088 export function RouteHintHop_get_fees(this_ptr: number): number {
28089 if(!isWasmInitialized) {
28090 throw new Error("initializeWasm() must be awaited first!");
28092 const nativeResponseValue = wasm.TS_RouteHintHop_get_fees(this_ptr);
28093 return nativeResponseValue;
28095 // void RouteHintHop_set_fees(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
28097 export function RouteHintHop_set_fees(this_ptr: number, val: number): void {
28098 if(!isWasmInitialized) {
28099 throw new Error("initializeWasm() must be awaited first!");
28101 const nativeResponseValue = wasm.TS_RouteHintHop_set_fees(this_ptr, val);
28102 // debug statements here
28104 // uint16_t RouteHintHop_get_cltv_expiry_delta(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
28106 export function RouteHintHop_get_cltv_expiry_delta(this_ptr: number): number {
28107 if(!isWasmInitialized) {
28108 throw new Error("initializeWasm() must be awaited first!");
28110 const nativeResponseValue = wasm.TS_RouteHintHop_get_cltv_expiry_delta(this_ptr);
28111 return nativeResponseValue;
28113 // void RouteHintHop_set_cltv_expiry_delta(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint16_t val);
28115 export function RouteHintHop_set_cltv_expiry_delta(this_ptr: number, val: number): void {
28116 if(!isWasmInitialized) {
28117 throw new Error("initializeWasm() must be awaited first!");
28119 const nativeResponseValue = wasm.TS_RouteHintHop_set_cltv_expiry_delta(this_ptr, val);
28120 // debug statements here
28122 // struct LDKCOption_u64Z RouteHintHop_get_htlc_minimum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
28124 export function RouteHintHop_get_htlc_minimum_msat(this_ptr: number): number {
28125 if(!isWasmInitialized) {
28126 throw new Error("initializeWasm() must be awaited first!");
28128 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_minimum_msat(this_ptr);
28129 return nativeResponseValue;
28131 // void RouteHintHop_set_htlc_minimum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
28133 export function RouteHintHop_set_htlc_minimum_msat(this_ptr: number, val: number): void {
28134 if(!isWasmInitialized) {
28135 throw new Error("initializeWasm() must be awaited first!");
28137 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_minimum_msat(this_ptr, val);
28138 // debug statements here
28140 // struct LDKCOption_u64Z RouteHintHop_get_htlc_maximum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
28142 export function RouteHintHop_get_htlc_maximum_msat(this_ptr: number): number {
28143 if(!isWasmInitialized) {
28144 throw new Error("initializeWasm() must be awaited first!");
28146 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_maximum_msat(this_ptr);
28147 return nativeResponseValue;
28149 // void RouteHintHop_set_htlc_maximum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
28151 export function RouteHintHop_set_htlc_maximum_msat(this_ptr: number, val: number): void {
28152 if(!isWasmInitialized) {
28153 throw new Error("initializeWasm() must be awaited first!");
28155 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_maximum_msat(this_ptr, val);
28156 // debug statements here
28158 // 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);
28160 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 {
28161 if(!isWasmInitialized) {
28162 throw new Error("initializeWasm() must be awaited first!");
28164 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);
28165 return nativeResponseValue;
28167 // uintptr_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg);
28169 export function RouteHintHop_clone_ptr(arg: number): number {
28170 if(!isWasmInitialized) {
28171 throw new Error("initializeWasm() must be awaited first!");
28173 const nativeResponseValue = wasm.TS_RouteHintHop_clone_ptr(arg);
28174 return nativeResponseValue;
28176 // struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
28178 export function RouteHintHop_clone(orig: number): number {
28179 if(!isWasmInitialized) {
28180 throw new Error("initializeWasm() must be awaited first!");
28182 const nativeResponseValue = wasm.TS_RouteHintHop_clone(orig);
28183 return nativeResponseValue;
28185 // uint64_t RouteHintHop_hash(const struct LDKRouteHintHop *NONNULL_PTR o);
28187 export function RouteHintHop_hash(o: number): bigint {
28188 if(!isWasmInitialized) {
28189 throw new Error("initializeWasm() must be awaited first!");
28191 const nativeResponseValue = wasm.TS_RouteHintHop_hash(o);
28192 return nativeResponseValue;
28194 // bool RouteHintHop_eq(const struct LDKRouteHintHop *NONNULL_PTR a, const struct LDKRouteHintHop *NONNULL_PTR b);
28196 export function RouteHintHop_eq(a: number, b: number): boolean {
28197 if(!isWasmInitialized) {
28198 throw new Error("initializeWasm() must be awaited first!");
28200 const nativeResponseValue = wasm.TS_RouteHintHop_eq(a, b);
28201 return nativeResponseValue;
28203 // struct LDKCVec_u8Z RouteHintHop_write(const struct LDKRouteHintHop *NONNULL_PTR obj);
28205 export function RouteHintHop_write(obj: number): number {
28206 if(!isWasmInitialized) {
28207 throw new Error("initializeWasm() must be awaited first!");
28209 const nativeResponseValue = wasm.TS_RouteHintHop_write(obj);
28210 return nativeResponseValue;
28212 // struct LDKCResult_RouteHintHopDecodeErrorZ RouteHintHop_read(struct LDKu8slice ser);
28214 export function RouteHintHop_read(ser: number): number {
28215 if(!isWasmInitialized) {
28216 throw new Error("initializeWasm() must be awaited first!");
28218 const nativeResponseValue = wasm.TS_RouteHintHop_read(ser);
28219 return nativeResponseValue;
28221 // 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);
28223 export function find_route(our_node_pubkey: number, route_params: number, network: number, first_hops: number, logger: number, scorer: number): number {
28224 if(!isWasmInitialized) {
28225 throw new Error("initializeWasm() must be awaited first!");
28227 const nativeResponseValue = wasm.TS_find_route(our_node_pubkey, route_params, network, first_hops, logger, scorer);
28228 return nativeResponseValue;
28230 // void Score_free(struct LDKScore this_ptr);
28232 export function Score_free(this_ptr: number): void {
28233 if(!isWasmInitialized) {
28234 throw new Error("initializeWasm() must be awaited first!");
28236 const nativeResponseValue = wasm.TS_Score_free(this_ptr);
28237 // debug statements here
28239 // void LockableScore_free(struct LDKLockableScore this_ptr);
28241 export function LockableScore_free(this_ptr: number): void {
28242 if(!isWasmInitialized) {
28243 throw new Error("initializeWasm() must be awaited first!");
28245 const nativeResponseValue = wasm.TS_LockableScore_free(this_ptr);
28246 // debug statements here
28248 // void MultiThreadedLockableScore_free(struct LDKMultiThreadedLockableScore this_obj);
28250 export function MultiThreadedLockableScore_free(this_obj: number): void {
28251 if(!isWasmInitialized) {
28252 throw new Error("initializeWasm() must be awaited first!");
28254 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_free(this_obj);
28255 // debug statements here
28257 // MUST_USE_RES struct LDKMultiThreadedLockableScore MultiThreadedLockableScore_new(struct LDKScore score);
28259 export function MultiThreadedLockableScore_new(score: number): number {
28260 if(!isWasmInitialized) {
28261 throw new Error("initializeWasm() must be awaited first!");
28263 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_new(score);
28264 return nativeResponseValue;
28266 // void FixedPenaltyScorer_free(struct LDKFixedPenaltyScorer this_obj);
28268 export function FixedPenaltyScorer_free(this_obj: number): void {
28269 if(!isWasmInitialized) {
28270 throw new Error("initializeWasm() must be awaited first!");
28272 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_free(this_obj);
28273 // debug statements here
28275 // uintptr_t FixedPenaltyScorer_clone_ptr(LDKFixedPenaltyScorer *NONNULL_PTR arg);
28277 export function FixedPenaltyScorer_clone_ptr(arg: number): number {
28278 if(!isWasmInitialized) {
28279 throw new Error("initializeWasm() must be awaited first!");
28281 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone_ptr(arg);
28282 return nativeResponseValue;
28284 // struct LDKFixedPenaltyScorer FixedPenaltyScorer_clone(const struct LDKFixedPenaltyScorer *NONNULL_PTR orig);
28286 export function FixedPenaltyScorer_clone(orig: number): number {
28287 if(!isWasmInitialized) {
28288 throw new Error("initializeWasm() must be awaited first!");
28290 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone(orig);
28291 return nativeResponseValue;
28293 // struct LDKCVec_u8Z FixedPenaltyScorer_write(const struct LDKFixedPenaltyScorer *NONNULL_PTR obj);
28295 export function FixedPenaltyScorer_write(obj: number): number {
28296 if(!isWasmInitialized) {
28297 throw new Error("initializeWasm() must be awaited first!");
28299 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_write(obj);
28300 return nativeResponseValue;
28302 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ FixedPenaltyScorer_read(struct LDKu8slice ser);
28304 export function FixedPenaltyScorer_read(ser: number): number {
28305 if(!isWasmInitialized) {
28306 throw new Error("initializeWasm() must be awaited first!");
28308 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_read(ser);
28309 return nativeResponseValue;
28311 // MUST_USE_RES struct LDKFixedPenaltyScorer FixedPenaltyScorer_with_penalty(uint64_t penalty_msat);
28313 export function FixedPenaltyScorer_with_penalty(penalty_msat: bigint): number {
28314 if(!isWasmInitialized) {
28315 throw new Error("initializeWasm() must be awaited first!");
28317 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_with_penalty(penalty_msat);
28318 return nativeResponseValue;
28320 // struct LDKScore FixedPenaltyScorer_as_Score(const struct LDKFixedPenaltyScorer *NONNULL_PTR this_arg);
28322 export function FixedPenaltyScorer_as_Score(this_arg: number): number {
28323 if(!isWasmInitialized) {
28324 throw new Error("initializeWasm() must be awaited first!");
28326 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_as_Score(this_arg);
28327 return nativeResponseValue;
28329 // void Scorer_free(struct LDKScorer this_obj);
28331 export function Scorer_free(this_obj: number): void {
28332 if(!isWasmInitialized) {
28333 throw new Error("initializeWasm() must be awaited first!");
28335 const nativeResponseValue = wasm.TS_Scorer_free(this_obj);
28336 // debug statements here
28338 // void ScoringParameters_free(struct LDKScoringParameters this_obj);
28340 export function ScoringParameters_free(this_obj: number): void {
28341 if(!isWasmInitialized) {
28342 throw new Error("initializeWasm() must be awaited first!");
28344 const nativeResponseValue = wasm.TS_ScoringParameters_free(this_obj);
28345 // debug statements here
28347 // uint64_t ScoringParameters_get_base_penalty_msat(const struct LDKScoringParameters *NONNULL_PTR this_ptr);
28349 export function ScoringParameters_get_base_penalty_msat(this_ptr: number): bigint {
28350 if(!isWasmInitialized) {
28351 throw new Error("initializeWasm() must be awaited first!");
28353 const nativeResponseValue = wasm.TS_ScoringParameters_get_base_penalty_msat(this_ptr);
28354 return nativeResponseValue;
28356 // void ScoringParameters_set_base_penalty_msat(struct LDKScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
28358 export function ScoringParameters_set_base_penalty_msat(this_ptr: number, val: bigint): void {
28359 if(!isWasmInitialized) {
28360 throw new Error("initializeWasm() must be awaited first!");
28362 const nativeResponseValue = wasm.TS_ScoringParameters_set_base_penalty_msat(this_ptr, val);
28363 // debug statements here
28365 // uint64_t ScoringParameters_get_failure_penalty_msat(const struct LDKScoringParameters *NONNULL_PTR this_ptr);
28367 export function ScoringParameters_get_failure_penalty_msat(this_ptr: number): bigint {
28368 if(!isWasmInitialized) {
28369 throw new Error("initializeWasm() must be awaited first!");
28371 const nativeResponseValue = wasm.TS_ScoringParameters_get_failure_penalty_msat(this_ptr);
28372 return nativeResponseValue;
28374 // void ScoringParameters_set_failure_penalty_msat(struct LDKScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
28376 export function ScoringParameters_set_failure_penalty_msat(this_ptr: number, val: bigint): void {
28377 if(!isWasmInitialized) {
28378 throw new Error("initializeWasm() must be awaited first!");
28380 const nativeResponseValue = wasm.TS_ScoringParameters_set_failure_penalty_msat(this_ptr, val);
28381 // debug statements here
28383 // uint16_t ScoringParameters_get_overuse_penalty_start_1024th(const struct LDKScoringParameters *NONNULL_PTR this_ptr);
28385 export function ScoringParameters_get_overuse_penalty_start_1024th(this_ptr: number): number {
28386 if(!isWasmInitialized) {
28387 throw new Error("initializeWasm() must be awaited first!");
28389 const nativeResponseValue = wasm.TS_ScoringParameters_get_overuse_penalty_start_1024th(this_ptr);
28390 return nativeResponseValue;
28392 // void ScoringParameters_set_overuse_penalty_start_1024th(struct LDKScoringParameters *NONNULL_PTR this_ptr, uint16_t val);
28394 export function ScoringParameters_set_overuse_penalty_start_1024th(this_ptr: number, val: number): void {
28395 if(!isWasmInitialized) {
28396 throw new Error("initializeWasm() must be awaited first!");
28398 const nativeResponseValue = wasm.TS_ScoringParameters_set_overuse_penalty_start_1024th(this_ptr, val);
28399 // debug statements here
28401 // uint64_t ScoringParameters_get_overuse_penalty_msat_per_1024th(const struct LDKScoringParameters *NONNULL_PTR this_ptr);
28403 export function ScoringParameters_get_overuse_penalty_msat_per_1024th(this_ptr: number): bigint {
28404 if(!isWasmInitialized) {
28405 throw new Error("initializeWasm() must be awaited first!");
28407 const nativeResponseValue = wasm.TS_ScoringParameters_get_overuse_penalty_msat_per_1024th(this_ptr);
28408 return nativeResponseValue;
28410 // void ScoringParameters_set_overuse_penalty_msat_per_1024th(struct LDKScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
28412 export function ScoringParameters_set_overuse_penalty_msat_per_1024th(this_ptr: number, val: bigint): void {
28413 if(!isWasmInitialized) {
28414 throw new Error("initializeWasm() must be awaited first!");
28416 const nativeResponseValue = wasm.TS_ScoringParameters_set_overuse_penalty_msat_per_1024th(this_ptr, val);
28417 // debug statements here
28419 // uint64_t ScoringParameters_get_failure_penalty_half_life(const struct LDKScoringParameters *NONNULL_PTR this_ptr);
28421 export function ScoringParameters_get_failure_penalty_half_life(this_ptr: number): bigint {
28422 if(!isWasmInitialized) {
28423 throw new Error("initializeWasm() must be awaited first!");
28425 const nativeResponseValue = wasm.TS_ScoringParameters_get_failure_penalty_half_life(this_ptr);
28426 return nativeResponseValue;
28428 // void ScoringParameters_set_failure_penalty_half_life(struct LDKScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
28430 export function ScoringParameters_set_failure_penalty_half_life(this_ptr: number, val: bigint): void {
28431 if(!isWasmInitialized) {
28432 throw new Error("initializeWasm() must be awaited first!");
28434 const nativeResponseValue = wasm.TS_ScoringParameters_set_failure_penalty_half_life(this_ptr, val);
28435 // debug statements here
28437 // 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);
28439 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 {
28440 if(!isWasmInitialized) {
28441 throw new Error("initializeWasm() must be awaited first!");
28443 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);
28444 return nativeResponseValue;
28446 // uintptr_t ScoringParameters_clone_ptr(LDKScoringParameters *NONNULL_PTR arg);
28448 export function ScoringParameters_clone_ptr(arg: number): number {
28449 if(!isWasmInitialized) {
28450 throw new Error("initializeWasm() must be awaited first!");
28452 const nativeResponseValue = wasm.TS_ScoringParameters_clone_ptr(arg);
28453 return nativeResponseValue;
28455 // struct LDKScoringParameters ScoringParameters_clone(const struct LDKScoringParameters *NONNULL_PTR orig);
28457 export function ScoringParameters_clone(orig: number): number {
28458 if(!isWasmInitialized) {
28459 throw new Error("initializeWasm() must be awaited first!");
28461 const nativeResponseValue = wasm.TS_ScoringParameters_clone(orig);
28462 return nativeResponseValue;
28464 // struct LDKCVec_u8Z ScoringParameters_write(const struct LDKScoringParameters *NONNULL_PTR obj);
28466 export function ScoringParameters_write(obj: number): number {
28467 if(!isWasmInitialized) {
28468 throw new Error("initializeWasm() must be awaited first!");
28470 const nativeResponseValue = wasm.TS_ScoringParameters_write(obj);
28471 return nativeResponseValue;
28473 // struct LDKCResult_ScoringParametersDecodeErrorZ ScoringParameters_read(struct LDKu8slice ser);
28475 export function ScoringParameters_read(ser: number): number {
28476 if(!isWasmInitialized) {
28477 throw new Error("initializeWasm() must be awaited first!");
28479 const nativeResponseValue = wasm.TS_ScoringParameters_read(ser);
28480 return nativeResponseValue;
28482 // MUST_USE_RES struct LDKScorer Scorer_new(struct LDKScoringParameters params);
28484 export function Scorer_new(params: number): number {
28485 if(!isWasmInitialized) {
28486 throw new Error("initializeWasm() must be awaited first!");
28488 const nativeResponseValue = wasm.TS_Scorer_new(params);
28489 return nativeResponseValue;
28491 // MUST_USE_RES struct LDKScorer Scorer_default(void);
28493 export function Scorer_default(): number {
28494 if(!isWasmInitialized) {
28495 throw new Error("initializeWasm() must be awaited first!");
28497 const nativeResponseValue = wasm.TS_Scorer_default();
28498 return nativeResponseValue;
28500 // MUST_USE_RES struct LDKScoringParameters ScoringParameters_default(void);
28502 export function ScoringParameters_default(): number {
28503 if(!isWasmInitialized) {
28504 throw new Error("initializeWasm() must be awaited first!");
28506 const nativeResponseValue = wasm.TS_ScoringParameters_default();
28507 return nativeResponseValue;
28509 // struct LDKScore Scorer_as_Score(const struct LDKScorer *NONNULL_PTR this_arg);
28511 export function Scorer_as_Score(this_arg: number): number {
28512 if(!isWasmInitialized) {
28513 throw new Error("initializeWasm() must be awaited first!");
28515 const nativeResponseValue = wasm.TS_Scorer_as_Score(this_arg);
28516 return nativeResponseValue;
28518 // struct LDKCVec_u8Z Scorer_write(const struct LDKScorer *NONNULL_PTR obj);
28520 export function Scorer_write(obj: number): number {
28521 if(!isWasmInitialized) {
28522 throw new Error("initializeWasm() must be awaited first!");
28524 const nativeResponseValue = wasm.TS_Scorer_write(obj);
28525 return nativeResponseValue;
28527 // struct LDKCResult_ScorerDecodeErrorZ Scorer_read(struct LDKu8slice ser);
28529 export function Scorer_read(ser: number): number {
28530 if(!isWasmInitialized) {
28531 throw new Error("initializeWasm() must be awaited first!");
28533 const nativeResponseValue = wasm.TS_Scorer_read(ser);
28534 return nativeResponseValue;
28536 // void ProbabilisticScorer_free(struct LDKProbabilisticScorer this_obj);
28538 export function ProbabilisticScorer_free(this_obj: number): void {
28539 if(!isWasmInitialized) {
28540 throw new Error("initializeWasm() must be awaited first!");
28542 const nativeResponseValue = wasm.TS_ProbabilisticScorer_free(this_obj);
28543 // debug statements here
28545 // void ProbabilisticScoringParameters_free(struct LDKProbabilisticScoringParameters this_obj);
28547 export function ProbabilisticScoringParameters_free(this_obj: number): void {
28548 if(!isWasmInitialized) {
28549 throw new Error("initializeWasm() must be awaited first!");
28551 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_free(this_obj);
28552 // debug statements here
28554 // uint64_t ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
28556 export function ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr: number): bigint {
28557 if(!isWasmInitialized) {
28558 throw new Error("initializeWasm() must be awaited first!");
28560 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr);
28561 return nativeResponseValue;
28563 // void ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
28565 export function ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr: number, val: bigint): void {
28566 if(!isWasmInitialized) {
28567 throw new Error("initializeWasm() must be awaited first!");
28569 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr, val);
28570 // debug statements here
28572 // uint64_t ProbabilisticScoringParameters_get_liquidity_offset_half_life(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
28574 export function ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr: number): bigint {
28575 if(!isWasmInitialized) {
28576 throw new Error("initializeWasm() must be awaited first!");
28578 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr);
28579 return nativeResponseValue;
28581 // void ProbabilisticScoringParameters_set_liquidity_offset_half_life(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
28583 export function ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr: number, val: bigint): void {
28584 if(!isWasmInitialized) {
28585 throw new Error("initializeWasm() must be awaited first!");
28587 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr, val);
28588 // debug statements here
28590 // MUST_USE_RES struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_new(uint64_t liquidity_penalty_multiplier_msat_arg, uint64_t liquidity_offset_half_life_arg);
28592 export function ProbabilisticScoringParameters_new(liquidity_penalty_multiplier_msat_arg: bigint, liquidity_offset_half_life_arg: bigint): number {
28593 if(!isWasmInitialized) {
28594 throw new Error("initializeWasm() must be awaited first!");
28596 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_new(liquidity_penalty_multiplier_msat_arg, liquidity_offset_half_life_arg);
28597 return nativeResponseValue;
28599 // uintptr_t ProbabilisticScoringParameters_clone_ptr(LDKProbabilisticScoringParameters *NONNULL_PTR arg);
28601 export function ProbabilisticScoringParameters_clone_ptr(arg: number): number {
28602 if(!isWasmInitialized) {
28603 throw new Error("initializeWasm() must be awaited first!");
28605 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone_ptr(arg);
28606 return nativeResponseValue;
28608 // struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_clone(const struct LDKProbabilisticScoringParameters *NONNULL_PTR orig);
28610 export function ProbabilisticScoringParameters_clone(orig: number): number {
28611 if(!isWasmInitialized) {
28612 throw new Error("initializeWasm() must be awaited first!");
28614 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone(orig);
28615 return nativeResponseValue;
28617 // struct LDKCVec_u8Z ProbabilisticScoringParameters_write(const struct LDKProbabilisticScoringParameters *NONNULL_PTR obj);
28619 export function ProbabilisticScoringParameters_write(obj: number): number {
28620 if(!isWasmInitialized) {
28621 throw new Error("initializeWasm() must be awaited first!");
28623 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_write(obj);
28624 return nativeResponseValue;
28626 // struct LDKCResult_ProbabilisticScoringParametersDecodeErrorZ ProbabilisticScoringParameters_read(struct LDKu8slice ser);
28628 export function ProbabilisticScoringParameters_read(ser: number): number {
28629 if(!isWasmInitialized) {
28630 throw new Error("initializeWasm() must be awaited first!");
28632 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_read(ser);
28633 return nativeResponseValue;
28635 // MUST_USE_RES struct LDKProbabilisticScorer ProbabilisticScorer_new(struct LDKProbabilisticScoringParameters params, const struct LDKNetworkGraph *NONNULL_PTR network_graph);
28637 export function ProbabilisticScorer_new(params: number, network_graph: number): number {
28638 if(!isWasmInitialized) {
28639 throw new Error("initializeWasm() must be awaited first!");
28641 const nativeResponseValue = wasm.TS_ProbabilisticScorer_new(params, network_graph);
28642 return nativeResponseValue;
28644 // MUST_USE_RES struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_default(void);
28646 export function ProbabilisticScoringParameters_default(): number {
28647 if(!isWasmInitialized) {
28648 throw new Error("initializeWasm() must be awaited first!");
28650 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_default();
28651 return nativeResponseValue;
28653 // struct LDKScore ProbabilisticScorer_as_Score(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
28655 export function ProbabilisticScorer_as_Score(this_arg: number): number {
28656 if(!isWasmInitialized) {
28657 throw new Error("initializeWasm() must be awaited first!");
28659 const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_Score(this_arg);
28660 return nativeResponseValue;
28662 // struct LDKCVec_u8Z ProbabilisticScorer_write(const struct LDKProbabilisticScorer *NONNULL_PTR obj);
28664 export function ProbabilisticScorer_write(obj: number): number {
28665 if(!isWasmInitialized) {
28666 throw new Error("initializeWasm() must be awaited first!");
28668 const nativeResponseValue = wasm.TS_ProbabilisticScorer_write(obj);
28669 return nativeResponseValue;
28671 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ ProbabilisticScorer_read(struct LDKu8slice ser, struct LDKC2Tuple_ProbabilisticScoringParametersNetworkGraphZ arg);
28673 export function ProbabilisticScorer_read(ser: number, arg: number): number {
28674 if(!isWasmInitialized) {
28675 throw new Error("initializeWasm() must be awaited first!");
28677 const nativeResponseValue = wasm.TS_ProbabilisticScorer_read(ser, arg);
28678 return nativeResponseValue;
28680 // void Invoice_free(struct LDKInvoice this_obj);
28682 export function Invoice_free(this_obj: number): void {
28683 if(!isWasmInitialized) {
28684 throw new Error("initializeWasm() must be awaited first!");
28686 const nativeResponseValue = wasm.TS_Invoice_free(this_obj);
28687 // debug statements here
28689 // bool Invoice_eq(const struct LDKInvoice *NONNULL_PTR a, const struct LDKInvoice *NONNULL_PTR b);
28691 export function Invoice_eq(a: number, b: number): boolean {
28692 if(!isWasmInitialized) {
28693 throw new Error("initializeWasm() must be awaited first!");
28695 const nativeResponseValue = wasm.TS_Invoice_eq(a, b);
28696 return nativeResponseValue;
28698 // uintptr_t Invoice_clone_ptr(LDKInvoice *NONNULL_PTR arg);
28700 export function Invoice_clone_ptr(arg: number): number {
28701 if(!isWasmInitialized) {
28702 throw new Error("initializeWasm() must be awaited first!");
28704 const nativeResponseValue = wasm.TS_Invoice_clone_ptr(arg);
28705 return nativeResponseValue;
28707 // struct LDKInvoice Invoice_clone(const struct LDKInvoice *NONNULL_PTR orig);
28709 export function Invoice_clone(orig: number): number {
28710 if(!isWasmInitialized) {
28711 throw new Error("initializeWasm() must be awaited first!");
28713 const nativeResponseValue = wasm.TS_Invoice_clone(orig);
28714 return nativeResponseValue;
28716 // void SignedRawInvoice_free(struct LDKSignedRawInvoice this_obj);
28718 export function SignedRawInvoice_free(this_obj: number): void {
28719 if(!isWasmInitialized) {
28720 throw new Error("initializeWasm() must be awaited first!");
28722 const nativeResponseValue = wasm.TS_SignedRawInvoice_free(this_obj);
28723 // debug statements here
28725 // bool SignedRawInvoice_eq(const struct LDKSignedRawInvoice *NONNULL_PTR a, const struct LDKSignedRawInvoice *NONNULL_PTR b);
28727 export function SignedRawInvoice_eq(a: number, b: number): boolean {
28728 if(!isWasmInitialized) {
28729 throw new Error("initializeWasm() must be awaited first!");
28731 const nativeResponseValue = wasm.TS_SignedRawInvoice_eq(a, b);
28732 return nativeResponseValue;
28734 // uintptr_t SignedRawInvoice_clone_ptr(LDKSignedRawInvoice *NONNULL_PTR arg);
28736 export function SignedRawInvoice_clone_ptr(arg: number): number {
28737 if(!isWasmInitialized) {
28738 throw new Error("initializeWasm() must be awaited first!");
28740 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone_ptr(arg);
28741 return nativeResponseValue;
28743 // struct LDKSignedRawInvoice SignedRawInvoice_clone(const struct LDKSignedRawInvoice *NONNULL_PTR orig);
28745 export function SignedRawInvoice_clone(orig: number): number {
28746 if(!isWasmInitialized) {
28747 throw new Error("initializeWasm() must be awaited first!");
28749 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone(orig);
28750 return nativeResponseValue;
28752 // void RawInvoice_free(struct LDKRawInvoice this_obj);
28754 export function RawInvoice_free(this_obj: number): void {
28755 if(!isWasmInitialized) {
28756 throw new Error("initializeWasm() must be awaited first!");
28758 const nativeResponseValue = wasm.TS_RawInvoice_free(this_obj);
28759 // debug statements here
28761 // struct LDKRawDataPart RawInvoice_get_data(const struct LDKRawInvoice *NONNULL_PTR this_ptr);
28763 export function RawInvoice_get_data(this_ptr: number): number {
28764 if(!isWasmInitialized) {
28765 throw new Error("initializeWasm() must be awaited first!");
28767 const nativeResponseValue = wasm.TS_RawInvoice_get_data(this_ptr);
28768 return nativeResponseValue;
28770 // void RawInvoice_set_data(struct LDKRawInvoice *NONNULL_PTR this_ptr, struct LDKRawDataPart val);
28772 export function RawInvoice_set_data(this_ptr: number, val: number): void {
28773 if(!isWasmInitialized) {
28774 throw new Error("initializeWasm() must be awaited first!");
28776 const nativeResponseValue = wasm.TS_RawInvoice_set_data(this_ptr, val);
28777 // debug statements here
28779 // bool RawInvoice_eq(const struct LDKRawInvoice *NONNULL_PTR a, const struct LDKRawInvoice *NONNULL_PTR b);
28781 export function RawInvoice_eq(a: number, b: number): boolean {
28782 if(!isWasmInitialized) {
28783 throw new Error("initializeWasm() must be awaited first!");
28785 const nativeResponseValue = wasm.TS_RawInvoice_eq(a, b);
28786 return nativeResponseValue;
28788 // uintptr_t RawInvoice_clone_ptr(LDKRawInvoice *NONNULL_PTR arg);
28790 export function RawInvoice_clone_ptr(arg: number): number {
28791 if(!isWasmInitialized) {
28792 throw new Error("initializeWasm() must be awaited first!");
28794 const nativeResponseValue = wasm.TS_RawInvoice_clone_ptr(arg);
28795 return nativeResponseValue;
28797 // struct LDKRawInvoice RawInvoice_clone(const struct LDKRawInvoice *NONNULL_PTR orig);
28799 export function RawInvoice_clone(orig: number): number {
28800 if(!isWasmInitialized) {
28801 throw new Error("initializeWasm() must be awaited first!");
28803 const nativeResponseValue = wasm.TS_RawInvoice_clone(orig);
28804 return nativeResponseValue;
28806 // void RawDataPart_free(struct LDKRawDataPart this_obj);
28808 export function RawDataPart_free(this_obj: number): void {
28809 if(!isWasmInitialized) {
28810 throw new Error("initializeWasm() must be awaited first!");
28812 const nativeResponseValue = wasm.TS_RawDataPart_free(this_obj);
28813 // debug statements here
28815 // struct LDKPositiveTimestamp RawDataPart_get_timestamp(const struct LDKRawDataPart *NONNULL_PTR this_ptr);
28817 export function RawDataPart_get_timestamp(this_ptr: number): number {
28818 if(!isWasmInitialized) {
28819 throw new Error("initializeWasm() must be awaited first!");
28821 const nativeResponseValue = wasm.TS_RawDataPart_get_timestamp(this_ptr);
28822 return nativeResponseValue;
28824 // void RawDataPart_set_timestamp(struct LDKRawDataPart *NONNULL_PTR this_ptr, struct LDKPositiveTimestamp val);
28826 export function RawDataPart_set_timestamp(this_ptr: number, val: number): void {
28827 if(!isWasmInitialized) {
28828 throw new Error("initializeWasm() must be awaited first!");
28830 const nativeResponseValue = wasm.TS_RawDataPart_set_timestamp(this_ptr, val);
28831 // debug statements here
28833 // bool RawDataPart_eq(const struct LDKRawDataPart *NONNULL_PTR a, const struct LDKRawDataPart *NONNULL_PTR b);
28835 export function RawDataPart_eq(a: number, b: number): boolean {
28836 if(!isWasmInitialized) {
28837 throw new Error("initializeWasm() must be awaited first!");
28839 const nativeResponseValue = wasm.TS_RawDataPart_eq(a, b);
28840 return nativeResponseValue;
28842 // uintptr_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg);
28844 export function RawDataPart_clone_ptr(arg: number): number {
28845 if(!isWasmInitialized) {
28846 throw new Error("initializeWasm() must be awaited first!");
28848 const nativeResponseValue = wasm.TS_RawDataPart_clone_ptr(arg);
28849 return nativeResponseValue;
28851 // struct LDKRawDataPart RawDataPart_clone(const struct LDKRawDataPart *NONNULL_PTR orig);
28853 export function RawDataPart_clone(orig: number): number {
28854 if(!isWasmInitialized) {
28855 throw new Error("initializeWasm() must be awaited first!");
28857 const nativeResponseValue = wasm.TS_RawDataPart_clone(orig);
28858 return nativeResponseValue;
28860 // void PositiveTimestamp_free(struct LDKPositiveTimestamp this_obj);
28862 export function PositiveTimestamp_free(this_obj: number): void {
28863 if(!isWasmInitialized) {
28864 throw new Error("initializeWasm() must be awaited first!");
28866 const nativeResponseValue = wasm.TS_PositiveTimestamp_free(this_obj);
28867 // debug statements here
28869 // bool PositiveTimestamp_eq(const struct LDKPositiveTimestamp *NONNULL_PTR a, const struct LDKPositiveTimestamp *NONNULL_PTR b);
28871 export function PositiveTimestamp_eq(a: number, b: number): boolean {
28872 if(!isWasmInitialized) {
28873 throw new Error("initializeWasm() must be awaited first!");
28875 const nativeResponseValue = wasm.TS_PositiveTimestamp_eq(a, b);
28876 return nativeResponseValue;
28878 // uintptr_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg);
28880 export function PositiveTimestamp_clone_ptr(arg: number): number {
28881 if(!isWasmInitialized) {
28882 throw new Error("initializeWasm() must be awaited first!");
28884 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone_ptr(arg);
28885 return nativeResponseValue;
28887 // struct LDKPositiveTimestamp PositiveTimestamp_clone(const struct LDKPositiveTimestamp *NONNULL_PTR orig);
28889 export function PositiveTimestamp_clone(orig: number): number {
28890 if(!isWasmInitialized) {
28891 throw new Error("initializeWasm() must be awaited first!");
28893 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone(orig);
28894 return nativeResponseValue;
28896 // enum LDKSiPrefix SiPrefix_clone(const enum LDKSiPrefix *NONNULL_PTR orig);
28898 export function SiPrefix_clone(orig: number): SiPrefix {
28899 if(!isWasmInitialized) {
28900 throw new Error("initializeWasm() must be awaited first!");
28902 const nativeResponseValue = wasm.TS_SiPrefix_clone(orig);
28903 return nativeResponseValue;
28905 // enum LDKSiPrefix SiPrefix_milli(void);
28907 export function SiPrefix_milli(): SiPrefix {
28908 if(!isWasmInitialized) {
28909 throw new Error("initializeWasm() must be awaited first!");
28911 const nativeResponseValue = wasm.TS_SiPrefix_milli();
28912 return nativeResponseValue;
28914 // enum LDKSiPrefix SiPrefix_micro(void);
28916 export function SiPrefix_micro(): SiPrefix {
28917 if(!isWasmInitialized) {
28918 throw new Error("initializeWasm() must be awaited first!");
28920 const nativeResponseValue = wasm.TS_SiPrefix_micro();
28921 return nativeResponseValue;
28923 // enum LDKSiPrefix SiPrefix_nano(void);
28925 export function SiPrefix_nano(): SiPrefix {
28926 if(!isWasmInitialized) {
28927 throw new Error("initializeWasm() must be awaited first!");
28929 const nativeResponseValue = wasm.TS_SiPrefix_nano();
28930 return nativeResponseValue;
28932 // enum LDKSiPrefix SiPrefix_pico(void);
28934 export function SiPrefix_pico(): SiPrefix {
28935 if(!isWasmInitialized) {
28936 throw new Error("initializeWasm() must be awaited first!");
28938 const nativeResponseValue = wasm.TS_SiPrefix_pico();
28939 return nativeResponseValue;
28941 // bool SiPrefix_eq(const enum LDKSiPrefix *NONNULL_PTR a, const enum LDKSiPrefix *NONNULL_PTR b);
28943 export function SiPrefix_eq(a: number, b: number): boolean {
28944 if(!isWasmInitialized) {
28945 throw new Error("initializeWasm() must be awaited first!");
28947 const nativeResponseValue = wasm.TS_SiPrefix_eq(a, b);
28948 return nativeResponseValue;
28950 // MUST_USE_RES uint64_t SiPrefix_multiplier(const enum LDKSiPrefix *NONNULL_PTR this_arg);
28952 export function SiPrefix_multiplier(this_arg: number): bigint {
28953 if(!isWasmInitialized) {
28954 throw new Error("initializeWasm() must be awaited first!");
28956 const nativeResponseValue = wasm.TS_SiPrefix_multiplier(this_arg);
28957 return nativeResponseValue;
28959 // enum LDKCurrency Currency_clone(const enum LDKCurrency *NONNULL_PTR orig);
28961 export function Currency_clone(orig: number): Currency {
28962 if(!isWasmInitialized) {
28963 throw new Error("initializeWasm() must be awaited first!");
28965 const nativeResponseValue = wasm.TS_Currency_clone(orig);
28966 return nativeResponseValue;
28968 // enum LDKCurrency Currency_bitcoin(void);
28970 export function Currency_bitcoin(): Currency {
28971 if(!isWasmInitialized) {
28972 throw new Error("initializeWasm() must be awaited first!");
28974 const nativeResponseValue = wasm.TS_Currency_bitcoin();
28975 return nativeResponseValue;
28977 // enum LDKCurrency Currency_bitcoin_testnet(void);
28979 export function Currency_bitcoin_testnet(): Currency {
28980 if(!isWasmInitialized) {
28981 throw new Error("initializeWasm() must be awaited first!");
28983 const nativeResponseValue = wasm.TS_Currency_bitcoin_testnet();
28984 return nativeResponseValue;
28986 // enum LDKCurrency Currency_regtest(void);
28988 export function Currency_regtest(): Currency {
28989 if(!isWasmInitialized) {
28990 throw new Error("initializeWasm() must be awaited first!");
28992 const nativeResponseValue = wasm.TS_Currency_regtest();
28993 return nativeResponseValue;
28995 // enum LDKCurrency Currency_simnet(void);
28997 export function Currency_simnet(): Currency {
28998 if(!isWasmInitialized) {
28999 throw new Error("initializeWasm() must be awaited first!");
29001 const nativeResponseValue = wasm.TS_Currency_simnet();
29002 return nativeResponseValue;
29004 // enum LDKCurrency Currency_signet(void);
29006 export function Currency_signet(): Currency {
29007 if(!isWasmInitialized) {
29008 throw new Error("initializeWasm() must be awaited first!");
29010 const nativeResponseValue = wasm.TS_Currency_signet();
29011 return nativeResponseValue;
29013 // uint64_t Currency_hash(const enum LDKCurrency *NONNULL_PTR o);
29015 export function Currency_hash(o: number): bigint {
29016 if(!isWasmInitialized) {
29017 throw new Error("initializeWasm() must be awaited first!");
29019 const nativeResponseValue = wasm.TS_Currency_hash(o);
29020 return nativeResponseValue;
29022 // bool Currency_eq(const enum LDKCurrency *NONNULL_PTR a, const enum LDKCurrency *NONNULL_PTR b);
29024 export function Currency_eq(a: number, b: number): boolean {
29025 if(!isWasmInitialized) {
29026 throw new Error("initializeWasm() must be awaited first!");
29028 const nativeResponseValue = wasm.TS_Currency_eq(a, b);
29029 return nativeResponseValue;
29031 // void Sha256_free(struct LDKSha256 this_obj);
29033 export function Sha256_free(this_obj: number): void {
29034 if(!isWasmInitialized) {
29035 throw new Error("initializeWasm() must be awaited first!");
29037 const nativeResponseValue = wasm.TS_Sha256_free(this_obj);
29038 // debug statements here
29040 // uintptr_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg);
29042 export function Sha256_clone_ptr(arg: number): number {
29043 if(!isWasmInitialized) {
29044 throw new Error("initializeWasm() must be awaited first!");
29046 const nativeResponseValue = wasm.TS_Sha256_clone_ptr(arg);
29047 return nativeResponseValue;
29049 // struct LDKSha256 Sha256_clone(const struct LDKSha256 *NONNULL_PTR orig);
29051 export function Sha256_clone(orig: number): number {
29052 if(!isWasmInitialized) {
29053 throw new Error("initializeWasm() must be awaited first!");
29055 const nativeResponseValue = wasm.TS_Sha256_clone(orig);
29056 return nativeResponseValue;
29058 // uint64_t Sha256_hash(const struct LDKSha256 *NONNULL_PTR o);
29060 export function Sha256_hash(o: number): bigint {
29061 if(!isWasmInitialized) {
29062 throw new Error("initializeWasm() must be awaited first!");
29064 const nativeResponseValue = wasm.TS_Sha256_hash(o);
29065 return nativeResponseValue;
29067 // bool Sha256_eq(const struct LDKSha256 *NONNULL_PTR a, const struct LDKSha256 *NONNULL_PTR b);
29069 export function Sha256_eq(a: number, b: number): boolean {
29070 if(!isWasmInitialized) {
29071 throw new Error("initializeWasm() must be awaited first!");
29073 const nativeResponseValue = wasm.TS_Sha256_eq(a, b);
29074 return nativeResponseValue;
29076 // void Description_free(struct LDKDescription this_obj);
29078 export function Description_free(this_obj: number): void {
29079 if(!isWasmInitialized) {
29080 throw new Error("initializeWasm() must be awaited first!");
29082 const nativeResponseValue = wasm.TS_Description_free(this_obj);
29083 // debug statements here
29085 // uintptr_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg);
29087 export function Description_clone_ptr(arg: number): number {
29088 if(!isWasmInitialized) {
29089 throw new Error("initializeWasm() must be awaited first!");
29091 const nativeResponseValue = wasm.TS_Description_clone_ptr(arg);
29092 return nativeResponseValue;
29094 // struct LDKDescription Description_clone(const struct LDKDescription *NONNULL_PTR orig);
29096 export function Description_clone(orig: number): number {
29097 if(!isWasmInitialized) {
29098 throw new Error("initializeWasm() must be awaited first!");
29100 const nativeResponseValue = wasm.TS_Description_clone(orig);
29101 return nativeResponseValue;
29103 // uint64_t Description_hash(const struct LDKDescription *NONNULL_PTR o);
29105 export function Description_hash(o: number): bigint {
29106 if(!isWasmInitialized) {
29107 throw new Error("initializeWasm() must be awaited first!");
29109 const nativeResponseValue = wasm.TS_Description_hash(o);
29110 return nativeResponseValue;
29112 // bool Description_eq(const struct LDKDescription *NONNULL_PTR a, const struct LDKDescription *NONNULL_PTR b);
29114 export function Description_eq(a: number, b: number): boolean {
29115 if(!isWasmInitialized) {
29116 throw new Error("initializeWasm() must be awaited first!");
29118 const nativeResponseValue = wasm.TS_Description_eq(a, b);
29119 return nativeResponseValue;
29121 // void PayeePubKey_free(struct LDKPayeePubKey this_obj);
29123 export function PayeePubKey_free(this_obj: number): void {
29124 if(!isWasmInitialized) {
29125 throw new Error("initializeWasm() must be awaited first!");
29127 const nativeResponseValue = wasm.TS_PayeePubKey_free(this_obj);
29128 // debug statements here
29130 // struct LDKPublicKey PayeePubKey_get_a(const struct LDKPayeePubKey *NONNULL_PTR this_ptr);
29132 export function PayeePubKey_get_a(this_ptr: number): number {
29133 if(!isWasmInitialized) {
29134 throw new Error("initializeWasm() must be awaited first!");
29136 const nativeResponseValue = wasm.TS_PayeePubKey_get_a(this_ptr);
29137 return nativeResponseValue;
29139 // void PayeePubKey_set_a(struct LDKPayeePubKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29141 export function PayeePubKey_set_a(this_ptr: number, val: number): void {
29142 if(!isWasmInitialized) {
29143 throw new Error("initializeWasm() must be awaited first!");
29145 const nativeResponseValue = wasm.TS_PayeePubKey_set_a(this_ptr, val);
29146 // debug statements here
29148 // MUST_USE_RES struct LDKPayeePubKey PayeePubKey_new(struct LDKPublicKey a_arg);
29150 export function PayeePubKey_new(a_arg: number): number {
29151 if(!isWasmInitialized) {
29152 throw new Error("initializeWasm() must be awaited first!");
29154 const nativeResponseValue = wasm.TS_PayeePubKey_new(a_arg);
29155 return nativeResponseValue;
29157 // uintptr_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg);
29159 export function PayeePubKey_clone_ptr(arg: number): number {
29160 if(!isWasmInitialized) {
29161 throw new Error("initializeWasm() must be awaited first!");
29163 const nativeResponseValue = wasm.TS_PayeePubKey_clone_ptr(arg);
29164 return nativeResponseValue;
29166 // struct LDKPayeePubKey PayeePubKey_clone(const struct LDKPayeePubKey *NONNULL_PTR orig);
29168 export function PayeePubKey_clone(orig: number): number {
29169 if(!isWasmInitialized) {
29170 throw new Error("initializeWasm() must be awaited first!");
29172 const nativeResponseValue = wasm.TS_PayeePubKey_clone(orig);
29173 return nativeResponseValue;
29175 // uint64_t PayeePubKey_hash(const struct LDKPayeePubKey *NONNULL_PTR o);
29177 export function PayeePubKey_hash(o: number): bigint {
29178 if(!isWasmInitialized) {
29179 throw new Error("initializeWasm() must be awaited first!");
29181 const nativeResponseValue = wasm.TS_PayeePubKey_hash(o);
29182 return nativeResponseValue;
29184 // bool PayeePubKey_eq(const struct LDKPayeePubKey *NONNULL_PTR a, const struct LDKPayeePubKey *NONNULL_PTR b);
29186 export function PayeePubKey_eq(a: number, b: number): boolean {
29187 if(!isWasmInitialized) {
29188 throw new Error("initializeWasm() must be awaited first!");
29190 const nativeResponseValue = wasm.TS_PayeePubKey_eq(a, b);
29191 return nativeResponseValue;
29193 // void ExpiryTime_free(struct LDKExpiryTime this_obj);
29195 export function ExpiryTime_free(this_obj: number): void {
29196 if(!isWasmInitialized) {
29197 throw new Error("initializeWasm() must be awaited first!");
29199 const nativeResponseValue = wasm.TS_ExpiryTime_free(this_obj);
29200 // debug statements here
29202 // uintptr_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg);
29204 export function ExpiryTime_clone_ptr(arg: number): number {
29205 if(!isWasmInitialized) {
29206 throw new Error("initializeWasm() must be awaited first!");
29208 const nativeResponseValue = wasm.TS_ExpiryTime_clone_ptr(arg);
29209 return nativeResponseValue;
29211 // struct LDKExpiryTime ExpiryTime_clone(const struct LDKExpiryTime *NONNULL_PTR orig);
29213 export function ExpiryTime_clone(orig: number): number {
29214 if(!isWasmInitialized) {
29215 throw new Error("initializeWasm() must be awaited first!");
29217 const nativeResponseValue = wasm.TS_ExpiryTime_clone(orig);
29218 return nativeResponseValue;
29220 // uint64_t ExpiryTime_hash(const struct LDKExpiryTime *NONNULL_PTR o);
29222 export function ExpiryTime_hash(o: number): bigint {
29223 if(!isWasmInitialized) {
29224 throw new Error("initializeWasm() must be awaited first!");
29226 const nativeResponseValue = wasm.TS_ExpiryTime_hash(o);
29227 return nativeResponseValue;
29229 // bool ExpiryTime_eq(const struct LDKExpiryTime *NONNULL_PTR a, const struct LDKExpiryTime *NONNULL_PTR b);
29231 export function ExpiryTime_eq(a: number, b: number): boolean {
29232 if(!isWasmInitialized) {
29233 throw new Error("initializeWasm() must be awaited first!");
29235 const nativeResponseValue = wasm.TS_ExpiryTime_eq(a, b);
29236 return nativeResponseValue;
29238 // void MinFinalCltvExpiry_free(struct LDKMinFinalCltvExpiry this_obj);
29240 export function MinFinalCltvExpiry_free(this_obj: number): void {
29241 if(!isWasmInitialized) {
29242 throw new Error("initializeWasm() must be awaited first!");
29244 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_free(this_obj);
29245 // debug statements here
29247 // uint64_t MinFinalCltvExpiry_get_a(const struct LDKMinFinalCltvExpiry *NONNULL_PTR this_ptr);
29249 export function MinFinalCltvExpiry_get_a(this_ptr: number): bigint {
29250 if(!isWasmInitialized) {
29251 throw new Error("initializeWasm() must be awaited first!");
29253 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_get_a(this_ptr);
29254 return nativeResponseValue;
29256 // void MinFinalCltvExpiry_set_a(struct LDKMinFinalCltvExpiry *NONNULL_PTR this_ptr, uint64_t val);
29258 export function MinFinalCltvExpiry_set_a(this_ptr: number, val: bigint): void {
29259 if(!isWasmInitialized) {
29260 throw new Error("initializeWasm() must be awaited first!");
29262 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_set_a(this_ptr, val);
29263 // debug statements here
29265 // MUST_USE_RES struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_new(uint64_t a_arg);
29267 export function MinFinalCltvExpiry_new(a_arg: bigint): number {
29268 if(!isWasmInitialized) {
29269 throw new Error("initializeWasm() must be awaited first!");
29271 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_new(a_arg);
29272 return nativeResponseValue;
29274 // uintptr_t MinFinalCltvExpiry_clone_ptr(LDKMinFinalCltvExpiry *NONNULL_PTR arg);
29276 export function MinFinalCltvExpiry_clone_ptr(arg: number): number {
29277 if(!isWasmInitialized) {
29278 throw new Error("initializeWasm() must be awaited first!");
29280 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_clone_ptr(arg);
29281 return nativeResponseValue;
29283 // struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_clone(const struct LDKMinFinalCltvExpiry *NONNULL_PTR orig);
29285 export function MinFinalCltvExpiry_clone(orig: number): number {
29286 if(!isWasmInitialized) {
29287 throw new Error("initializeWasm() must be awaited first!");
29289 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_clone(orig);
29290 return nativeResponseValue;
29292 // uint64_t MinFinalCltvExpiry_hash(const struct LDKMinFinalCltvExpiry *NONNULL_PTR o);
29294 export function MinFinalCltvExpiry_hash(o: number): bigint {
29295 if(!isWasmInitialized) {
29296 throw new Error("initializeWasm() must be awaited first!");
29298 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_hash(o);
29299 return nativeResponseValue;
29301 // bool MinFinalCltvExpiry_eq(const struct LDKMinFinalCltvExpiry *NONNULL_PTR a, const struct LDKMinFinalCltvExpiry *NONNULL_PTR b);
29303 export function MinFinalCltvExpiry_eq(a: number, b: number): boolean {
29304 if(!isWasmInitialized) {
29305 throw new Error("initializeWasm() must be awaited first!");
29307 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_eq(a, b);
29308 return nativeResponseValue;
29310 // void Fallback_free(struct LDKFallback this_ptr);
29312 export function Fallback_free(this_ptr: number): void {
29313 if(!isWasmInitialized) {
29314 throw new Error("initializeWasm() must be awaited first!");
29316 const nativeResponseValue = wasm.TS_Fallback_free(this_ptr);
29317 // debug statements here
29319 // uintptr_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg);
29321 export function Fallback_clone_ptr(arg: number): number {
29322 if(!isWasmInitialized) {
29323 throw new Error("initializeWasm() must be awaited first!");
29325 const nativeResponseValue = wasm.TS_Fallback_clone_ptr(arg);
29326 return nativeResponseValue;
29328 // struct LDKFallback Fallback_clone(const struct LDKFallback *NONNULL_PTR orig);
29330 export function Fallback_clone(orig: number): number {
29331 if(!isWasmInitialized) {
29332 throw new Error("initializeWasm() must be awaited first!");
29334 const nativeResponseValue = wasm.TS_Fallback_clone(orig);
29335 return nativeResponseValue;
29337 // struct LDKFallback Fallback_seg_wit_program(struct LDKu5 version, struct LDKCVec_u8Z program);
29339 export function Fallback_seg_wit_program(version: number, program: number): number {
29340 if(!isWasmInitialized) {
29341 throw new Error("initializeWasm() must be awaited first!");
29343 const nativeResponseValue = wasm.TS_Fallback_seg_wit_program(version, program);
29344 return nativeResponseValue;
29346 // struct LDKFallback Fallback_pub_key_hash(struct LDKTwentyBytes a);
29348 export function Fallback_pub_key_hash(a: number): number {
29349 if(!isWasmInitialized) {
29350 throw new Error("initializeWasm() must be awaited first!");
29352 const nativeResponseValue = wasm.TS_Fallback_pub_key_hash(a);
29353 return nativeResponseValue;
29355 // struct LDKFallback Fallback_script_hash(struct LDKTwentyBytes a);
29357 export function Fallback_script_hash(a: number): number {
29358 if(!isWasmInitialized) {
29359 throw new Error("initializeWasm() must be awaited first!");
29361 const nativeResponseValue = wasm.TS_Fallback_script_hash(a);
29362 return nativeResponseValue;
29364 // uint64_t Fallback_hash(const struct LDKFallback *NONNULL_PTR o);
29366 export function Fallback_hash(o: number): bigint {
29367 if(!isWasmInitialized) {
29368 throw new Error("initializeWasm() must be awaited first!");
29370 const nativeResponseValue = wasm.TS_Fallback_hash(o);
29371 return nativeResponseValue;
29373 // bool Fallback_eq(const struct LDKFallback *NONNULL_PTR a, const struct LDKFallback *NONNULL_PTR b);
29375 export function Fallback_eq(a: number, b: number): boolean {
29376 if(!isWasmInitialized) {
29377 throw new Error("initializeWasm() must be awaited first!");
29379 const nativeResponseValue = wasm.TS_Fallback_eq(a, b);
29380 return nativeResponseValue;
29382 // void InvoiceSignature_free(struct LDKInvoiceSignature this_obj);
29384 export function InvoiceSignature_free(this_obj: number): void {
29385 if(!isWasmInitialized) {
29386 throw new Error("initializeWasm() must be awaited first!");
29388 const nativeResponseValue = wasm.TS_InvoiceSignature_free(this_obj);
29389 // debug statements here
29391 // uintptr_t InvoiceSignature_clone_ptr(LDKInvoiceSignature *NONNULL_PTR arg);
29393 export function InvoiceSignature_clone_ptr(arg: number): number {
29394 if(!isWasmInitialized) {
29395 throw new Error("initializeWasm() must be awaited first!");
29397 const nativeResponseValue = wasm.TS_InvoiceSignature_clone_ptr(arg);
29398 return nativeResponseValue;
29400 // struct LDKInvoiceSignature InvoiceSignature_clone(const struct LDKInvoiceSignature *NONNULL_PTR orig);
29402 export function InvoiceSignature_clone(orig: number): number {
29403 if(!isWasmInitialized) {
29404 throw new Error("initializeWasm() must be awaited first!");
29406 const nativeResponseValue = wasm.TS_InvoiceSignature_clone(orig);
29407 return nativeResponseValue;
29409 // bool InvoiceSignature_eq(const struct LDKInvoiceSignature *NONNULL_PTR a, const struct LDKInvoiceSignature *NONNULL_PTR b);
29411 export function InvoiceSignature_eq(a: number, b: number): boolean {
29412 if(!isWasmInitialized) {
29413 throw new Error("initializeWasm() must be awaited first!");
29415 const nativeResponseValue = wasm.TS_InvoiceSignature_eq(a, b);
29416 return nativeResponseValue;
29418 // void PrivateRoute_free(struct LDKPrivateRoute this_obj);
29420 export function PrivateRoute_free(this_obj: number): void {
29421 if(!isWasmInitialized) {
29422 throw new Error("initializeWasm() must be awaited first!");
29424 const nativeResponseValue = wasm.TS_PrivateRoute_free(this_obj);
29425 // debug statements here
29427 // uintptr_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg);
29429 export function PrivateRoute_clone_ptr(arg: number): number {
29430 if(!isWasmInitialized) {
29431 throw new Error("initializeWasm() must be awaited first!");
29433 const nativeResponseValue = wasm.TS_PrivateRoute_clone_ptr(arg);
29434 return nativeResponseValue;
29436 // struct LDKPrivateRoute PrivateRoute_clone(const struct LDKPrivateRoute *NONNULL_PTR orig);
29438 export function PrivateRoute_clone(orig: number): number {
29439 if(!isWasmInitialized) {
29440 throw new Error("initializeWasm() must be awaited first!");
29442 const nativeResponseValue = wasm.TS_PrivateRoute_clone(orig);
29443 return nativeResponseValue;
29445 // uint64_t PrivateRoute_hash(const struct LDKPrivateRoute *NONNULL_PTR o);
29447 export function PrivateRoute_hash(o: number): bigint {
29448 if(!isWasmInitialized) {
29449 throw new Error("initializeWasm() must be awaited first!");
29451 const nativeResponseValue = wasm.TS_PrivateRoute_hash(o);
29452 return nativeResponseValue;
29454 // bool PrivateRoute_eq(const struct LDKPrivateRoute *NONNULL_PTR a, const struct LDKPrivateRoute *NONNULL_PTR b);
29456 export function PrivateRoute_eq(a: number, b: number): boolean {
29457 if(!isWasmInitialized) {
29458 throw new Error("initializeWasm() must be awaited first!");
29460 const nativeResponseValue = wasm.TS_PrivateRoute_eq(a, b);
29461 return nativeResponseValue;
29463 // MUST_USE_RES struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ SignedRawInvoice_into_parts(struct LDKSignedRawInvoice this_arg);
29465 export function SignedRawInvoice_into_parts(this_arg: number): number {
29466 if(!isWasmInitialized) {
29467 throw new Error("initializeWasm() must be awaited first!");
29469 const nativeResponseValue = wasm.TS_SignedRawInvoice_into_parts(this_arg);
29470 return nativeResponseValue;
29472 // MUST_USE_RES struct LDKRawInvoice SignedRawInvoice_raw_invoice(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
29474 export function SignedRawInvoice_raw_invoice(this_arg: number): number {
29475 if(!isWasmInitialized) {
29476 throw new Error("initializeWasm() must be awaited first!");
29478 const nativeResponseValue = wasm.TS_SignedRawInvoice_raw_invoice(this_arg);
29479 return nativeResponseValue;
29481 // MUST_USE_RES const uint8_t (*SignedRawInvoice_hash(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg))[32];
29483 export function SignedRawInvoice_hash(this_arg: number): number {
29484 if(!isWasmInitialized) {
29485 throw new Error("initializeWasm() must be awaited first!");
29487 const nativeResponseValue = wasm.TS_SignedRawInvoice_hash(this_arg);
29488 return nativeResponseValue;
29490 // MUST_USE_RES struct LDKInvoiceSignature SignedRawInvoice_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
29492 export function SignedRawInvoice_signature(this_arg: number): number {
29493 if(!isWasmInitialized) {
29494 throw new Error("initializeWasm() must be awaited first!");
29496 const nativeResponseValue = wasm.TS_SignedRawInvoice_signature(this_arg);
29497 return nativeResponseValue;
29499 // MUST_USE_RES struct LDKCResult_PayeePubKeyErrorZ SignedRawInvoice_recover_payee_pub_key(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
29501 export function SignedRawInvoice_recover_payee_pub_key(this_arg: number): number {
29502 if(!isWasmInitialized) {
29503 throw new Error("initializeWasm() must be awaited first!");
29505 const nativeResponseValue = wasm.TS_SignedRawInvoice_recover_payee_pub_key(this_arg);
29506 return nativeResponseValue;
29508 // MUST_USE_RES bool SignedRawInvoice_check_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
29510 export function SignedRawInvoice_check_signature(this_arg: number): boolean {
29511 if(!isWasmInitialized) {
29512 throw new Error("initializeWasm() must be awaited first!");
29514 const nativeResponseValue = wasm.TS_SignedRawInvoice_check_signature(this_arg);
29515 return nativeResponseValue;
29517 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
29519 export function RawInvoice_hash(this_arg: number): number {
29520 if(!isWasmInitialized) {
29521 throw new Error("initializeWasm() must be awaited first!");
29523 const nativeResponseValue = wasm.TS_RawInvoice_hash(this_arg);
29524 return nativeResponseValue;
29526 // MUST_USE_RES struct LDKSha256 RawInvoice_payment_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
29528 export function RawInvoice_payment_hash(this_arg: number): number {
29529 if(!isWasmInitialized) {
29530 throw new Error("initializeWasm() must be awaited first!");
29532 const nativeResponseValue = wasm.TS_RawInvoice_payment_hash(this_arg);
29533 return nativeResponseValue;
29535 // MUST_USE_RES struct LDKDescription RawInvoice_description(const struct LDKRawInvoice *NONNULL_PTR this_arg);
29537 export function RawInvoice_description(this_arg: number): number {
29538 if(!isWasmInitialized) {
29539 throw new Error("initializeWasm() must be awaited first!");
29541 const nativeResponseValue = wasm.TS_RawInvoice_description(this_arg);
29542 return nativeResponseValue;
29544 // MUST_USE_RES struct LDKPayeePubKey RawInvoice_payee_pub_key(const struct LDKRawInvoice *NONNULL_PTR this_arg);
29546 export function RawInvoice_payee_pub_key(this_arg: number): number {
29547 if(!isWasmInitialized) {
29548 throw new Error("initializeWasm() must be awaited first!");
29550 const nativeResponseValue = wasm.TS_RawInvoice_payee_pub_key(this_arg);
29551 return nativeResponseValue;
29553 // MUST_USE_RES struct LDKSha256 RawInvoice_description_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
29555 export function RawInvoice_description_hash(this_arg: number): number {
29556 if(!isWasmInitialized) {
29557 throw new Error("initializeWasm() must be awaited first!");
29559 const nativeResponseValue = wasm.TS_RawInvoice_description_hash(this_arg);
29560 return nativeResponseValue;
29562 // MUST_USE_RES struct LDKExpiryTime RawInvoice_expiry_time(const struct LDKRawInvoice *NONNULL_PTR this_arg);
29564 export function RawInvoice_expiry_time(this_arg: number): number {
29565 if(!isWasmInitialized) {
29566 throw new Error("initializeWasm() must be awaited first!");
29568 const nativeResponseValue = wasm.TS_RawInvoice_expiry_time(this_arg);
29569 return nativeResponseValue;
29571 // MUST_USE_RES struct LDKMinFinalCltvExpiry RawInvoice_min_final_cltv_expiry(const struct LDKRawInvoice *NONNULL_PTR this_arg);
29573 export function RawInvoice_min_final_cltv_expiry(this_arg: number): number {
29574 if(!isWasmInitialized) {
29575 throw new Error("initializeWasm() must be awaited first!");
29577 const nativeResponseValue = wasm.TS_RawInvoice_min_final_cltv_expiry(this_arg);
29578 return nativeResponseValue;
29580 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_payment_secret(const struct LDKRawInvoice *NONNULL_PTR this_arg);
29582 export function RawInvoice_payment_secret(this_arg: number): number {
29583 if(!isWasmInitialized) {
29584 throw new Error("initializeWasm() must be awaited first!");
29586 const nativeResponseValue = wasm.TS_RawInvoice_payment_secret(this_arg);
29587 return nativeResponseValue;
29589 // MUST_USE_RES struct LDKInvoiceFeatures RawInvoice_features(const struct LDKRawInvoice *NONNULL_PTR this_arg);
29591 export function RawInvoice_features(this_arg: number): number {
29592 if(!isWasmInitialized) {
29593 throw new Error("initializeWasm() must be awaited first!");
29595 const nativeResponseValue = wasm.TS_RawInvoice_features(this_arg);
29596 return nativeResponseValue;
29598 // MUST_USE_RES struct LDKCVec_PrivateRouteZ RawInvoice_private_routes(const struct LDKRawInvoice *NONNULL_PTR this_arg);
29600 export function RawInvoice_private_routes(this_arg: number): number {
29601 if(!isWasmInitialized) {
29602 throw new Error("initializeWasm() must be awaited first!");
29604 const nativeResponseValue = wasm.TS_RawInvoice_private_routes(this_arg);
29605 return nativeResponseValue;
29607 // MUST_USE_RES struct LDKCOption_u64Z RawInvoice_amount_pico_btc(const struct LDKRawInvoice *NONNULL_PTR this_arg);
29609 export function RawInvoice_amount_pico_btc(this_arg: number): number {
29610 if(!isWasmInitialized) {
29611 throw new Error("initializeWasm() must be awaited first!");
29613 const nativeResponseValue = wasm.TS_RawInvoice_amount_pico_btc(this_arg);
29614 return nativeResponseValue;
29616 // MUST_USE_RES enum LDKCurrency RawInvoice_currency(const struct LDKRawInvoice *NONNULL_PTR this_arg);
29618 export function RawInvoice_currency(this_arg: number): Currency {
29619 if(!isWasmInitialized) {
29620 throw new Error("initializeWasm() must be awaited first!");
29622 const nativeResponseValue = wasm.TS_RawInvoice_currency(this_arg);
29623 return nativeResponseValue;
29625 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_unix_timestamp(uint64_t unix_seconds);
29627 export function PositiveTimestamp_from_unix_timestamp(unix_seconds: bigint): number {
29628 if(!isWasmInitialized) {
29629 throw new Error("initializeWasm() must be awaited first!");
29631 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_unix_timestamp(unix_seconds);
29632 return nativeResponseValue;
29634 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_duration_since_epoch(uint64_t duration);
29636 export function PositiveTimestamp_from_duration_since_epoch(duration: bigint): number {
29637 if(!isWasmInitialized) {
29638 throw new Error("initializeWasm() must be awaited first!");
29640 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_duration_since_epoch(duration);
29641 return nativeResponseValue;
29643 // MUST_USE_RES uint64_t PositiveTimestamp_as_unix_timestamp(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
29645 export function PositiveTimestamp_as_unix_timestamp(this_arg: number): bigint {
29646 if(!isWasmInitialized) {
29647 throw new Error("initializeWasm() must be awaited first!");
29649 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_unix_timestamp(this_arg);
29650 return nativeResponseValue;
29652 // MUST_USE_RES uint64_t PositiveTimestamp_as_duration_since_epoch(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
29654 export function PositiveTimestamp_as_duration_since_epoch(this_arg: number): bigint {
29655 if(!isWasmInitialized) {
29656 throw new Error("initializeWasm() must be awaited first!");
29658 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_duration_since_epoch(this_arg);
29659 return nativeResponseValue;
29661 // MUST_USE_RES struct LDKSignedRawInvoice Invoice_into_signed_raw(struct LDKInvoice this_arg);
29663 export function Invoice_into_signed_raw(this_arg: number): number {
29664 if(!isWasmInitialized) {
29665 throw new Error("initializeWasm() must be awaited first!");
29667 const nativeResponseValue = wasm.TS_Invoice_into_signed_raw(this_arg);
29668 return nativeResponseValue;
29670 // MUST_USE_RES struct LDKCResult_NoneSemanticErrorZ Invoice_check_signature(const struct LDKInvoice *NONNULL_PTR this_arg);
29672 export function Invoice_check_signature(this_arg: number): number {
29673 if(!isWasmInitialized) {
29674 throw new Error("initializeWasm() must be awaited first!");
29676 const nativeResponseValue = wasm.TS_Invoice_check_signature(this_arg);
29677 return nativeResponseValue;
29679 // MUST_USE_RES struct LDKCResult_InvoiceSemanticErrorZ Invoice_from_signed(struct LDKSignedRawInvoice signed_invoice);
29681 export function Invoice_from_signed(signed_invoice: number): number {
29682 if(!isWasmInitialized) {
29683 throw new Error("initializeWasm() must be awaited first!");
29685 const nativeResponseValue = wasm.TS_Invoice_from_signed(signed_invoice);
29686 return nativeResponseValue;
29688 // MUST_USE_RES uint64_t Invoice_duration_since_epoch(const struct LDKInvoice *NONNULL_PTR this_arg);
29690 export function Invoice_duration_since_epoch(this_arg: number): bigint {
29691 if(!isWasmInitialized) {
29692 throw new Error("initializeWasm() must be awaited first!");
29694 const nativeResponseValue = wasm.TS_Invoice_duration_since_epoch(this_arg);
29695 return nativeResponseValue;
29697 // MUST_USE_RES const uint8_t (*Invoice_payment_hash(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
29699 export function Invoice_payment_hash(this_arg: number): number {
29700 if(!isWasmInitialized) {
29701 throw new Error("initializeWasm() must be awaited first!");
29703 const nativeResponseValue = wasm.TS_Invoice_payment_hash(this_arg);
29704 return nativeResponseValue;
29706 // MUST_USE_RES struct LDKPublicKey Invoice_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
29708 export function Invoice_payee_pub_key(this_arg: number): number {
29709 if(!isWasmInitialized) {
29710 throw new Error("initializeWasm() must be awaited first!");
29712 const nativeResponseValue = wasm.TS_Invoice_payee_pub_key(this_arg);
29713 return nativeResponseValue;
29715 // MUST_USE_RES const uint8_t (*Invoice_payment_secret(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
29717 export function Invoice_payment_secret(this_arg: number): number {
29718 if(!isWasmInitialized) {
29719 throw new Error("initializeWasm() must be awaited first!");
29721 const nativeResponseValue = wasm.TS_Invoice_payment_secret(this_arg);
29722 return nativeResponseValue;
29724 // MUST_USE_RES struct LDKInvoiceFeatures Invoice_features(const struct LDKInvoice *NONNULL_PTR this_arg);
29726 export function Invoice_features(this_arg: number): number {
29727 if(!isWasmInitialized) {
29728 throw new Error("initializeWasm() must be awaited first!");
29730 const nativeResponseValue = wasm.TS_Invoice_features(this_arg);
29731 return nativeResponseValue;
29733 // MUST_USE_RES struct LDKPublicKey Invoice_recover_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
29735 export function Invoice_recover_payee_pub_key(this_arg: number): number {
29736 if(!isWasmInitialized) {
29737 throw new Error("initializeWasm() must be awaited first!");
29739 const nativeResponseValue = wasm.TS_Invoice_recover_payee_pub_key(this_arg);
29740 return nativeResponseValue;
29742 // MUST_USE_RES uint64_t Invoice_expiry_time(const struct LDKInvoice *NONNULL_PTR this_arg);
29744 export function Invoice_expiry_time(this_arg: number): bigint {
29745 if(!isWasmInitialized) {
29746 throw new Error("initializeWasm() must be awaited first!");
29748 const nativeResponseValue = wasm.TS_Invoice_expiry_time(this_arg);
29749 return nativeResponseValue;
29751 // MUST_USE_RES bool Invoice_would_expire(const struct LDKInvoice *NONNULL_PTR this_arg, uint64_t at_time);
29753 export function Invoice_would_expire(this_arg: number, at_time: bigint): boolean {
29754 if(!isWasmInitialized) {
29755 throw new Error("initializeWasm() must be awaited first!");
29757 const nativeResponseValue = wasm.TS_Invoice_would_expire(this_arg, at_time);
29758 return nativeResponseValue;
29760 // MUST_USE_RES uint64_t Invoice_min_final_cltv_expiry(const struct LDKInvoice *NONNULL_PTR this_arg);
29762 export function Invoice_min_final_cltv_expiry(this_arg: number): bigint {
29763 if(!isWasmInitialized) {
29764 throw new Error("initializeWasm() must be awaited first!");
29766 const nativeResponseValue = wasm.TS_Invoice_min_final_cltv_expiry(this_arg);
29767 return nativeResponseValue;
29769 // MUST_USE_RES struct LDKCVec_PrivateRouteZ Invoice_private_routes(const struct LDKInvoice *NONNULL_PTR this_arg);
29771 export function Invoice_private_routes(this_arg: number): number {
29772 if(!isWasmInitialized) {
29773 throw new Error("initializeWasm() must be awaited first!");
29775 const nativeResponseValue = wasm.TS_Invoice_private_routes(this_arg);
29776 return nativeResponseValue;
29778 // MUST_USE_RES struct LDKCVec_RouteHintZ Invoice_route_hints(const struct LDKInvoice *NONNULL_PTR this_arg);
29780 export function Invoice_route_hints(this_arg: number): number {
29781 if(!isWasmInitialized) {
29782 throw new Error("initializeWasm() must be awaited first!");
29784 const nativeResponseValue = wasm.TS_Invoice_route_hints(this_arg);
29785 return nativeResponseValue;
29787 // MUST_USE_RES enum LDKCurrency Invoice_currency(const struct LDKInvoice *NONNULL_PTR this_arg);
29789 export function Invoice_currency(this_arg: number): Currency {
29790 if(!isWasmInitialized) {
29791 throw new Error("initializeWasm() must be awaited first!");
29793 const nativeResponseValue = wasm.TS_Invoice_currency(this_arg);
29794 return nativeResponseValue;
29796 // MUST_USE_RES struct LDKCOption_u64Z Invoice_amount_milli_satoshis(const struct LDKInvoice *NONNULL_PTR this_arg);
29798 export function Invoice_amount_milli_satoshis(this_arg: number): number {
29799 if(!isWasmInitialized) {
29800 throw new Error("initializeWasm() must be awaited first!");
29802 const nativeResponseValue = wasm.TS_Invoice_amount_milli_satoshis(this_arg);
29803 return nativeResponseValue;
29805 // MUST_USE_RES struct LDKCResult_DescriptionCreationErrorZ Description_new(struct LDKStr description);
29807 export function Description_new(description: number): number {
29808 if(!isWasmInitialized) {
29809 throw new Error("initializeWasm() must be awaited first!");
29811 const nativeResponseValue = wasm.TS_Description_new(description);
29812 return nativeResponseValue;
29814 // MUST_USE_RES struct LDKStr Description_into_inner(struct LDKDescription this_arg);
29816 export function Description_into_inner(this_arg: number): number {
29817 if(!isWasmInitialized) {
29818 throw new Error("initializeWasm() must be awaited first!");
29820 const nativeResponseValue = wasm.TS_Description_into_inner(this_arg);
29821 return nativeResponseValue;
29823 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_seconds(uint64_t seconds);
29825 export function ExpiryTime_from_seconds(seconds: bigint): number {
29826 if(!isWasmInitialized) {
29827 throw new Error("initializeWasm() must be awaited first!");
29829 const nativeResponseValue = wasm.TS_ExpiryTime_from_seconds(seconds);
29830 return nativeResponseValue;
29832 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_duration(uint64_t duration);
29834 export function ExpiryTime_from_duration(duration: bigint): number {
29835 if(!isWasmInitialized) {
29836 throw new Error("initializeWasm() must be awaited first!");
29838 const nativeResponseValue = wasm.TS_ExpiryTime_from_duration(duration);
29839 return nativeResponseValue;
29841 // MUST_USE_RES uint64_t ExpiryTime_as_seconds(const struct LDKExpiryTime *NONNULL_PTR this_arg);
29843 export function ExpiryTime_as_seconds(this_arg: number): bigint {
29844 if(!isWasmInitialized) {
29845 throw new Error("initializeWasm() must be awaited first!");
29847 const nativeResponseValue = wasm.TS_ExpiryTime_as_seconds(this_arg);
29848 return nativeResponseValue;
29850 // MUST_USE_RES uint64_t ExpiryTime_as_duration(const struct LDKExpiryTime *NONNULL_PTR this_arg);
29852 export function ExpiryTime_as_duration(this_arg: number): bigint {
29853 if(!isWasmInitialized) {
29854 throw new Error("initializeWasm() must be awaited first!");
29856 const nativeResponseValue = wasm.TS_ExpiryTime_as_duration(this_arg);
29857 return nativeResponseValue;
29859 // MUST_USE_RES struct LDKCResult_PrivateRouteCreationErrorZ PrivateRoute_new(struct LDKRouteHint hops);
29861 export function PrivateRoute_new(hops: number): number {
29862 if(!isWasmInitialized) {
29863 throw new Error("initializeWasm() must be awaited first!");
29865 const nativeResponseValue = wasm.TS_PrivateRoute_new(hops);
29866 return nativeResponseValue;
29868 // MUST_USE_RES struct LDKRouteHint PrivateRoute_into_inner(struct LDKPrivateRoute this_arg);
29870 export function PrivateRoute_into_inner(this_arg: number): number {
29871 if(!isWasmInitialized) {
29872 throw new Error("initializeWasm() must be awaited first!");
29874 const nativeResponseValue = wasm.TS_PrivateRoute_into_inner(this_arg);
29875 return nativeResponseValue;
29877 // enum LDKCreationError CreationError_clone(const enum LDKCreationError *NONNULL_PTR orig);
29879 export function CreationError_clone(orig: number): CreationError {
29880 if(!isWasmInitialized) {
29881 throw new Error("initializeWasm() must be awaited first!");
29883 const nativeResponseValue = wasm.TS_CreationError_clone(orig);
29884 return nativeResponseValue;
29886 // enum LDKCreationError CreationError_description_too_long(void);
29888 export function CreationError_description_too_long(): CreationError {
29889 if(!isWasmInitialized) {
29890 throw new Error("initializeWasm() must be awaited first!");
29892 const nativeResponseValue = wasm.TS_CreationError_description_too_long();
29893 return nativeResponseValue;
29895 // enum LDKCreationError CreationError_route_too_long(void);
29897 export function CreationError_route_too_long(): CreationError {
29898 if(!isWasmInitialized) {
29899 throw new Error("initializeWasm() must be awaited first!");
29901 const nativeResponseValue = wasm.TS_CreationError_route_too_long();
29902 return nativeResponseValue;
29904 // enum LDKCreationError CreationError_timestamp_out_of_bounds(void);
29906 export function CreationError_timestamp_out_of_bounds(): CreationError {
29907 if(!isWasmInitialized) {
29908 throw new Error("initializeWasm() must be awaited first!");
29910 const nativeResponseValue = wasm.TS_CreationError_timestamp_out_of_bounds();
29911 return nativeResponseValue;
29913 // enum LDKCreationError CreationError_invalid_amount(void);
29915 export function CreationError_invalid_amount(): CreationError {
29916 if(!isWasmInitialized) {
29917 throw new Error("initializeWasm() must be awaited first!");
29919 const nativeResponseValue = wasm.TS_CreationError_invalid_amount();
29920 return nativeResponseValue;
29922 // enum LDKCreationError CreationError_missing_route_hints(void);
29924 export function CreationError_missing_route_hints(): CreationError {
29925 if(!isWasmInitialized) {
29926 throw new Error("initializeWasm() must be awaited first!");
29928 const nativeResponseValue = wasm.TS_CreationError_missing_route_hints();
29929 return nativeResponseValue;
29931 // bool CreationError_eq(const enum LDKCreationError *NONNULL_PTR a, const enum LDKCreationError *NONNULL_PTR b);
29933 export function CreationError_eq(a: number, b: number): boolean {
29934 if(!isWasmInitialized) {
29935 throw new Error("initializeWasm() must be awaited first!");
29937 const nativeResponseValue = wasm.TS_CreationError_eq(a, b);
29938 return nativeResponseValue;
29940 // struct LDKStr CreationError_to_str(const enum LDKCreationError *NONNULL_PTR o);
29942 export function CreationError_to_str(o: number): number {
29943 if(!isWasmInitialized) {
29944 throw new Error("initializeWasm() must be awaited first!");
29946 const nativeResponseValue = wasm.TS_CreationError_to_str(o);
29947 return nativeResponseValue;
29949 // enum LDKSemanticError SemanticError_clone(const enum LDKSemanticError *NONNULL_PTR orig);
29951 export function SemanticError_clone(orig: number): SemanticError {
29952 if(!isWasmInitialized) {
29953 throw new Error("initializeWasm() must be awaited first!");
29955 const nativeResponseValue = wasm.TS_SemanticError_clone(orig);
29956 return nativeResponseValue;
29958 // enum LDKSemanticError SemanticError_no_payment_hash(void);
29960 export function SemanticError_no_payment_hash(): SemanticError {
29961 if(!isWasmInitialized) {
29962 throw new Error("initializeWasm() must be awaited first!");
29964 const nativeResponseValue = wasm.TS_SemanticError_no_payment_hash();
29965 return nativeResponseValue;
29967 // enum LDKSemanticError SemanticError_multiple_payment_hashes(void);
29969 export function SemanticError_multiple_payment_hashes(): SemanticError {
29970 if(!isWasmInitialized) {
29971 throw new Error("initializeWasm() must be awaited first!");
29973 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_hashes();
29974 return nativeResponseValue;
29976 // enum LDKSemanticError SemanticError_no_description(void);
29978 export function SemanticError_no_description(): SemanticError {
29979 if(!isWasmInitialized) {
29980 throw new Error("initializeWasm() must be awaited first!");
29982 const nativeResponseValue = wasm.TS_SemanticError_no_description();
29983 return nativeResponseValue;
29985 // enum LDKSemanticError SemanticError_multiple_descriptions(void);
29987 export function SemanticError_multiple_descriptions(): SemanticError {
29988 if(!isWasmInitialized) {
29989 throw new Error("initializeWasm() must be awaited first!");
29991 const nativeResponseValue = wasm.TS_SemanticError_multiple_descriptions();
29992 return nativeResponseValue;
29994 // enum LDKSemanticError SemanticError_no_payment_secret(void);
29996 export function SemanticError_no_payment_secret(): SemanticError {
29997 if(!isWasmInitialized) {
29998 throw new Error("initializeWasm() must be awaited first!");
30000 const nativeResponseValue = wasm.TS_SemanticError_no_payment_secret();
30001 return nativeResponseValue;
30003 // enum LDKSemanticError SemanticError_multiple_payment_secrets(void);
30005 export function SemanticError_multiple_payment_secrets(): SemanticError {
30006 if(!isWasmInitialized) {
30007 throw new Error("initializeWasm() must be awaited first!");
30009 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_secrets();
30010 return nativeResponseValue;
30012 // enum LDKSemanticError SemanticError_invalid_features(void);
30014 export function SemanticError_invalid_features(): SemanticError {
30015 if(!isWasmInitialized) {
30016 throw new Error("initializeWasm() must be awaited first!");
30018 const nativeResponseValue = wasm.TS_SemanticError_invalid_features();
30019 return nativeResponseValue;
30021 // enum LDKSemanticError SemanticError_invalid_recovery_id(void);
30023 export function SemanticError_invalid_recovery_id(): SemanticError {
30024 if(!isWasmInitialized) {
30025 throw new Error("initializeWasm() must be awaited first!");
30027 const nativeResponseValue = wasm.TS_SemanticError_invalid_recovery_id();
30028 return nativeResponseValue;
30030 // enum LDKSemanticError SemanticError_invalid_signature(void);
30032 export function SemanticError_invalid_signature(): SemanticError {
30033 if(!isWasmInitialized) {
30034 throw new Error("initializeWasm() must be awaited first!");
30036 const nativeResponseValue = wasm.TS_SemanticError_invalid_signature();
30037 return nativeResponseValue;
30039 // enum LDKSemanticError SemanticError_imprecise_amount(void);
30041 export function SemanticError_imprecise_amount(): SemanticError {
30042 if(!isWasmInitialized) {
30043 throw new Error("initializeWasm() must be awaited first!");
30045 const nativeResponseValue = wasm.TS_SemanticError_imprecise_amount();
30046 return nativeResponseValue;
30048 // bool SemanticError_eq(const enum LDKSemanticError *NONNULL_PTR a, const enum LDKSemanticError *NONNULL_PTR b);
30050 export function SemanticError_eq(a: number, b: number): boolean {
30051 if(!isWasmInitialized) {
30052 throw new Error("initializeWasm() must be awaited first!");
30054 const nativeResponseValue = wasm.TS_SemanticError_eq(a, b);
30055 return nativeResponseValue;
30057 // struct LDKStr SemanticError_to_str(const enum LDKSemanticError *NONNULL_PTR o);
30059 export function SemanticError_to_str(o: number): number {
30060 if(!isWasmInitialized) {
30061 throw new Error("initializeWasm() must be awaited first!");
30063 const nativeResponseValue = wasm.TS_SemanticError_to_str(o);
30064 return nativeResponseValue;
30066 // void SignOrCreationError_free(struct LDKSignOrCreationError this_ptr);
30068 export function SignOrCreationError_free(this_ptr: number): void {
30069 if(!isWasmInitialized) {
30070 throw new Error("initializeWasm() must be awaited first!");
30072 const nativeResponseValue = wasm.TS_SignOrCreationError_free(this_ptr);
30073 // debug statements here
30075 // uintptr_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg);
30077 export function SignOrCreationError_clone_ptr(arg: number): number {
30078 if(!isWasmInitialized) {
30079 throw new Error("initializeWasm() must be awaited first!");
30081 const nativeResponseValue = wasm.TS_SignOrCreationError_clone_ptr(arg);
30082 return nativeResponseValue;
30084 // struct LDKSignOrCreationError SignOrCreationError_clone(const struct LDKSignOrCreationError *NONNULL_PTR orig);
30086 export function SignOrCreationError_clone(orig: number): number {
30087 if(!isWasmInitialized) {
30088 throw new Error("initializeWasm() must be awaited first!");
30090 const nativeResponseValue = wasm.TS_SignOrCreationError_clone(orig);
30091 return nativeResponseValue;
30093 // struct LDKSignOrCreationError SignOrCreationError_sign_error(void);
30095 export function SignOrCreationError_sign_error(): number {
30096 if(!isWasmInitialized) {
30097 throw new Error("initializeWasm() must be awaited first!");
30099 const nativeResponseValue = wasm.TS_SignOrCreationError_sign_error();
30100 return nativeResponseValue;
30102 // struct LDKSignOrCreationError SignOrCreationError_creation_error(enum LDKCreationError a);
30104 export function SignOrCreationError_creation_error(a: CreationError): number {
30105 if(!isWasmInitialized) {
30106 throw new Error("initializeWasm() must be awaited first!");
30108 const nativeResponseValue = wasm.TS_SignOrCreationError_creation_error(a);
30109 return nativeResponseValue;
30111 // bool SignOrCreationError_eq(const struct LDKSignOrCreationError *NONNULL_PTR a, const struct LDKSignOrCreationError *NONNULL_PTR b);
30113 export function SignOrCreationError_eq(a: number, b: number): boolean {
30114 if(!isWasmInitialized) {
30115 throw new Error("initializeWasm() must be awaited first!");
30117 const nativeResponseValue = wasm.TS_SignOrCreationError_eq(a, b);
30118 return nativeResponseValue;
30120 // struct LDKStr SignOrCreationError_to_str(const struct LDKSignOrCreationError *NONNULL_PTR o);
30122 export function SignOrCreationError_to_str(o: number): number {
30123 if(!isWasmInitialized) {
30124 throw new Error("initializeWasm() must be awaited first!");
30126 const nativeResponseValue = wasm.TS_SignOrCreationError_to_str(o);
30127 return nativeResponseValue;
30129 // void InvoicePayer_free(struct LDKInvoicePayer this_obj);
30131 export function InvoicePayer_free(this_obj: number): void {
30132 if(!isWasmInitialized) {
30133 throw new Error("initializeWasm() must be awaited first!");
30135 const nativeResponseValue = wasm.TS_InvoicePayer_free(this_obj);
30136 // debug statements here
30138 // void Payer_free(struct LDKPayer this_ptr);
30140 export function Payer_free(this_ptr: number): void {
30141 if(!isWasmInitialized) {
30142 throw new Error("initializeWasm() must be awaited first!");
30144 const nativeResponseValue = wasm.TS_Payer_free(this_ptr);
30145 // debug statements here
30147 // void Router_free(struct LDKRouter this_ptr);
30149 export function Router_free(this_ptr: number): void {
30150 if(!isWasmInitialized) {
30151 throw new Error("initializeWasm() must be awaited first!");
30153 const nativeResponseValue = wasm.TS_Router_free(this_ptr);
30154 // debug statements here
30156 // void RetryAttempts_free(struct LDKRetryAttempts this_obj);
30158 export function RetryAttempts_free(this_obj: number): void {
30159 if(!isWasmInitialized) {
30160 throw new Error("initializeWasm() must be awaited first!");
30162 const nativeResponseValue = wasm.TS_RetryAttempts_free(this_obj);
30163 // debug statements here
30165 // uintptr_t RetryAttempts_get_a(const struct LDKRetryAttempts *NONNULL_PTR this_ptr);
30167 export function RetryAttempts_get_a(this_ptr: number): number {
30168 if(!isWasmInitialized) {
30169 throw new Error("initializeWasm() must be awaited first!");
30171 const nativeResponseValue = wasm.TS_RetryAttempts_get_a(this_ptr);
30172 return nativeResponseValue;
30174 // void RetryAttempts_set_a(struct LDKRetryAttempts *NONNULL_PTR this_ptr, uintptr_t val);
30176 export function RetryAttempts_set_a(this_ptr: number, val: number): void {
30177 if(!isWasmInitialized) {
30178 throw new Error("initializeWasm() must be awaited first!");
30180 const nativeResponseValue = wasm.TS_RetryAttempts_set_a(this_ptr, val);
30181 // debug statements here
30183 // MUST_USE_RES struct LDKRetryAttempts RetryAttempts_new(uintptr_t a_arg);
30185 export function RetryAttempts_new(a_arg: number): number {
30186 if(!isWasmInitialized) {
30187 throw new Error("initializeWasm() must be awaited first!");
30189 const nativeResponseValue = wasm.TS_RetryAttempts_new(a_arg);
30190 return nativeResponseValue;
30192 // uintptr_t RetryAttempts_clone_ptr(LDKRetryAttempts *NONNULL_PTR arg);
30194 export function RetryAttempts_clone_ptr(arg: number): number {
30195 if(!isWasmInitialized) {
30196 throw new Error("initializeWasm() must be awaited first!");
30198 const nativeResponseValue = wasm.TS_RetryAttempts_clone_ptr(arg);
30199 return nativeResponseValue;
30201 // struct LDKRetryAttempts RetryAttempts_clone(const struct LDKRetryAttempts *NONNULL_PTR orig);
30203 export function RetryAttempts_clone(orig: number): number {
30204 if(!isWasmInitialized) {
30205 throw new Error("initializeWasm() must be awaited first!");
30207 const nativeResponseValue = wasm.TS_RetryAttempts_clone(orig);
30208 return nativeResponseValue;
30210 // bool RetryAttempts_eq(const struct LDKRetryAttempts *NONNULL_PTR a, const struct LDKRetryAttempts *NONNULL_PTR b);
30212 export function RetryAttempts_eq(a: number, b: number): boolean {
30213 if(!isWasmInitialized) {
30214 throw new Error("initializeWasm() must be awaited first!");
30216 const nativeResponseValue = wasm.TS_RetryAttempts_eq(a, b);
30217 return nativeResponseValue;
30219 // uint64_t RetryAttempts_hash(const struct LDKRetryAttempts *NONNULL_PTR o);
30221 export function RetryAttempts_hash(o: number): bigint {
30222 if(!isWasmInitialized) {
30223 throw new Error("initializeWasm() must be awaited first!");
30225 const nativeResponseValue = wasm.TS_RetryAttempts_hash(o);
30226 return nativeResponseValue;
30228 // void PaymentError_free(struct LDKPaymentError this_ptr);
30230 export function PaymentError_free(this_ptr: number): void {
30231 if(!isWasmInitialized) {
30232 throw new Error("initializeWasm() must be awaited first!");
30234 const nativeResponseValue = wasm.TS_PaymentError_free(this_ptr);
30235 // debug statements here
30237 // uintptr_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg);
30239 export function PaymentError_clone_ptr(arg: number): number {
30240 if(!isWasmInitialized) {
30241 throw new Error("initializeWasm() must be awaited first!");
30243 const nativeResponseValue = wasm.TS_PaymentError_clone_ptr(arg);
30244 return nativeResponseValue;
30246 // struct LDKPaymentError PaymentError_clone(const struct LDKPaymentError *NONNULL_PTR orig);
30248 export function PaymentError_clone(orig: number): number {
30249 if(!isWasmInitialized) {
30250 throw new Error("initializeWasm() must be awaited first!");
30252 const nativeResponseValue = wasm.TS_PaymentError_clone(orig);
30253 return nativeResponseValue;
30255 // struct LDKPaymentError PaymentError_invoice(struct LDKStr a);
30257 export function PaymentError_invoice(a: number): number {
30258 if(!isWasmInitialized) {
30259 throw new Error("initializeWasm() must be awaited first!");
30261 const nativeResponseValue = wasm.TS_PaymentError_invoice(a);
30262 return nativeResponseValue;
30264 // struct LDKPaymentError PaymentError_routing(struct LDKLightningError a);
30266 export function PaymentError_routing(a: number): number {
30267 if(!isWasmInitialized) {
30268 throw new Error("initializeWasm() must be awaited first!");
30270 const nativeResponseValue = wasm.TS_PaymentError_routing(a);
30271 return nativeResponseValue;
30273 // struct LDKPaymentError PaymentError_sending(struct LDKPaymentSendFailure a);
30275 export function PaymentError_sending(a: number): number {
30276 if(!isWasmInitialized) {
30277 throw new Error("initializeWasm() must be awaited first!");
30279 const nativeResponseValue = wasm.TS_PaymentError_sending(a);
30280 return nativeResponseValue;
30282 // 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);
30284 export function InvoicePayer_new(payer: number, router: number, scorer: number, logger: number, event_handler: number, retry_attempts: number): number {
30285 if(!isWasmInitialized) {
30286 throw new Error("initializeWasm() must be awaited first!");
30288 const nativeResponseValue = wasm.TS_InvoicePayer_new(payer, router, scorer, logger, event_handler, retry_attempts);
30289 return nativeResponseValue;
30291 // MUST_USE_RES struct LDKCResult_PaymentIdPaymentErrorZ InvoicePayer_pay_invoice(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const struct LDKInvoice *NONNULL_PTR invoice);
30293 export function InvoicePayer_pay_invoice(this_arg: number, invoice: number): number {
30294 if(!isWasmInitialized) {
30295 throw new Error("initializeWasm() must be awaited first!");
30297 const nativeResponseValue = wasm.TS_InvoicePayer_pay_invoice(this_arg, invoice);
30298 return nativeResponseValue;
30300 // 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);
30302 export function InvoicePayer_pay_zero_value_invoice(this_arg: number, invoice: number, amount_msats: bigint): number {
30303 if(!isWasmInitialized) {
30304 throw new Error("initializeWasm() must be awaited first!");
30306 const nativeResponseValue = wasm.TS_InvoicePayer_pay_zero_value_invoice(this_arg, invoice, amount_msats);
30307 return nativeResponseValue;
30309 // 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);
30311 export function InvoicePayer_pay_pubkey(this_arg: number, pubkey: number, payment_preimage: number, amount_msats: bigint, final_cltv_expiry_delta: number): number {
30312 if(!isWasmInitialized) {
30313 throw new Error("initializeWasm() must be awaited first!");
30315 const nativeResponseValue = wasm.TS_InvoicePayer_pay_pubkey(this_arg, pubkey, payment_preimage, amount_msats, final_cltv_expiry_delta);
30316 return nativeResponseValue;
30318 // void InvoicePayer_remove_cached_payment(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
30320 export function InvoicePayer_remove_cached_payment(this_arg: number, payment_hash: number): void {
30321 if(!isWasmInitialized) {
30322 throw new Error("initializeWasm() must be awaited first!");
30324 const nativeResponseValue = wasm.TS_InvoicePayer_remove_cached_payment(this_arg, payment_hash);
30325 // debug statements here
30327 // struct LDKEventHandler InvoicePayer_as_EventHandler(const struct LDKInvoicePayer *NONNULL_PTR this_arg);
30329 export function InvoicePayer_as_EventHandler(this_arg: number): number {
30330 if(!isWasmInitialized) {
30331 throw new Error("initializeWasm() must be awaited first!");
30333 const nativeResponseValue = wasm.TS_InvoicePayer_as_EventHandler(this_arg);
30334 return nativeResponseValue;
30336 // 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);
30338 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 {
30339 if(!isWasmInitialized) {
30340 throw new Error("initializeWasm() must be awaited first!");
30342 const nativeResponseValue = wasm.TS_create_invoice_from_channelmanager_and_duration_since_epoch(channelmanager, keys_manager, network, amt_msat, description, duration_since_epoch);
30343 return nativeResponseValue;
30345 // void DefaultRouter_free(struct LDKDefaultRouter this_obj);
30347 export function DefaultRouter_free(this_obj: number): void {
30348 if(!isWasmInitialized) {
30349 throw new Error("initializeWasm() must be awaited first!");
30351 const nativeResponseValue = wasm.TS_DefaultRouter_free(this_obj);
30352 // debug statements here
30354 // MUST_USE_RES struct LDKDefaultRouter DefaultRouter_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger);
30356 export function DefaultRouter_new(network_graph: number, logger: number): number {
30357 if(!isWasmInitialized) {
30358 throw new Error("initializeWasm() must be awaited first!");
30360 const nativeResponseValue = wasm.TS_DefaultRouter_new(network_graph, logger);
30361 return nativeResponseValue;
30363 // struct LDKRouter DefaultRouter_as_Router(const struct LDKDefaultRouter *NONNULL_PTR this_arg);
30365 export function DefaultRouter_as_Router(this_arg: number): number {
30366 if(!isWasmInitialized) {
30367 throw new Error("initializeWasm() must be awaited first!");
30369 const nativeResponseValue = wasm.TS_DefaultRouter_as_Router(this_arg);
30370 return nativeResponseValue;
30372 // struct LDKPayer ChannelManager_as_Payer(const struct LDKChannelManager *NONNULL_PTR this_arg);
30374 export function ChannelManager_as_Payer(this_arg: number): number {
30375 if(!isWasmInitialized) {
30376 throw new Error("initializeWasm() must be awaited first!");
30378 const nativeResponseValue = wasm.TS_ChannelManager_as_Payer(this_arg);
30379 return nativeResponseValue;
30381 // struct LDKCResult_SiPrefixNoneZ SiPrefix_from_str(struct LDKStr s);
30383 export function SiPrefix_from_str(s: number): number {
30384 if(!isWasmInitialized) {
30385 throw new Error("initializeWasm() must be awaited first!");
30387 const nativeResponseValue = wasm.TS_SiPrefix_from_str(s);
30388 return nativeResponseValue;
30390 // struct LDKCResult_InvoiceNoneZ Invoice_from_str(struct LDKStr s);
30392 export function Invoice_from_str(s: number): number {
30393 if(!isWasmInitialized) {
30394 throw new Error("initializeWasm() must be awaited first!");
30396 const nativeResponseValue = wasm.TS_Invoice_from_str(s);
30397 return nativeResponseValue;
30399 // struct LDKCResult_SignedRawInvoiceNoneZ SignedRawInvoice_from_str(struct LDKStr s);
30401 export function SignedRawInvoice_from_str(s: number): number {
30402 if(!isWasmInitialized) {
30403 throw new Error("initializeWasm() must be awaited first!");
30405 const nativeResponseValue = wasm.TS_SignedRawInvoice_from_str(s);
30406 return nativeResponseValue;
30408 // struct LDKStr Invoice_to_str(const struct LDKInvoice *NONNULL_PTR o);
30410 export function Invoice_to_str(o: number): number {
30411 if(!isWasmInitialized) {
30412 throw new Error("initializeWasm() must be awaited first!");
30414 const nativeResponseValue = wasm.TS_Invoice_to_str(o);
30415 return nativeResponseValue;
30417 // struct LDKStr SignedRawInvoice_to_str(const struct LDKSignedRawInvoice *NONNULL_PTR o);
30419 export function SignedRawInvoice_to_str(o: number): number {
30420 if(!isWasmInitialized) {
30421 throw new Error("initializeWasm() must be awaited first!");
30423 const nativeResponseValue = wasm.TS_SignedRawInvoice_to_str(o);
30424 return nativeResponseValue;
30426 // struct LDKStr Currency_to_str(const enum LDKCurrency *NONNULL_PTR o);
30428 export function Currency_to_str(o: number): number {
30429 if(!isWasmInitialized) {
30430 throw new Error("initializeWasm() must be awaited first!");
30432 const nativeResponseValue = wasm.TS_Currency_to_str(o);
30433 return nativeResponseValue;
30435 // struct LDKStr SiPrefix_to_str(const enum LDKSiPrefix *NONNULL_PTR o);
30437 export function SiPrefix_to_str(o: number): number {
30438 if(!isWasmInitialized) {
30439 throw new Error("initializeWasm() must be awaited first!");
30441 const nativeResponseValue = wasm.TS_SiPrefix_to_str(o);
30442 return nativeResponseValue;
30446 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) {
30447 const weak: WeakRef<object> = js_objs[obj_ptr];
30448 if (weak == null || weak == undefined) {
30449 console.error("Got function call on unknown/free'd JS object!");
30450 throw new Error("Got function call on unknown/free'd JS object!");
30452 const obj: object = weak.deref();
30453 if (obj == null || obj == undefined) {
30454 console.error("Got function call on GC'd JS object!");
30455 throw new Error("Got function call on GC'd JS object!");
30459 case 0: fn = Object.getOwnPropertyDescriptor(obj, "get_per_commitment_point"); break;
30460 case 1: fn = Object.getOwnPropertyDescriptor(obj, "release_commitment_secret"); break;
30461 case 2: fn = Object.getOwnPropertyDescriptor(obj, "validate_holder_commitment"); break;
30462 case 3: fn = Object.getOwnPropertyDescriptor(obj, "channel_keys_id"); break;
30463 case 4: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_commitment"); break;
30464 case 5: fn = Object.getOwnPropertyDescriptor(obj, "validate_counterparty_revocation"); break;
30465 case 6: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_commitment_and_htlcs"); break;
30466 case 7: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_output"); break;
30467 case 8: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_htlc"); break;
30468 case 9: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_htlc_transaction"); break;
30469 case 10: fn = Object.getOwnPropertyDescriptor(obj, "sign_closing_transaction"); break;
30470 case 11: fn = Object.getOwnPropertyDescriptor(obj, "sign_channel_announcement"); break;
30471 case 12: fn = Object.getOwnPropertyDescriptor(obj, "ready_channel"); break;
30472 case 13: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
30473 case 14: fn = Object.getOwnPropertyDescriptor(obj, "watch_channel"); break;
30474 case 15: fn = Object.getOwnPropertyDescriptor(obj, "update_channel"); break;
30475 case 16: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_monitor_events"); break;
30476 case 17: fn = Object.getOwnPropertyDescriptor(obj, "broadcast_transaction"); break;
30477 case 18: fn = Object.getOwnPropertyDescriptor(obj, "get_node_secret"); break;
30478 case 19: fn = Object.getOwnPropertyDescriptor(obj, "get_destination_script"); break;
30479 case 20: fn = Object.getOwnPropertyDescriptor(obj, "get_shutdown_scriptpubkey"); break;
30480 case 21: fn = Object.getOwnPropertyDescriptor(obj, "get_channel_signer"); break;
30481 case 22: fn = Object.getOwnPropertyDescriptor(obj, "get_secure_random_bytes"); break;
30482 case 23: fn = Object.getOwnPropertyDescriptor(obj, "read_chan_signer"); break;
30483 case 24: fn = Object.getOwnPropertyDescriptor(obj, "sign_invoice"); break;
30484 case 25: fn = Object.getOwnPropertyDescriptor(obj, "get_inbound_payment_key_material"); break;
30485 case 26: fn = Object.getOwnPropertyDescriptor(obj, "get_est_sat_per_1000_weight"); break;
30486 case 27: fn = Object.getOwnPropertyDescriptor(obj, "log"); break;
30487 case 28: fn = Object.getOwnPropertyDescriptor(obj, "type_id"); break;
30488 case 29: fn = Object.getOwnPropertyDescriptor(obj, "debug_str"); break;
30489 case 30: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
30490 case 31: fn = Object.getOwnPropertyDescriptor(obj, "get_utxo"); break;
30491 case 32: fn = Object.getOwnPropertyDescriptor(obj, "register_tx"); break;
30492 case 33: fn = Object.getOwnPropertyDescriptor(obj, "register_output"); break;
30493 case 34: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg_events"); break;
30494 case 35: fn = Object.getOwnPropertyDescriptor(obj, "handle_event"); break;
30495 case 36: fn = Object.getOwnPropertyDescriptor(obj, "process_pending_events"); break;
30496 case 37: fn = Object.getOwnPropertyDescriptor(obj, "block_connected"); break;
30497 case 38: fn = Object.getOwnPropertyDescriptor(obj, "block_disconnected"); break;
30498 case 39: fn = Object.getOwnPropertyDescriptor(obj, "transactions_confirmed"); break;
30499 case 40: fn = Object.getOwnPropertyDescriptor(obj, "transaction_unconfirmed"); break;
30500 case 41: fn = Object.getOwnPropertyDescriptor(obj, "best_block_updated"); break;
30501 case 42: fn = Object.getOwnPropertyDescriptor(obj, "get_relevant_txids"); break;
30502 case 43: fn = Object.getOwnPropertyDescriptor(obj, "persist_new_channel"); break;
30503 case 44: fn = Object.getOwnPropertyDescriptor(obj, "update_persisted_channel"); break;
30504 case 45: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel"); break;
30505 case 46: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel"); break;
30506 case 47: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_created"); break;
30507 case 48: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_signed"); break;
30508 case 49: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_locked"); break;
30509 case 50: fn = Object.getOwnPropertyDescriptor(obj, "handle_shutdown"); break;
30510 case 51: fn = Object.getOwnPropertyDescriptor(obj, "handle_closing_signed"); break;
30511 case 52: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_add_htlc"); break;
30512 case 53: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fulfill_htlc"); break;
30513 case 54: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_htlc"); break;
30514 case 55: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_malformed_htlc"); break;
30515 case 56: fn = Object.getOwnPropertyDescriptor(obj, "handle_commitment_signed"); break;
30516 case 57: fn = Object.getOwnPropertyDescriptor(obj, "handle_revoke_and_ack"); break;
30517 case 58: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fee"); break;
30518 case 59: fn = Object.getOwnPropertyDescriptor(obj, "handle_announcement_signatures"); break;
30519 case 60: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
30520 case 61: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
30521 case 62: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_reestablish"); break;
30522 case 63: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
30523 case 64: fn = Object.getOwnPropertyDescriptor(obj, "handle_error"); break;
30524 case 65: fn = Object.getOwnPropertyDescriptor(obj, "handle_node_announcement"); break;
30525 case 66: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_announcement"); break;
30526 case 67: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
30527 case 68: fn = Object.getOwnPropertyDescriptor(obj, "get_next_channel_announcements"); break;
30528 case 69: fn = Object.getOwnPropertyDescriptor(obj, "get_next_node_announcements"); break;
30529 case 70: fn = Object.getOwnPropertyDescriptor(obj, "sync_routing_table"); break;
30530 case 71: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_channel_range"); break;
30531 case 72: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_short_channel_ids_end"); break;
30532 case 73: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_channel_range"); break;
30533 case 74: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_short_channel_ids"); break;
30534 case 75: fn = Object.getOwnPropertyDescriptor(obj, "read"); break;
30535 case 76: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
30536 case 77: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg"); break;
30537 case 78: fn = Object.getOwnPropertyDescriptor(obj, "send_data"); break;
30538 case 79: fn = Object.getOwnPropertyDescriptor(obj, "disconnect_socket"); break;
30539 case 80: fn = Object.getOwnPropertyDescriptor(obj, "eq"); break;
30540 case 81: fn = Object.getOwnPropertyDescriptor(obj, "hash"); break;
30541 case 82: fn = Object.getOwnPropertyDescriptor(obj, "channel_penalty_msat"); break;
30542 case 83: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_failed"); break;
30543 case 84: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_successful"); break;
30544 case 85: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
30545 case 86: fn = Object.getOwnPropertyDescriptor(obj, "lock"); break;
30546 case 87: fn = Object.getOwnPropertyDescriptor(obj, "node_id"); break;
30547 case 88: fn = Object.getOwnPropertyDescriptor(obj, "first_hops"); break;
30548 case 89: fn = Object.getOwnPropertyDescriptor(obj, "send_payment"); break;
30549 case 90: fn = Object.getOwnPropertyDescriptor(obj, "send_spontaneous_payment"); break;
30550 case 91: fn = Object.getOwnPropertyDescriptor(obj, "retry_payment"); break;
30551 case 92: fn = Object.getOwnPropertyDescriptor(obj, "abandon_payment"); break;
30552 case 93: fn = Object.getOwnPropertyDescriptor(obj, "find_route"); break;
30554 console.error("Got unknown function call from C!");
30555 throw new Error("Got unknown function call from C!");
30557 if (fn == null || fn == undefined) {
30558 console.error("Got function call on incorrect JS object!");
30559 throw new Error("Got function call on incorrect JS object!");
30561 return fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);