2 import * as version from './version.mjs';
3 import { UInt5, WitnessVersion } from './structs/CommonBase.mjs';
5 const imports: any = {};
8 var js_objs: Array<WeakRef<object>> = [];
9 var js_invoke: Function;
10 var getRandomValues: Function;
12 imports.wasi_snapshot_preview1 = {
13 "fd_write": (fd: number, iovec_array_ptr: number, iovec_array_len: number, bytes_written_ptr: number) => {
14 // This should generally only be used to print panic messages
15 const ptr_len_view = new Uint32Array(wasm.memory.buffer, iovec_array_ptr, iovec_array_len * 2);
16 var bytes_written = 0;
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("[fd " + fd + "]: " + String.fromCharCode(...bytes_view));
20 bytes_written += ptr_len_view[i*2+1];
22 const written_view = new Uint32Array(wasm.memory.buffer, bytes_written_ptr, 1);
23 written_view[0] = bytes_written;
26 "fd_close": (_fd: number) => {
27 // This is not generally called, but may be referenced in debug builds
28 console.log("wasi_snapshot_preview1:fd_close");
29 return 58; // Not Supported
31 "fd_seek": (_fd: number, _offset: bigint, _whence: number, _new_offset: number) => {
32 // This is not generally called, but may be referenced in debug builds
33 console.log("wasi_snapshot_preview1:fd_seek");
34 return 58; // Not Supported
36 "random_get": (buf_ptr: number, buf_len: number) => {
37 const buf = new Uint8Array(wasm.memory.buffer, buf_ptr, buf_len);
41 "environ_sizes_get": (environ_var_count_ptr: number, environ_len_ptr: number) => {
42 // This is called before fd_write to format + print panic messages
43 const out_count_view = new Uint32Array(wasm.memory.buffer, environ_var_count_ptr, 1);
44 out_count_view[0] = 0;
45 const out_len_view = new Uint32Array(wasm.memory.buffer, environ_len_ptr, 1);
49 "environ_get": (environ_ptr: number, environ_buf_ptr: number) => {
50 // This is called before fd_write to format + print panic messages,
51 // but only if we have variables in environ_sizes_get, so shouldn't ever actually happen!
52 console.log("wasi_snapshot_preview1:environ_get");
53 return 58; // Note supported - we said there were 0 environment entries!
56 console.log("wasi_snapshot_preview1:proc_exit");
61 let isWasmInitialized: boolean = false;
63 async function finishInitializeWasm(wasmInstance: WebAssembly.Instance) {
64 if (typeof crypto === "undefined") {
65 var crypto_import = (await import('crypto')).webcrypto;
66 getRandomValues = crypto_import.getRandomValues.bind(crypto_import);
68 getRandomValues = crypto.getRandomValues.bind(crypto);
71 wasm = wasmInstance.exports;
72 if (!wasm.test_bigint_pass_deadbeef0badf00d(BigInt("0xdeadbeef0badf00d"))) {
73 throw new Error("Currently need BigInt-as-u64 support, try ----experimental-wasm-bigint");
76 if (decodeString(wasm.TS_get_lib_version_string()) !== version.get_ldk_java_bindings_version())
77 throw new Error("Compiled LDK library and LDK class files do not match");
78 // Fetching the LDK versions from C also checks that the header and binaries match
79 const c_bindings_ver: number = wasm.TS_get_ldk_c_bindings_version();
80 const ldk_ver: number = wasm.TS_get_ldk_version();
81 if (c_bindings_ver == 0)
82 throw new Error("LDK version did not match the header we built against");
84 throw new Error("LDK C bindings version did not match the header we built against");
85 const c_bindings_version: string = decodeString(c_bindings_ver)
86 const ldk_version: string = decodeString(ldk_ver);
87 console.log("Loaded LDK-Java Bindings with LDK " + ldk_version + " and LDK-C-Bindings " + c_bindings_version);
89 isWasmInitialized = true;
92 const fn_list = ["uuuuuu", "buuuuu", "bbuuuu", "bbbuuu", "bbbbuu",
93 "bbbbbb", "ubuubu", "ubuuuu", "ubbuuu", "uubuuu", "uububu"];
96 export async function initializeWasmFromUint8Array(wasmBinary: Uint8Array) {
97 for (const fn of fn_list) { imports.env["js_invoke_function_" + fn] = js_invoke; }
98 const { instance: wasmInstance } = await WebAssembly.instantiate(wasmBinary, imports);
99 await finishInitializeWasm(wasmInstance);
103 export async function initializeWasmFetch(uri: string) {
104 for (const fn of fn_list) { imports.env["js_invoke_function_" + fn] = js_invoke; }
105 const stream = fetch(uri);
106 const { instance: wasmInstance } = await WebAssembly.instantiateStreaming(stream, imports);
107 await finishInitializeWasm(wasmInstance);
112 export function uint5ArrToBytes(inputArray: Array<UInt5>): Uint8Array {
113 const arr = new Uint8Array(inputArray.length);
114 for (var i = 0; i < inputArray.length; i++) {
115 arr[i] = inputArray[i].getVal();
121 export function WitnessVersionArrToBytes(inputArray: Array<WitnessVersion>): Uint8Array {
122 const arr = new Uint8Array(inputArray.length);
123 for (var i = 0; i < inputArray.length; i++) {
124 arr[i] = inputArray[i].getVal();
132 export function encodeUint8Array (inputArray: Uint8Array): number {
133 const cArrayPointer = wasm.TS_malloc(inputArray.length + 8);
134 const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
135 arrayLengthView[0] = BigInt(inputArray.length);
136 const arrayMemoryView = new Uint8Array(wasm.memory.buffer, cArrayPointer + 8, inputArray.length);
137 arrayMemoryView.set(inputArray);
138 return cArrayPointer;
141 export function encodeUint32Array (inputArray: Uint32Array|Array<number>): number {
142 const cArrayPointer = wasm.TS_malloc((inputArray.length + 2) * 4);
143 const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
144 arrayLengthView[0] = BigInt(inputArray.length);
145 const arrayMemoryView = new Uint32Array(wasm.memory.buffer, cArrayPointer + 8, inputArray.length);
146 arrayMemoryView.set(inputArray);
147 return cArrayPointer;
150 export function encodeUint64Array (inputArray: BigUint64Array|Array<bigint>): number {
151 const cArrayPointer = wasm.TS_malloc((inputArray.length + 1) * 8);
152 const arrayMemoryView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, inputArray.length + 1);
153 arrayMemoryView[0] = BigInt(inputArray.length);
154 arrayMemoryView.set(inputArray, 1);
155 return cArrayPointer;
159 export function check_arr_len(arr: Uint8Array, len: number): Uint8Array {
160 if (arr.length != len) { throw new Error("Expected array of length " + len + " got " + arr.length); }
165 export function getArrayLength(arrayPointer: number): number {
166 const arraySizeViewer = new BigUint64Array(wasm.memory.buffer, arrayPointer, 1);
167 const len = arraySizeViewer[0];
168 if (len >= (2n ** 32n)) throw new Error("Bogus Array Size");
169 return Number(len % (2n ** 32n));
172 export function decodeUint8Array (arrayPointer: number, free = true): Uint8Array {
173 const arraySize = getArrayLength(arrayPointer);
174 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 8, arraySize);
175 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
176 // will free the underlying memory when it becomes unreachable instead of copying here.
177 // Note that doing so may have edge-case interactions with memory resizing (invalidating the buffer).
178 const actualArray = actualArrayViewer.slice(0, arraySize);
180 wasm.TS_free(arrayPointer);
184 const decodeUint32Array = (arrayPointer: number, free = true) => {
185 const arraySize = getArrayLength(arrayPointer);
186 const actualArrayViewer = new Uint32Array(
187 wasm.memory.buffer, // value
188 arrayPointer + 8, // offset (ignoring length bytes)
189 arraySize // uint32 count
191 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
192 // will free the underlying memory when it becomes unreachable instead of copying here.
193 const actualArray = actualArrayViewer.slice(0, arraySize);
195 wasm.TS_free(arrayPointer);
200 export function decodeUint64Array (arrayPointer: number, free = true): bigint[] {
201 const arraySize = getArrayLength(arrayPointer);
202 const actualArrayViewer = new BigUint64Array(
203 wasm.memory.buffer, // value
204 arrayPointer + 8, // offset (ignoring length bytes)
205 arraySize // uint32 count
207 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
208 // will free the underlying memory when it becomes unreachable instead of copying here.
209 const actualArray = new Array(arraySize);
210 for (var i = 0; i < arraySize; i++) actualArray[i] = actualArrayViewer[i];
212 wasm.TS_free(arrayPointer);
217 export function freeWasmMemory(pointer: number) { wasm.TS_free(pointer); }
220 export function getU64ArrayElem(arrayPointer: number, idx: number): bigint {
221 const actualArrayViewer = new BigUint64Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
222 return actualArrayViewer[idx];
226 export function getU32ArrayElem(arrayPointer: number, idx: number): number {
227 const actualArrayViewer = new Uint32Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
228 return actualArrayViewer[idx];
232 export function getU8ArrayElem(arrayPointer: number, idx: number): number {
233 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
234 return actualArrayViewer[idx];
239 export function encodeString(str: string): number {
240 const charArray = new TextEncoder().encode(str);
241 return encodeUint8Array(charArray);
245 export function decodeString(stringPointer: number, free = true): string {
246 const arraySize = getArrayLength(stringPointer);
247 const memoryView = new Uint8Array(wasm.memory.buffer, stringPointer + 8, arraySize);
248 const result = new TextDecoder("utf-8").decode(memoryView);
251 wasm.TS_free(stringPointer);
257 /* @internal */ export function getRemainingAllocationCount(): number { return 0; }
258 /* @internal */ export function debugPrintRemainingAllocs() { }
261 * An error when accessing the chain via [`Access`].
263 export enum AccessError {
265 * The requested chain is unknown.
267 LDKAccessError_UnknownChain,
269 * The requested transaction doesn't exist or hasn't confirmed.
271 LDKAccessError_UnknownTx,
276 * An enum which can either contain a or not
278 export enum COption_NoneZ {
280 * When we're in this state, this COption_NoneZ contains a
282 LDKCOption_NoneZ_Some,
284 * When we're in this state, this COption_NoneZ contains nothing
286 LDKCOption_NoneZ_None,
291 * An error enum representing a failure to persist a channel monitor update.
293 export enum ChannelMonitorUpdateErr {
295 * Used to indicate a temporary failure (eg connection to a watchtower or remote backup of
296 our state failed, but is expected to succeed at some point in the future).
298 Such a failure will \"freeze\" a channel, preventing us from revoking old states or
299 submitting new commitment transactions to the counterparty. Once the update(s) that failed
300 have been successfully applied, a [`MonitorEvent::UpdateCompleted`] event should be returned
301 via [`Watch::release_pending_monitor_events`] which will then restore the channel to an
304 Note that a given ChannelManager will *never* re-generate a given ChannelMonitorUpdate. If
305 you return a TemporaryFailure you must ensure that it is written to disk safely before
306 writing out the latest ChannelManager state.
308 Even when a channel has been \"frozen\" updates to the ChannelMonitor can continue to occur
309 (eg if an inbound HTLC which we forwarded was claimed upstream resulting in us attempting
310 to claim it on this channel) and those updates must be applied wherever they can be. At
311 least one such updated ChannelMonitor must be persisted otherwise PermanentFailure should
312 be returned to get things on-chain ASAP using only the in-memory copy. Obviously updates to
313 the channel which would invalidate previous ChannelMonitors are not made when a channel has
316 Note that even if updates made after TemporaryFailure succeed you must still provide a
317 [`MonitorEvent::UpdateCompleted`] to ensure you have the latest monitor and re-enable
318 normal channel operation. Note that this is normally generated through a call to
319 [`ChainMonitor::channel_monitor_updated`].
321 Note that the update being processed here will not be replayed for you when you return a
322 [`MonitorEvent::UpdateCompleted`] event via [`Watch::release_pending_monitor_events`], so
323 you must store the update itself on your own local disk prior to returning a
324 TemporaryFailure. You may, of course, employ a journaling approach, storing only the
325 ChannelMonitorUpdate on disk without updating the monitor itself, replaying the journal at
328 For deployments where a copy of ChannelMonitors and other local state are backed up in a
329 remote location (with local copies persisted immediately), it is anticipated that all
330 updates will return TemporaryFailure until the remote copies could be updated.
332 [`ChainMonitor::channel_monitor_updated`]: chainmonitor::ChainMonitor::channel_monitor_updated
334 LDKChannelMonitorUpdateErr_TemporaryFailure,
336 * Used to indicate no further channel monitor updates will be allowed (eg we've moved on to a
337 different watchtower and cannot update with all watchtowers that were previously informed
340 At reception of this error, ChannelManager will force-close the channel and return at
341 least a final ChannelMonitorUpdate::ChannelForceClosed which must be delivered to at
342 least one ChannelMonitor copy. Revocation secret MUST NOT be released and offchain channel
343 update must be rejected.
345 This failure may also signal a failure to update the local persisted copy of one of
346 the channel monitor instance.
348 Note that even when you fail a holder commitment transaction update, you must store the
349 update to ensure you can claim from it in case of a duplicate copy of this ChannelMonitor
350 broadcasts it (e.g distributed channel-monitor deployment)
352 In case of distributed watchtowers deployment, the new version must be written to disk, as
353 state may have been stored but rejected due to a block forcing a commitment broadcast. This
354 storage is used to claim outputs of rejected state confirmed onchain by another watchtower,
355 lagging behind on block processing.
357 LDKChannelMonitorUpdateErr_PermanentFailure,
362 * An enum that represents the speed at which we want a transaction to confirm used for feerate
365 export enum ConfirmationTarget {
367 * We are happy with this transaction confirming slowly when feerate drops some.
369 LDKConfirmationTarget_Background,
371 * We'd like this transaction to confirm without major delay, but 12-18 blocks is fine.
373 LDKConfirmationTarget_Normal,
375 * We'd like this transaction to confirm in the next few blocks.
377 LDKConfirmationTarget_HighPriority,
382 * Errors that may occur when constructing a new `RawInvoice` or `Invoice`
384 export enum CreationError {
386 * The supplied description string was longer than 639 __bytes__ (see [`Description::new(...)`](./struct.Description.html#method.new))
388 LDKCreationError_DescriptionTooLong,
390 * The specified route has too many hops and can't be encoded
392 LDKCreationError_RouteTooLong,
394 * The Unix timestamp of the supplied date is less than zero or greater than 35-bits
396 LDKCreationError_TimestampOutOfBounds,
398 * The supplied millisatoshi amount was greater than the total bitcoin supply.
400 LDKCreationError_InvalidAmount,
402 * Route hints were required for this invoice and were missing. Applies to
405 [phantom invoices]: crate::utils::create_phantom_invoice
407 LDKCreationError_MissingRouteHints,
412 * Enum representing the crypto currencies (or networks) supported by this library
414 export enum Currency {
422 LDKCurrency_BitcoinTestnet,
439 * Represents an IO Error. Note that some information is lost in the conversion from Rust.
441 export enum IOError {
443 LDKIOError_PermissionDenied,
444 LDKIOError_ConnectionRefused,
445 LDKIOError_ConnectionReset,
446 LDKIOError_ConnectionAborted,
447 LDKIOError_NotConnected,
448 LDKIOError_AddrInUse,
449 LDKIOError_AddrNotAvailable,
450 LDKIOError_BrokenPipe,
451 LDKIOError_AlreadyExists,
452 LDKIOError_WouldBlock,
453 LDKIOError_InvalidInput,
454 LDKIOError_InvalidData,
456 LDKIOError_WriteZero,
457 LDKIOError_Interrupted,
459 LDKIOError_UnexpectedEof,
464 * An enum representing the available verbosity levels of the logger.
468 * Designates extremely verbose information, including gossip-induced messages
472 * Designates very low priority, often extremely verbose, information
476 * Designates lower priority information
480 * Designates useful information
484 * Designates hazardous situations
488 * Designates very serious errors
495 * An enum representing the possible Bitcoin or test networks which we can run on
497 export enum Network {
499 * The main Bitcoin blockchain.
503 * The testnet3 blockchain.
507 * A local test blockchain.
511 * A blockchain on which blocks are signed instead of mined.
518 * Specifies the recipient of an invoice, to indicate to [`KeysInterface::sign_invoice`] what node
519 * secret key should be used to sign the invoice.
521 export enum Recipient {
523 * The invoice should be signed with the local node secret key.
527 * The invoice should be signed with the phantom node secret key. This secret key must be the
528 same for all nodes participating in the [phantom node payment].
530 [phantom node payment]: PhantomKeysManager
532 LDKRecipient_PhantomNode,
537 * Represents an error returned from libsecp256k1 during validation of some secp256k1 data
539 export enum Secp256k1Error {
541 * Signature failed verification
543 LDKSecp256k1Error_IncorrectSignature,
545 * Badly sized message ("messages" are actually fixed-sized digests; see the MESSAGE_SIZE constant)
547 LDKSecp256k1Error_InvalidMessage,
551 LDKSecp256k1Error_InvalidPublicKey,
555 LDKSecp256k1Error_InvalidSignature,
559 LDKSecp256k1Error_InvalidSecretKey,
563 LDKSecp256k1Error_InvalidSharedSecret,
567 LDKSecp256k1Error_InvalidRecoveryId,
569 * Invalid tweak for add_assign or mul_assign
571 LDKSecp256k1Error_InvalidTweak,
573 * Didn't pass enough memory to context creation with preallocated memory
575 LDKSecp256k1Error_NotEnoughMemory,
577 * Bad set of public keys.
579 LDKSecp256k1Error_InvalidPublicKeySum,
581 * The only valid parity values are 0 or 1.
583 LDKSecp256k1Error_InvalidParityValue,
588 * Errors that may occur when converting a `RawInvoice` to an `Invoice`. They relate to the
589 * requirements sections in BOLT #11
591 export enum SemanticError {
593 * The invoice is missing the mandatory payment hash
595 LDKSemanticError_NoPaymentHash,
597 * The invoice has multiple payment hashes which isn't allowed
599 LDKSemanticError_MultiplePaymentHashes,
601 * No description or description hash are part of the invoice
603 LDKSemanticError_NoDescription,
605 * The invoice contains multiple descriptions and/or description hashes which isn't allowed
607 LDKSemanticError_MultipleDescriptions,
609 * The invoice is missing the mandatory payment secret, which all modern lightning nodes
612 LDKSemanticError_NoPaymentSecret,
614 * The invoice contains multiple payment secrets
616 LDKSemanticError_MultiplePaymentSecrets,
618 * The invoice's features are invalid
620 LDKSemanticError_InvalidFeatures,
622 * The recovery id doesn't fit the signature/pub key
624 LDKSemanticError_InvalidRecoveryId,
626 * The invoice's signature is invalid
628 LDKSemanticError_InvalidSignature,
630 * The invoice's amount was not a whole number of millisatoshis
632 LDKSemanticError_ImpreciseAmount,
637 * SI prefixes for the human readable part
639 export enum SiPrefix {
658 // struct LDKThirtyTwoBytes BigEndianScalar_get_bytes (struct LDKBigEndianScalar* thing)
660 export function BigEndianScalar_get_bytes(thing: bigint): number {
661 if(!isWasmInitialized) {
662 throw new Error("initializeWasm() must be awaited first!");
664 const nativeResponseValue = wasm.TS_BigEndianScalar_get_bytes(thing);
665 return nativeResponseValue;
667 // static void BigEndianScalar_free (struct LDKBigEndianScalar thing)
669 export function BigEndianScalar_free(thing: bigint): void {
670 if(!isWasmInitialized) {
671 throw new Error("initializeWasm() must be awaited first!");
673 const nativeResponseValue = wasm.TS_BigEndianScalar_free(thing);
674 // debug statements here
677 export class LDKBech32Error {
678 protected constructor() {}
681 export function LDKBech32Error_ty_from_ptr(ptr: bigint): number {
682 if(!isWasmInitialized) {
683 throw new Error("initializeWasm() must be awaited first!");
685 const nativeResponseValue = wasm.TS_LDKBech32Error_ty_from_ptr(ptr);
686 return nativeResponseValue;
689 export function LDKBech32Error_InvalidChar_get_invalid_char(ptr: bigint): number {
690 if(!isWasmInitialized) {
691 throw new Error("initializeWasm() must be awaited first!");
693 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidChar_get_invalid_char(ptr);
694 return nativeResponseValue;
697 export function LDKBech32Error_InvalidData_get_invalid_data(ptr: bigint): number {
698 if(!isWasmInitialized) {
699 throw new Error("initializeWasm() must be awaited first!");
701 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidData_get_invalid_data(ptr);
702 return nativeResponseValue;
704 // struct LDKCVec_u8Z TxOut_get_script_pubkey (struct LDKTxOut* thing)
706 export function TxOut_get_script_pubkey(thing: bigint): number {
707 if(!isWasmInitialized) {
708 throw new Error("initializeWasm() must be awaited first!");
710 const nativeResponseValue = wasm.TS_TxOut_get_script_pubkey(thing);
711 return nativeResponseValue;
713 // uint64_t TxOut_get_value (struct LDKTxOut* thing)
715 export function TxOut_get_value(thing: bigint): bigint {
716 if(!isWasmInitialized) {
717 throw new Error("initializeWasm() must be awaited first!");
719 const nativeResponseValue = wasm.TS_TxOut_get_value(thing);
720 return nativeResponseValue;
722 // struct LDKBlindedRoute CResult_BlindedRouteNoneZ_get_ok(LDKCResult_BlindedRouteNoneZ *NONNULL_PTR owner);
724 export function CResult_BlindedRouteNoneZ_get_ok(owner: bigint): bigint {
725 if(!isWasmInitialized) {
726 throw new Error("initializeWasm() must be awaited first!");
728 const nativeResponseValue = wasm.TS_CResult_BlindedRouteNoneZ_get_ok(owner);
729 return nativeResponseValue;
731 // void CResult_BlindedRouteNoneZ_get_err(LDKCResult_BlindedRouteNoneZ *NONNULL_PTR owner);
733 export function CResult_BlindedRouteNoneZ_get_err(owner: bigint): void {
734 if(!isWasmInitialized) {
735 throw new Error("initializeWasm() must be awaited first!");
737 const nativeResponseValue = wasm.TS_CResult_BlindedRouteNoneZ_get_err(owner);
738 // debug statements here
740 // struct LDKBlindedRoute CResult_BlindedRouteDecodeErrorZ_get_ok(LDKCResult_BlindedRouteDecodeErrorZ *NONNULL_PTR owner);
742 export function CResult_BlindedRouteDecodeErrorZ_get_ok(owner: bigint): bigint {
743 if(!isWasmInitialized) {
744 throw new Error("initializeWasm() must be awaited first!");
746 const nativeResponseValue = wasm.TS_CResult_BlindedRouteDecodeErrorZ_get_ok(owner);
747 return nativeResponseValue;
749 // struct LDKDecodeError CResult_BlindedRouteDecodeErrorZ_get_err(LDKCResult_BlindedRouteDecodeErrorZ *NONNULL_PTR owner);
751 export function CResult_BlindedRouteDecodeErrorZ_get_err(owner: bigint): bigint {
752 if(!isWasmInitialized) {
753 throw new Error("initializeWasm() must be awaited first!");
755 const nativeResponseValue = wasm.TS_CResult_BlindedRouteDecodeErrorZ_get_err(owner);
756 return nativeResponseValue;
758 // struct LDKBlindedHop CResult_BlindedHopDecodeErrorZ_get_ok(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner);
760 export function CResult_BlindedHopDecodeErrorZ_get_ok(owner: bigint): bigint {
761 if(!isWasmInitialized) {
762 throw new Error("initializeWasm() must be awaited first!");
764 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_get_ok(owner);
765 return nativeResponseValue;
767 // struct LDKDecodeError CResult_BlindedHopDecodeErrorZ_get_err(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner);
769 export function CResult_BlindedHopDecodeErrorZ_get_err(owner: bigint): bigint {
770 if(!isWasmInitialized) {
771 throw new Error("initializeWasm() must be awaited first!");
773 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_get_err(owner);
774 return nativeResponseValue;
776 // void CResult_NoneNoneZ_get_ok(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
778 export function CResult_NoneNoneZ_get_ok(owner: bigint): void {
779 if(!isWasmInitialized) {
780 throw new Error("initializeWasm() must be awaited first!");
782 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_ok(owner);
783 // debug statements here
785 // void CResult_NoneNoneZ_get_err(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
787 export function CResult_NoneNoneZ_get_err(owner: bigint): void {
788 if(!isWasmInitialized) {
789 throw new Error("initializeWasm() must be awaited first!");
791 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_err(owner);
792 // debug statements here
794 // struct LDKCounterpartyCommitmentSecrets CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
796 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner: bigint): bigint {
797 if(!isWasmInitialized) {
798 throw new Error("initializeWasm() must be awaited first!");
800 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner);
801 return nativeResponseValue;
803 // struct LDKDecodeError CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
805 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner: bigint): bigint {
806 if(!isWasmInitialized) {
807 throw new Error("initializeWasm() must be awaited first!");
809 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner);
810 return nativeResponseValue;
812 // struct LDKSecretKey CResult_SecretKeyErrorZ_get_ok(LDKCResult_SecretKeyErrorZ *NONNULL_PTR owner);
814 export function CResult_SecretKeyErrorZ_get_ok(owner: bigint): number {
815 if(!isWasmInitialized) {
816 throw new Error("initializeWasm() must be awaited first!");
818 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_get_ok(owner);
819 return nativeResponseValue;
821 // enum LDKSecp256k1Error CResult_SecretKeyErrorZ_get_err(LDKCResult_SecretKeyErrorZ *NONNULL_PTR owner);
823 export function CResult_SecretKeyErrorZ_get_err(owner: bigint): Secp256k1Error {
824 if(!isWasmInitialized) {
825 throw new Error("initializeWasm() must be awaited first!");
827 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_get_err(owner);
828 return nativeResponseValue;
830 // struct LDKPublicKey CResult_PublicKeyErrorZ_get_ok(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
832 export function CResult_PublicKeyErrorZ_get_ok(owner: bigint): number {
833 if(!isWasmInitialized) {
834 throw new Error("initializeWasm() must be awaited first!");
836 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_ok(owner);
837 return nativeResponseValue;
839 // enum LDKSecp256k1Error CResult_PublicKeyErrorZ_get_err(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
841 export function CResult_PublicKeyErrorZ_get_err(owner: bigint): Secp256k1Error {
842 if(!isWasmInitialized) {
843 throw new Error("initializeWasm() must be awaited first!");
845 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_err(owner);
846 return nativeResponseValue;
848 // struct LDKTxCreationKeys CResult_TxCreationKeysDecodeErrorZ_get_ok(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
850 export function CResult_TxCreationKeysDecodeErrorZ_get_ok(owner: bigint): bigint {
851 if(!isWasmInitialized) {
852 throw new Error("initializeWasm() must be awaited first!");
854 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_ok(owner);
855 return nativeResponseValue;
857 // struct LDKDecodeError CResult_TxCreationKeysDecodeErrorZ_get_err(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
859 export function CResult_TxCreationKeysDecodeErrorZ_get_err(owner: bigint): bigint {
860 if(!isWasmInitialized) {
861 throw new Error("initializeWasm() must be awaited first!");
863 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_err(owner);
864 return nativeResponseValue;
866 // struct LDKChannelPublicKeys CResult_ChannelPublicKeysDecodeErrorZ_get_ok(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
868 export function CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner: bigint): bigint {
869 if(!isWasmInitialized) {
870 throw new Error("initializeWasm() must be awaited first!");
872 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner);
873 return nativeResponseValue;
875 // struct LDKDecodeError CResult_ChannelPublicKeysDecodeErrorZ_get_err(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
877 export function CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner: bigint): bigint {
878 if(!isWasmInitialized) {
879 throw new Error("initializeWasm() must be awaited first!");
881 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner);
882 return nativeResponseValue;
884 // struct LDKTxCreationKeys CResult_TxCreationKeysErrorZ_get_ok(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR owner);
886 export function CResult_TxCreationKeysErrorZ_get_ok(owner: bigint): bigint {
887 if(!isWasmInitialized) {
888 throw new Error("initializeWasm() must be awaited first!");
890 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_get_ok(owner);
891 return nativeResponseValue;
893 // enum LDKSecp256k1Error CResult_TxCreationKeysErrorZ_get_err(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR owner);
895 export function CResult_TxCreationKeysErrorZ_get_err(owner: bigint): Secp256k1Error {
896 if(!isWasmInitialized) {
897 throw new Error("initializeWasm() must be awaited first!");
899 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_get_err(owner);
900 return nativeResponseValue;
903 export class LDKCOption_u32Z {
904 protected constructor() {}
907 export function LDKCOption_u32Z_ty_from_ptr(ptr: bigint): number {
908 if(!isWasmInitialized) {
909 throw new Error("initializeWasm() must be awaited first!");
911 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_ty_from_ptr(ptr);
912 return nativeResponseValue;
915 export function LDKCOption_u32Z_Some_get_some(ptr: bigint): number {
916 if(!isWasmInitialized) {
917 throw new Error("initializeWasm() must be awaited first!");
919 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_Some_get_some(ptr);
920 return nativeResponseValue;
922 // struct LDKHTLCOutputInCommitment CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
924 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner: bigint): bigint {
925 if(!isWasmInitialized) {
926 throw new Error("initializeWasm() must be awaited first!");
928 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner);
929 return nativeResponseValue;
931 // struct LDKDecodeError CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
933 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner: bigint): bigint {
934 if(!isWasmInitialized) {
935 throw new Error("initializeWasm() must be awaited first!");
937 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner);
938 return nativeResponseValue;
940 // struct LDKCounterpartyChannelTransactionParameters CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
942 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
943 if(!isWasmInitialized) {
944 throw new Error("initializeWasm() must be awaited first!");
946 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner);
947 return nativeResponseValue;
949 // struct LDKDecodeError CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
951 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner: bigint): bigint {
952 if(!isWasmInitialized) {
953 throw new Error("initializeWasm() must be awaited first!");
955 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner);
956 return nativeResponseValue;
958 // struct LDKChannelTransactionParameters CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
960 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
961 if(!isWasmInitialized) {
962 throw new Error("initializeWasm() must be awaited first!");
964 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner);
965 return nativeResponseValue;
967 // struct LDKDecodeError CResult_ChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
969 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner: bigint): bigint {
970 if(!isWasmInitialized) {
971 throw new Error("initializeWasm() must be awaited first!");
973 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner);
974 return nativeResponseValue;
976 // struct LDKHolderCommitmentTransaction CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
978 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
979 if(!isWasmInitialized) {
980 throw new Error("initializeWasm() must be awaited first!");
982 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner);
983 return nativeResponseValue;
985 // struct LDKDecodeError CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
987 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
988 if(!isWasmInitialized) {
989 throw new Error("initializeWasm() must be awaited first!");
991 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner);
992 return nativeResponseValue;
994 // struct LDKBuiltCommitmentTransaction CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
996 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
997 if(!isWasmInitialized) {
998 throw new Error("initializeWasm() must be awaited first!");
1000 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner);
1001 return nativeResponseValue;
1003 // struct LDKDecodeError CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
1005 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
1006 if(!isWasmInitialized) {
1007 throw new Error("initializeWasm() must be awaited first!");
1009 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner);
1010 return nativeResponseValue;
1012 // struct LDKTrustedClosingTransaction CResult_TrustedClosingTransactionNoneZ_get_ok(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
1014 export function CResult_TrustedClosingTransactionNoneZ_get_ok(owner: bigint): bigint {
1015 if(!isWasmInitialized) {
1016 throw new Error("initializeWasm() must be awaited first!");
1018 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_ok(owner);
1019 return nativeResponseValue;
1021 // void CResult_TrustedClosingTransactionNoneZ_get_err(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
1023 export function CResult_TrustedClosingTransactionNoneZ_get_err(owner: bigint): void {
1024 if(!isWasmInitialized) {
1025 throw new Error("initializeWasm() must be awaited first!");
1027 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_err(owner);
1028 // debug statements here
1030 // struct LDKCommitmentTransaction CResult_CommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
1032 export function CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
1033 if(!isWasmInitialized) {
1034 throw new Error("initializeWasm() must be awaited first!");
1036 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner);
1037 return nativeResponseValue;
1039 // struct LDKDecodeError CResult_CommitmentTransactionDecodeErrorZ_get_err(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
1041 export function CResult_CommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
1042 if(!isWasmInitialized) {
1043 throw new Error("initializeWasm() must be awaited first!");
1045 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_err(owner);
1046 return nativeResponseValue;
1048 // struct LDKTrustedCommitmentTransaction CResult_TrustedCommitmentTransactionNoneZ_get_ok(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
1050 export function CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner: bigint): bigint {
1051 if(!isWasmInitialized) {
1052 throw new Error("initializeWasm() must be awaited first!");
1054 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner);
1055 return nativeResponseValue;
1057 // void CResult_TrustedCommitmentTransactionNoneZ_get_err(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
1059 export function CResult_TrustedCommitmentTransactionNoneZ_get_err(owner: bigint): void {
1060 if(!isWasmInitialized) {
1061 throw new Error("initializeWasm() must be awaited first!");
1063 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_err(owner);
1064 // debug statements here
1066 // struct LDKCVec_SignatureZ CResult_CVec_SignatureZNoneZ_get_ok(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
1068 export function CResult_CVec_SignatureZNoneZ_get_ok(owner: bigint): number {
1069 if(!isWasmInitialized) {
1070 throw new Error("initializeWasm() must be awaited first!");
1072 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_ok(owner);
1073 return nativeResponseValue;
1075 // void CResult_CVec_SignatureZNoneZ_get_err(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
1077 export function CResult_CVec_SignatureZNoneZ_get_err(owner: bigint): void {
1078 if(!isWasmInitialized) {
1079 throw new Error("initializeWasm() must be awaited first!");
1081 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_err(owner);
1082 // debug statements here
1084 // struct LDKShutdownScript CResult_ShutdownScriptDecodeErrorZ_get_ok(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
1086 export function CResult_ShutdownScriptDecodeErrorZ_get_ok(owner: bigint): bigint {
1087 if(!isWasmInitialized) {
1088 throw new Error("initializeWasm() must be awaited first!");
1090 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_ok(owner);
1091 return nativeResponseValue;
1093 // struct LDKDecodeError CResult_ShutdownScriptDecodeErrorZ_get_err(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
1095 export function CResult_ShutdownScriptDecodeErrorZ_get_err(owner: bigint): bigint {
1096 if(!isWasmInitialized) {
1097 throw new Error("initializeWasm() must be awaited first!");
1099 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_err(owner);
1100 return nativeResponseValue;
1102 // struct LDKShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
1104 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner: bigint): bigint {
1105 if(!isWasmInitialized) {
1106 throw new Error("initializeWasm() must be awaited first!");
1108 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner);
1109 return nativeResponseValue;
1111 // struct LDKInvalidShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
1113 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner: bigint): bigint {
1114 if(!isWasmInitialized) {
1115 throw new Error("initializeWasm() must be awaited first!");
1117 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner);
1118 return nativeResponseValue;
1120 // struct LDKRouteHop CResult_RouteHopDecodeErrorZ_get_ok(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
1122 export function CResult_RouteHopDecodeErrorZ_get_ok(owner: bigint): bigint {
1123 if(!isWasmInitialized) {
1124 throw new Error("initializeWasm() must be awaited first!");
1126 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_ok(owner);
1127 return nativeResponseValue;
1129 // struct LDKDecodeError CResult_RouteHopDecodeErrorZ_get_err(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
1131 export function CResult_RouteHopDecodeErrorZ_get_err(owner: bigint): bigint {
1132 if(!isWasmInitialized) {
1133 throw new Error("initializeWasm() must be awaited first!");
1135 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_err(owner);
1136 return nativeResponseValue;
1138 // struct LDKRoute CResult_RouteDecodeErrorZ_get_ok(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
1140 export function CResult_RouteDecodeErrorZ_get_ok(owner: bigint): bigint {
1141 if(!isWasmInitialized) {
1142 throw new Error("initializeWasm() must be awaited first!");
1144 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_ok(owner);
1145 return nativeResponseValue;
1147 // struct LDKDecodeError CResult_RouteDecodeErrorZ_get_err(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
1149 export function CResult_RouteDecodeErrorZ_get_err(owner: bigint): bigint {
1150 if(!isWasmInitialized) {
1151 throw new Error("initializeWasm() must be awaited first!");
1153 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_err(owner);
1154 return nativeResponseValue;
1156 // struct LDKRouteParameters CResult_RouteParametersDecodeErrorZ_get_ok(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
1158 export function CResult_RouteParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
1159 if(!isWasmInitialized) {
1160 throw new Error("initializeWasm() must be awaited first!");
1162 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_ok(owner);
1163 return nativeResponseValue;
1165 // struct LDKDecodeError CResult_RouteParametersDecodeErrorZ_get_err(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
1167 export function CResult_RouteParametersDecodeErrorZ_get_err(owner: bigint): bigint {
1168 if(!isWasmInitialized) {
1169 throw new Error("initializeWasm() must be awaited first!");
1171 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_err(owner);
1172 return nativeResponseValue;
1175 export class LDKCOption_u64Z {
1176 protected constructor() {}
1179 export function LDKCOption_u64Z_ty_from_ptr(ptr: bigint): number {
1180 if(!isWasmInitialized) {
1181 throw new Error("initializeWasm() must be awaited first!");
1183 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_ty_from_ptr(ptr);
1184 return nativeResponseValue;
1187 export function LDKCOption_u64Z_Some_get_some(ptr: bigint): bigint {
1188 if(!isWasmInitialized) {
1189 throw new Error("initializeWasm() must be awaited first!");
1191 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_Some_get_some(ptr);
1192 return nativeResponseValue;
1194 // struct LDKPaymentParameters CResult_PaymentParametersDecodeErrorZ_get_ok(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
1196 export function CResult_PaymentParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
1197 if(!isWasmInitialized) {
1198 throw new Error("initializeWasm() must be awaited first!");
1200 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_ok(owner);
1201 return nativeResponseValue;
1203 // struct LDKDecodeError CResult_PaymentParametersDecodeErrorZ_get_err(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
1205 export function CResult_PaymentParametersDecodeErrorZ_get_err(owner: bigint): bigint {
1206 if(!isWasmInitialized) {
1207 throw new Error("initializeWasm() must be awaited first!");
1209 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_err(owner);
1210 return nativeResponseValue;
1212 // struct LDKRouteHint CResult_RouteHintDecodeErrorZ_get_ok(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
1214 export function CResult_RouteHintDecodeErrorZ_get_ok(owner: bigint): bigint {
1215 if(!isWasmInitialized) {
1216 throw new Error("initializeWasm() must be awaited first!");
1218 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_ok(owner);
1219 return nativeResponseValue;
1221 // struct LDKDecodeError CResult_RouteHintDecodeErrorZ_get_err(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
1223 export function CResult_RouteHintDecodeErrorZ_get_err(owner: bigint): bigint {
1224 if(!isWasmInitialized) {
1225 throw new Error("initializeWasm() must be awaited first!");
1227 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_err(owner);
1228 return nativeResponseValue;
1230 // struct LDKRouteHintHop CResult_RouteHintHopDecodeErrorZ_get_ok(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
1232 export function CResult_RouteHintHopDecodeErrorZ_get_ok(owner: bigint): bigint {
1233 if(!isWasmInitialized) {
1234 throw new Error("initializeWasm() must be awaited first!");
1236 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_ok(owner);
1237 return nativeResponseValue;
1239 // struct LDKDecodeError CResult_RouteHintHopDecodeErrorZ_get_err(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
1241 export function CResult_RouteHintHopDecodeErrorZ_get_err(owner: bigint): bigint {
1242 if(!isWasmInitialized) {
1243 throw new Error("initializeWasm() must be awaited first!");
1245 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_err(owner);
1246 return nativeResponseValue;
1248 // struct LDKRoute CResult_RouteLightningErrorZ_get_ok(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
1250 export function CResult_RouteLightningErrorZ_get_ok(owner: bigint): bigint {
1251 if(!isWasmInitialized) {
1252 throw new Error("initializeWasm() must be awaited first!");
1254 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_ok(owner);
1255 return nativeResponseValue;
1257 // struct LDKLightningError CResult_RouteLightningErrorZ_get_err(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
1259 export function CResult_RouteLightningErrorZ_get_err(owner: bigint): bigint {
1260 if(!isWasmInitialized) {
1261 throw new Error("initializeWasm() must be awaited first!");
1263 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_err(owner);
1264 return nativeResponseValue;
1267 export class LDKPaymentPurpose {
1268 protected constructor() {}
1271 export function LDKPaymentPurpose_ty_from_ptr(ptr: bigint): number {
1272 if(!isWasmInitialized) {
1273 throw new Error("initializeWasm() must be awaited first!");
1275 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_ty_from_ptr(ptr);
1276 return nativeResponseValue;
1279 export function LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr: bigint): number {
1280 if(!isWasmInitialized) {
1281 throw new Error("initializeWasm() must be awaited first!");
1283 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr);
1284 return nativeResponseValue;
1287 export function LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr: bigint): number {
1288 if(!isWasmInitialized) {
1289 throw new Error("initializeWasm() must be awaited first!");
1291 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr);
1292 return nativeResponseValue;
1295 export function LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr: bigint): number {
1296 if(!isWasmInitialized) {
1297 throw new Error("initializeWasm() must be awaited first!");
1299 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr);
1300 return nativeResponseValue;
1302 // struct LDKPaymentPurpose CResult_PaymentPurposeDecodeErrorZ_get_ok(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
1304 export function CResult_PaymentPurposeDecodeErrorZ_get_ok(owner: bigint): bigint {
1305 if(!isWasmInitialized) {
1306 throw new Error("initializeWasm() must be awaited first!");
1308 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_ok(owner);
1309 return nativeResponseValue;
1311 // struct LDKDecodeError CResult_PaymentPurposeDecodeErrorZ_get_err(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
1313 export function CResult_PaymentPurposeDecodeErrorZ_get_err(owner: bigint): bigint {
1314 if(!isWasmInitialized) {
1315 throw new Error("initializeWasm() must be awaited first!");
1317 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_err(owner);
1318 return nativeResponseValue;
1321 export class LDKClosureReason {
1322 protected constructor() {}
1325 export function LDKClosureReason_ty_from_ptr(ptr: bigint): number {
1326 if(!isWasmInitialized) {
1327 throw new Error("initializeWasm() must be awaited first!");
1329 const nativeResponseValue = wasm.TS_LDKClosureReason_ty_from_ptr(ptr);
1330 return nativeResponseValue;
1333 export function LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr: bigint): number {
1334 if(!isWasmInitialized) {
1335 throw new Error("initializeWasm() must be awaited first!");
1337 const nativeResponseValue = wasm.TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr);
1338 return nativeResponseValue;
1341 export function LDKClosureReason_ProcessingError_get_err(ptr: bigint): number {
1342 if(!isWasmInitialized) {
1343 throw new Error("initializeWasm() must be awaited first!");
1345 const nativeResponseValue = wasm.TS_LDKClosureReason_ProcessingError_get_err(ptr);
1346 return nativeResponseValue;
1349 export class LDKCOption_ClosureReasonZ {
1350 protected constructor() {}
1353 export function LDKCOption_ClosureReasonZ_ty_from_ptr(ptr: bigint): number {
1354 if(!isWasmInitialized) {
1355 throw new Error("initializeWasm() must be awaited first!");
1357 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_ty_from_ptr(ptr);
1358 return nativeResponseValue;
1361 export function LDKCOption_ClosureReasonZ_Some_get_some(ptr: bigint): bigint {
1362 if(!isWasmInitialized) {
1363 throw new Error("initializeWasm() must be awaited first!");
1365 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_Some_get_some(ptr);
1366 return nativeResponseValue;
1368 // struct LDKCOption_ClosureReasonZ CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
1370 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner: bigint): bigint {
1371 if(!isWasmInitialized) {
1372 throw new Error("initializeWasm() must be awaited first!");
1374 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner);
1375 return nativeResponseValue;
1377 // struct LDKDecodeError CResult_COption_ClosureReasonZDecodeErrorZ_get_err(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
1379 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner: bigint): bigint {
1380 if(!isWasmInitialized) {
1381 throw new Error("initializeWasm() must be awaited first!");
1383 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner);
1384 return nativeResponseValue;
1387 export class LDKHTLCDestination {
1388 protected constructor() {}
1391 export function LDKHTLCDestination_ty_from_ptr(ptr: bigint): number {
1392 if(!isWasmInitialized) {
1393 throw new Error("initializeWasm() must be awaited first!");
1395 const nativeResponseValue = wasm.TS_LDKHTLCDestination_ty_from_ptr(ptr);
1396 return nativeResponseValue;
1399 export function LDKHTLCDestination_NextHopChannel_get_node_id(ptr: bigint): number {
1400 if(!isWasmInitialized) {
1401 throw new Error("initializeWasm() must be awaited first!");
1403 const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_node_id(ptr);
1404 return nativeResponseValue;
1407 export function LDKHTLCDestination_NextHopChannel_get_channel_id(ptr: bigint): number {
1408 if(!isWasmInitialized) {
1409 throw new Error("initializeWasm() must be awaited first!");
1411 const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_channel_id(ptr);
1412 return nativeResponseValue;
1415 export function LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr: bigint): bigint {
1416 if(!isWasmInitialized) {
1417 throw new Error("initializeWasm() must be awaited first!");
1419 const nativeResponseValue = wasm.TS_LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr);
1420 return nativeResponseValue;
1423 export function LDKHTLCDestination_FailedPayment_get_payment_hash(ptr: bigint): number {
1424 if(!isWasmInitialized) {
1425 throw new Error("initializeWasm() must be awaited first!");
1427 const nativeResponseValue = wasm.TS_LDKHTLCDestination_FailedPayment_get_payment_hash(ptr);
1428 return nativeResponseValue;
1431 export class LDKCOption_HTLCDestinationZ {
1432 protected constructor() {}
1435 export function LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr: bigint): number {
1436 if(!isWasmInitialized) {
1437 throw new Error("initializeWasm() must be awaited first!");
1439 const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr);
1440 return nativeResponseValue;
1443 export function LDKCOption_HTLCDestinationZ_Some_get_some(ptr: bigint): bigint {
1444 if(!isWasmInitialized) {
1445 throw new Error("initializeWasm() must be awaited first!");
1447 const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_Some_get_some(ptr);
1448 return nativeResponseValue;
1450 // struct LDKCOption_HTLCDestinationZ CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
1452 export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner: bigint): bigint {
1453 if(!isWasmInitialized) {
1454 throw new Error("initializeWasm() must be awaited first!");
1456 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner);
1457 return nativeResponseValue;
1459 // struct LDKDecodeError CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
1461 export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner: bigint): bigint {
1462 if(!isWasmInitialized) {
1463 throw new Error("initializeWasm() must be awaited first!");
1465 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner);
1466 return nativeResponseValue;
1469 export class LDKNetworkUpdate {
1470 protected constructor() {}
1473 export function LDKNetworkUpdate_ty_from_ptr(ptr: bigint): number {
1474 if(!isWasmInitialized) {
1475 throw new Error("initializeWasm() must be awaited first!");
1477 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ty_from_ptr(ptr);
1478 return nativeResponseValue;
1481 export function LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr: bigint): bigint {
1482 if(!isWasmInitialized) {
1483 throw new Error("initializeWasm() must be awaited first!");
1485 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr);
1486 return nativeResponseValue;
1489 export function LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr: bigint): bigint {
1490 if(!isWasmInitialized) {
1491 throw new Error("initializeWasm() must be awaited first!");
1493 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr);
1494 return nativeResponseValue;
1497 export function LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr: bigint): boolean {
1498 if(!isWasmInitialized) {
1499 throw new Error("initializeWasm() must be awaited first!");
1501 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr);
1502 return nativeResponseValue;
1505 export function LDKNetworkUpdate_NodeFailure_get_node_id(ptr: bigint): number {
1506 if(!isWasmInitialized) {
1507 throw new Error("initializeWasm() must be awaited first!");
1509 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_node_id(ptr);
1510 return nativeResponseValue;
1513 export function LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr: bigint): boolean {
1514 if(!isWasmInitialized) {
1515 throw new Error("initializeWasm() must be awaited first!");
1517 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr);
1518 return nativeResponseValue;
1521 export class LDKCOption_NetworkUpdateZ {
1522 protected constructor() {}
1525 export function LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr: bigint): number {
1526 if(!isWasmInitialized) {
1527 throw new Error("initializeWasm() must be awaited first!");
1529 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr);
1530 return nativeResponseValue;
1533 export function LDKCOption_NetworkUpdateZ_Some_get_some(ptr: bigint): bigint {
1534 if(!isWasmInitialized) {
1535 throw new Error("initializeWasm() must be awaited first!");
1537 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_Some_get_some(ptr);
1538 return nativeResponseValue;
1541 export class LDKSpendableOutputDescriptor {
1542 protected constructor() {}
1545 export function LDKSpendableOutputDescriptor_ty_from_ptr(ptr: bigint): number {
1546 if(!isWasmInitialized) {
1547 throw new Error("initializeWasm() must be awaited first!");
1549 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_ty_from_ptr(ptr);
1550 return nativeResponseValue;
1553 export function LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr: bigint): bigint {
1554 if(!isWasmInitialized) {
1555 throw new Error("initializeWasm() must be awaited first!");
1557 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr);
1558 return nativeResponseValue;
1561 export function LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr: bigint): bigint {
1562 if(!isWasmInitialized) {
1563 throw new Error("initializeWasm() must be awaited first!");
1565 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr);
1566 return nativeResponseValue;
1569 export function LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr: bigint): bigint {
1570 if(!isWasmInitialized) {
1571 throw new Error("initializeWasm() must be awaited first!");
1573 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr);
1574 return nativeResponseValue;
1577 export function LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr: bigint): bigint {
1578 if(!isWasmInitialized) {
1579 throw new Error("initializeWasm() must be awaited first!");
1581 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr);
1582 return nativeResponseValue;
1585 export class LDKEvent {
1586 protected constructor() {}
1589 export function LDKEvent_ty_from_ptr(ptr: bigint): number {
1590 if(!isWasmInitialized) {
1591 throw new Error("initializeWasm() must be awaited first!");
1593 const nativeResponseValue = wasm.TS_LDKEvent_ty_from_ptr(ptr);
1594 return nativeResponseValue;
1597 export function LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr: bigint): number {
1598 if(!isWasmInitialized) {
1599 throw new Error("initializeWasm() must be awaited first!");
1601 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr);
1602 return nativeResponseValue;
1605 export function LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr: bigint): number {
1606 if(!isWasmInitialized) {
1607 throw new Error("initializeWasm() must be awaited first!");
1609 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr);
1610 return nativeResponseValue;
1613 export function LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr: bigint): bigint {
1614 if(!isWasmInitialized) {
1615 throw new Error("initializeWasm() must be awaited first!");
1617 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr);
1618 return nativeResponseValue;
1621 export function LDKEvent_FundingGenerationReady_get_output_script(ptr: bigint): number {
1622 if(!isWasmInitialized) {
1623 throw new Error("initializeWasm() must be awaited first!");
1625 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_output_script(ptr);
1626 return nativeResponseValue;
1629 export function LDKEvent_FundingGenerationReady_get_user_channel_id(ptr: bigint): bigint {
1630 if(!isWasmInitialized) {
1631 throw new Error("initializeWasm() must be awaited first!");
1633 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_user_channel_id(ptr);
1634 return nativeResponseValue;
1637 export function LDKEvent_PaymentReceived_get_payment_hash(ptr: bigint): number {
1638 if(!isWasmInitialized) {
1639 throw new Error("initializeWasm() must be awaited first!");
1641 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_payment_hash(ptr);
1642 return nativeResponseValue;
1645 export function LDKEvent_PaymentReceived_get_amount_msat(ptr: bigint): bigint {
1646 if(!isWasmInitialized) {
1647 throw new Error("initializeWasm() must be awaited first!");
1649 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_amount_msat(ptr);
1650 return nativeResponseValue;
1653 export function LDKEvent_PaymentReceived_get_purpose(ptr: bigint): bigint {
1654 if(!isWasmInitialized) {
1655 throw new Error("initializeWasm() must be awaited first!");
1657 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_purpose(ptr);
1658 return nativeResponseValue;
1661 export function LDKEvent_PaymentClaimed_get_payment_hash(ptr: bigint): number {
1662 if(!isWasmInitialized) {
1663 throw new Error("initializeWasm() must be awaited first!");
1665 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_payment_hash(ptr);
1666 return nativeResponseValue;
1669 export function LDKEvent_PaymentClaimed_get_amount_msat(ptr: bigint): bigint {
1670 if(!isWasmInitialized) {
1671 throw new Error("initializeWasm() must be awaited first!");
1673 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_amount_msat(ptr);
1674 return nativeResponseValue;
1677 export function LDKEvent_PaymentClaimed_get_purpose(ptr: bigint): bigint {
1678 if(!isWasmInitialized) {
1679 throw new Error("initializeWasm() must be awaited first!");
1681 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_purpose(ptr);
1682 return nativeResponseValue;
1685 export function LDKEvent_PaymentSent_get_payment_id(ptr: bigint): number {
1686 if(!isWasmInitialized) {
1687 throw new Error("initializeWasm() must be awaited first!");
1689 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_id(ptr);
1690 return nativeResponseValue;
1693 export function LDKEvent_PaymentSent_get_payment_preimage(ptr: bigint): number {
1694 if(!isWasmInitialized) {
1695 throw new Error("initializeWasm() must be awaited first!");
1697 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_preimage(ptr);
1698 return nativeResponseValue;
1701 export function LDKEvent_PaymentSent_get_payment_hash(ptr: bigint): number {
1702 if(!isWasmInitialized) {
1703 throw new Error("initializeWasm() must be awaited first!");
1705 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_hash(ptr);
1706 return nativeResponseValue;
1709 export function LDKEvent_PaymentSent_get_fee_paid_msat(ptr: bigint): bigint {
1710 if(!isWasmInitialized) {
1711 throw new Error("initializeWasm() must be awaited first!");
1713 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_fee_paid_msat(ptr);
1714 return nativeResponseValue;
1717 export function LDKEvent_PaymentFailed_get_payment_id(ptr: bigint): number {
1718 if(!isWasmInitialized) {
1719 throw new Error("initializeWasm() must be awaited first!");
1721 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_id(ptr);
1722 return nativeResponseValue;
1725 export function LDKEvent_PaymentFailed_get_payment_hash(ptr: bigint): number {
1726 if(!isWasmInitialized) {
1727 throw new Error("initializeWasm() must be awaited first!");
1729 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_hash(ptr);
1730 return nativeResponseValue;
1733 export function LDKEvent_PaymentPathSuccessful_get_payment_id(ptr: bigint): number {
1734 if(!isWasmInitialized) {
1735 throw new Error("initializeWasm() must be awaited first!");
1737 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_id(ptr);
1738 return nativeResponseValue;
1741 export function LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr: bigint): number {
1742 if(!isWasmInitialized) {
1743 throw new Error("initializeWasm() must be awaited first!");
1745 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr);
1746 return nativeResponseValue;
1749 export function LDKEvent_PaymentPathSuccessful_get_path(ptr: bigint): number {
1750 if(!isWasmInitialized) {
1751 throw new Error("initializeWasm() must be awaited first!");
1753 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_path(ptr);
1754 return nativeResponseValue;
1757 export function LDKEvent_PaymentPathFailed_get_payment_id(ptr: bigint): number {
1758 if(!isWasmInitialized) {
1759 throw new Error("initializeWasm() must be awaited first!");
1761 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_id(ptr);
1762 return nativeResponseValue;
1765 export function LDKEvent_PaymentPathFailed_get_payment_hash(ptr: bigint): number {
1766 if(!isWasmInitialized) {
1767 throw new Error("initializeWasm() must be awaited first!");
1769 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_hash(ptr);
1770 return nativeResponseValue;
1773 export function LDKEvent_PaymentPathFailed_get_payment_failed_permanently(ptr: bigint): boolean {
1774 if(!isWasmInitialized) {
1775 throw new Error("initializeWasm() must be awaited first!");
1777 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_failed_permanently(ptr);
1778 return nativeResponseValue;
1781 export function LDKEvent_PaymentPathFailed_get_network_update(ptr: bigint): bigint {
1782 if(!isWasmInitialized) {
1783 throw new Error("initializeWasm() must be awaited first!");
1785 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_network_update(ptr);
1786 return nativeResponseValue;
1789 export function LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr: bigint): boolean {
1790 if(!isWasmInitialized) {
1791 throw new Error("initializeWasm() must be awaited first!");
1793 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr);
1794 return nativeResponseValue;
1797 export function LDKEvent_PaymentPathFailed_get_path(ptr: bigint): number {
1798 if(!isWasmInitialized) {
1799 throw new Error("initializeWasm() must be awaited first!");
1801 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_path(ptr);
1802 return nativeResponseValue;
1805 export function LDKEvent_PaymentPathFailed_get_short_channel_id(ptr: bigint): bigint {
1806 if(!isWasmInitialized) {
1807 throw new Error("initializeWasm() must be awaited first!");
1809 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_short_channel_id(ptr);
1810 return nativeResponseValue;
1813 export function LDKEvent_PaymentPathFailed_get_retry(ptr: bigint): bigint {
1814 if(!isWasmInitialized) {
1815 throw new Error("initializeWasm() must be awaited first!");
1817 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_retry(ptr);
1818 return nativeResponseValue;
1821 export function LDKEvent_ProbeSuccessful_get_payment_id(ptr: bigint): number {
1822 if(!isWasmInitialized) {
1823 throw new Error("initializeWasm() must be awaited first!");
1825 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_payment_id(ptr);
1826 return nativeResponseValue;
1829 export function LDKEvent_ProbeSuccessful_get_payment_hash(ptr: bigint): number {
1830 if(!isWasmInitialized) {
1831 throw new Error("initializeWasm() must be awaited first!");
1833 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_payment_hash(ptr);
1834 return nativeResponseValue;
1837 export function LDKEvent_ProbeSuccessful_get_path(ptr: bigint): number {
1838 if(!isWasmInitialized) {
1839 throw new Error("initializeWasm() must be awaited first!");
1841 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_path(ptr);
1842 return nativeResponseValue;
1845 export function LDKEvent_ProbeFailed_get_payment_id(ptr: bigint): number {
1846 if(!isWasmInitialized) {
1847 throw new Error("initializeWasm() must be awaited first!");
1849 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_payment_id(ptr);
1850 return nativeResponseValue;
1853 export function LDKEvent_ProbeFailed_get_payment_hash(ptr: bigint): number {
1854 if(!isWasmInitialized) {
1855 throw new Error("initializeWasm() must be awaited first!");
1857 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_payment_hash(ptr);
1858 return nativeResponseValue;
1861 export function LDKEvent_ProbeFailed_get_path(ptr: bigint): number {
1862 if(!isWasmInitialized) {
1863 throw new Error("initializeWasm() must be awaited first!");
1865 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_path(ptr);
1866 return nativeResponseValue;
1869 export function LDKEvent_ProbeFailed_get_short_channel_id(ptr: bigint): bigint {
1870 if(!isWasmInitialized) {
1871 throw new Error("initializeWasm() must be awaited first!");
1873 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_short_channel_id(ptr);
1874 return nativeResponseValue;
1877 export function LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr: bigint): bigint {
1878 if(!isWasmInitialized) {
1879 throw new Error("initializeWasm() must be awaited first!");
1881 const nativeResponseValue = wasm.TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr);
1882 return nativeResponseValue;
1885 export function LDKEvent_SpendableOutputs_get_outputs(ptr: bigint): number {
1886 if(!isWasmInitialized) {
1887 throw new Error("initializeWasm() must be awaited first!");
1889 const nativeResponseValue = wasm.TS_LDKEvent_SpendableOutputs_get_outputs(ptr);
1890 return nativeResponseValue;
1893 export function LDKEvent_PaymentForwarded_get_prev_channel_id(ptr: bigint): number {
1894 if(!isWasmInitialized) {
1895 throw new Error("initializeWasm() must be awaited first!");
1897 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_prev_channel_id(ptr);
1898 return nativeResponseValue;
1901 export function LDKEvent_PaymentForwarded_get_next_channel_id(ptr: bigint): number {
1902 if(!isWasmInitialized) {
1903 throw new Error("initializeWasm() must be awaited first!");
1905 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_next_channel_id(ptr);
1906 return nativeResponseValue;
1909 export function LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr: bigint): bigint {
1910 if(!isWasmInitialized) {
1911 throw new Error("initializeWasm() must be awaited first!");
1913 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr);
1914 return nativeResponseValue;
1917 export function LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr: bigint): boolean {
1918 if(!isWasmInitialized) {
1919 throw new Error("initializeWasm() must be awaited first!");
1921 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr);
1922 return nativeResponseValue;
1925 export function LDKEvent_ChannelClosed_get_channel_id(ptr: bigint): number {
1926 if(!isWasmInitialized) {
1927 throw new Error("initializeWasm() must be awaited first!");
1929 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_channel_id(ptr);
1930 return nativeResponseValue;
1933 export function LDKEvent_ChannelClosed_get_user_channel_id(ptr: bigint): bigint {
1934 if(!isWasmInitialized) {
1935 throw new Error("initializeWasm() must be awaited first!");
1937 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_user_channel_id(ptr);
1938 return nativeResponseValue;
1941 export function LDKEvent_ChannelClosed_get_reason(ptr: bigint): bigint {
1942 if(!isWasmInitialized) {
1943 throw new Error("initializeWasm() must be awaited first!");
1945 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_reason(ptr);
1946 return nativeResponseValue;
1949 export function LDKEvent_DiscardFunding_get_channel_id(ptr: bigint): number {
1950 if(!isWasmInitialized) {
1951 throw new Error("initializeWasm() must be awaited first!");
1953 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_channel_id(ptr);
1954 return nativeResponseValue;
1957 export function LDKEvent_DiscardFunding_get_transaction(ptr: bigint): number {
1958 if(!isWasmInitialized) {
1959 throw new Error("initializeWasm() must be awaited first!");
1961 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_transaction(ptr);
1962 return nativeResponseValue;
1965 export function LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr: bigint): number {
1966 if(!isWasmInitialized) {
1967 throw new Error("initializeWasm() must be awaited first!");
1969 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr);
1970 return nativeResponseValue;
1973 export function LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr: bigint): number {
1974 if(!isWasmInitialized) {
1975 throw new Error("initializeWasm() must be awaited first!");
1977 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr);
1978 return nativeResponseValue;
1981 export function LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr: bigint): bigint {
1982 if(!isWasmInitialized) {
1983 throw new Error("initializeWasm() must be awaited first!");
1985 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr);
1986 return nativeResponseValue;
1989 export function LDKEvent_OpenChannelRequest_get_push_msat(ptr: bigint): bigint {
1990 if(!isWasmInitialized) {
1991 throw new Error("initializeWasm() must be awaited first!");
1993 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_push_msat(ptr);
1994 return nativeResponseValue;
1997 export function LDKEvent_OpenChannelRequest_get_channel_type(ptr: bigint): bigint {
1998 if(!isWasmInitialized) {
1999 throw new Error("initializeWasm() must be awaited first!");
2001 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_channel_type(ptr);
2002 return nativeResponseValue;
2005 export function LDKEvent_HTLCHandlingFailed_get_prev_channel_id(ptr: bigint): number {
2006 if(!isWasmInitialized) {
2007 throw new Error("initializeWasm() must be awaited first!");
2009 const nativeResponseValue = wasm.TS_LDKEvent_HTLCHandlingFailed_get_prev_channel_id(ptr);
2010 return nativeResponseValue;
2013 export function LDKEvent_HTLCHandlingFailed_get_failed_next_destination(ptr: bigint): bigint {
2014 if(!isWasmInitialized) {
2015 throw new Error("initializeWasm() must be awaited first!");
2017 const nativeResponseValue = wasm.TS_LDKEvent_HTLCHandlingFailed_get_failed_next_destination(ptr);
2018 return nativeResponseValue;
2021 export class LDKCOption_EventZ {
2022 protected constructor() {}
2025 export function LDKCOption_EventZ_ty_from_ptr(ptr: bigint): number {
2026 if(!isWasmInitialized) {
2027 throw new Error("initializeWasm() must be awaited first!");
2029 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_ty_from_ptr(ptr);
2030 return nativeResponseValue;
2033 export function LDKCOption_EventZ_Some_get_some(ptr: bigint): bigint {
2034 if(!isWasmInitialized) {
2035 throw new Error("initializeWasm() must be awaited first!");
2037 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_Some_get_some(ptr);
2038 return nativeResponseValue;
2040 // struct LDKCOption_EventZ CResult_COption_EventZDecodeErrorZ_get_ok(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
2042 export function CResult_COption_EventZDecodeErrorZ_get_ok(owner: bigint): bigint {
2043 if(!isWasmInitialized) {
2044 throw new Error("initializeWasm() must be awaited first!");
2046 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_ok(owner);
2047 return nativeResponseValue;
2049 // struct LDKDecodeError CResult_COption_EventZDecodeErrorZ_get_err(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
2051 export function CResult_COption_EventZDecodeErrorZ_get_err(owner: bigint): bigint {
2052 if(!isWasmInitialized) {
2053 throw new Error("initializeWasm() must be awaited first!");
2055 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_err(owner);
2056 return nativeResponseValue;
2059 export class LDKErrorAction {
2060 protected constructor() {}
2063 export function LDKErrorAction_ty_from_ptr(ptr: bigint): number {
2064 if(!isWasmInitialized) {
2065 throw new Error("initializeWasm() must be awaited first!");
2067 const nativeResponseValue = wasm.TS_LDKErrorAction_ty_from_ptr(ptr);
2068 return nativeResponseValue;
2071 export function LDKErrorAction_DisconnectPeer_get_msg(ptr: bigint): bigint {
2072 if(!isWasmInitialized) {
2073 throw new Error("initializeWasm() must be awaited first!");
2075 const nativeResponseValue = wasm.TS_LDKErrorAction_DisconnectPeer_get_msg(ptr);
2076 return nativeResponseValue;
2079 export function LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr: bigint): Level {
2080 if(!isWasmInitialized) {
2081 throw new Error("initializeWasm() must be awaited first!");
2083 const nativeResponseValue = wasm.TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr);
2084 return nativeResponseValue;
2087 export function LDKErrorAction_SendErrorMessage_get_msg(ptr: bigint): bigint {
2088 if(!isWasmInitialized) {
2089 throw new Error("initializeWasm() must be awaited first!");
2091 const nativeResponseValue = wasm.TS_LDKErrorAction_SendErrorMessage_get_msg(ptr);
2092 return nativeResponseValue;
2095 export function LDKErrorAction_SendWarningMessage_get_msg(ptr: bigint): bigint {
2096 if(!isWasmInitialized) {
2097 throw new Error("initializeWasm() must be awaited first!");
2099 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_msg(ptr);
2100 return nativeResponseValue;
2103 export function LDKErrorAction_SendWarningMessage_get_log_level(ptr: bigint): Level {
2104 if(!isWasmInitialized) {
2105 throw new Error("initializeWasm() must be awaited first!");
2107 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_log_level(ptr);
2108 return nativeResponseValue;
2111 export class LDKMessageSendEvent {
2112 protected constructor() {}
2115 export function LDKMessageSendEvent_ty_from_ptr(ptr: bigint): number {
2116 if(!isWasmInitialized) {
2117 throw new Error("initializeWasm() must be awaited first!");
2119 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_ty_from_ptr(ptr);
2120 return nativeResponseValue;
2123 export function LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr: bigint): number {
2124 if(!isWasmInitialized) {
2125 throw new Error("initializeWasm() must be awaited first!");
2127 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr);
2128 return nativeResponseValue;
2131 export function LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr: bigint): bigint {
2132 if(!isWasmInitialized) {
2133 throw new Error("initializeWasm() must be awaited first!");
2135 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr);
2136 return nativeResponseValue;
2139 export function LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr: bigint): number {
2140 if(!isWasmInitialized) {
2141 throw new Error("initializeWasm() must be awaited first!");
2143 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr);
2144 return nativeResponseValue;
2147 export function LDKMessageSendEvent_SendOpenChannel_get_msg(ptr: bigint): bigint {
2148 if(!isWasmInitialized) {
2149 throw new Error("initializeWasm() must be awaited first!");
2151 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_msg(ptr);
2152 return nativeResponseValue;
2155 export function LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr: bigint): number {
2156 if(!isWasmInitialized) {
2157 throw new Error("initializeWasm() must be awaited first!");
2159 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr);
2160 return nativeResponseValue;
2163 export function LDKMessageSendEvent_SendFundingCreated_get_msg(ptr: bigint): bigint {
2164 if(!isWasmInitialized) {
2165 throw new Error("initializeWasm() must be awaited first!");
2167 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_msg(ptr);
2168 return nativeResponseValue;
2171 export function LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr: bigint): number {
2172 if(!isWasmInitialized) {
2173 throw new Error("initializeWasm() must be awaited first!");
2175 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr);
2176 return nativeResponseValue;
2179 export function LDKMessageSendEvent_SendFundingSigned_get_msg(ptr: bigint): bigint {
2180 if(!isWasmInitialized) {
2181 throw new Error("initializeWasm() must be awaited first!");
2183 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_msg(ptr);
2184 return nativeResponseValue;
2187 export function LDKMessageSendEvent_SendChannelReady_get_node_id(ptr: bigint): number {
2188 if(!isWasmInitialized) {
2189 throw new Error("initializeWasm() must be awaited first!");
2191 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_node_id(ptr);
2192 return nativeResponseValue;
2195 export function LDKMessageSendEvent_SendChannelReady_get_msg(ptr: bigint): bigint {
2196 if(!isWasmInitialized) {
2197 throw new Error("initializeWasm() must be awaited first!");
2199 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_msg(ptr);
2200 return nativeResponseValue;
2203 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr: bigint): number {
2204 if(!isWasmInitialized) {
2205 throw new Error("initializeWasm() must be awaited first!");
2207 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr);
2208 return nativeResponseValue;
2211 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr: bigint): bigint {
2212 if(!isWasmInitialized) {
2213 throw new Error("initializeWasm() must be awaited first!");
2215 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr);
2216 return nativeResponseValue;
2219 export function LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr: bigint): number {
2220 if(!isWasmInitialized) {
2221 throw new Error("initializeWasm() must be awaited first!");
2223 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr);
2224 return nativeResponseValue;
2227 export function LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr: bigint): bigint {
2228 if(!isWasmInitialized) {
2229 throw new Error("initializeWasm() must be awaited first!");
2231 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr);
2232 return nativeResponseValue;
2235 export function LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr: bigint): number {
2236 if(!isWasmInitialized) {
2237 throw new Error("initializeWasm() must be awaited first!");
2239 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr);
2240 return nativeResponseValue;
2243 export function LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr: bigint): bigint {
2244 if(!isWasmInitialized) {
2245 throw new Error("initializeWasm() must be awaited first!");
2247 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr);
2248 return nativeResponseValue;
2251 export function LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr: bigint): number {
2252 if(!isWasmInitialized) {
2253 throw new Error("initializeWasm() must be awaited first!");
2255 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr);
2256 return nativeResponseValue;
2259 export function LDKMessageSendEvent_SendClosingSigned_get_msg(ptr: bigint): bigint {
2260 if(!isWasmInitialized) {
2261 throw new Error("initializeWasm() must be awaited first!");
2263 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_msg(ptr);
2264 return nativeResponseValue;
2267 export function LDKMessageSendEvent_SendShutdown_get_node_id(ptr: bigint): number {
2268 if(!isWasmInitialized) {
2269 throw new Error("initializeWasm() must be awaited first!");
2271 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_node_id(ptr);
2272 return nativeResponseValue;
2275 export function LDKMessageSendEvent_SendShutdown_get_msg(ptr: bigint): bigint {
2276 if(!isWasmInitialized) {
2277 throw new Error("initializeWasm() must be awaited first!");
2279 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_msg(ptr);
2280 return nativeResponseValue;
2283 export function LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr: bigint): number {
2284 if(!isWasmInitialized) {
2285 throw new Error("initializeWasm() must be awaited first!");
2287 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr);
2288 return nativeResponseValue;
2291 export function LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr: bigint): bigint {
2292 if(!isWasmInitialized) {
2293 throw new Error("initializeWasm() must be awaited first!");
2295 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr);
2296 return nativeResponseValue;
2299 export function LDKMessageSendEvent_SendChannelAnnouncement_get_node_id(ptr: bigint): number {
2300 if(!isWasmInitialized) {
2301 throw new Error("initializeWasm() must be awaited first!");
2303 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelAnnouncement_get_node_id(ptr);
2304 return nativeResponseValue;
2307 export function LDKMessageSendEvent_SendChannelAnnouncement_get_msg(ptr: bigint): bigint {
2308 if(!isWasmInitialized) {
2309 throw new Error("initializeWasm() must be awaited first!");
2311 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelAnnouncement_get_msg(ptr);
2312 return nativeResponseValue;
2315 export function LDKMessageSendEvent_SendChannelAnnouncement_get_update_msg(ptr: bigint): bigint {
2316 if(!isWasmInitialized) {
2317 throw new Error("initializeWasm() must be awaited first!");
2319 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelAnnouncement_get_update_msg(ptr);
2320 return nativeResponseValue;
2323 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr: bigint): bigint {
2324 if(!isWasmInitialized) {
2325 throw new Error("initializeWasm() must be awaited first!");
2327 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr);
2328 return nativeResponseValue;
2331 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr: bigint): bigint {
2332 if(!isWasmInitialized) {
2333 throw new Error("initializeWasm() must be awaited first!");
2335 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr);
2336 return nativeResponseValue;
2339 export function LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr: bigint): bigint {
2340 if(!isWasmInitialized) {
2341 throw new Error("initializeWasm() must be awaited first!");
2343 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr);
2344 return nativeResponseValue;
2347 export function LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr: bigint): number {
2348 if(!isWasmInitialized) {
2349 throw new Error("initializeWasm() must be awaited first!");
2351 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr);
2352 return nativeResponseValue;
2355 export function LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr: bigint): bigint {
2356 if(!isWasmInitialized) {
2357 throw new Error("initializeWasm() must be awaited first!");
2359 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr);
2360 return nativeResponseValue;
2363 export function LDKMessageSendEvent_HandleError_get_node_id(ptr: bigint): number {
2364 if(!isWasmInitialized) {
2365 throw new Error("initializeWasm() must be awaited first!");
2367 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_node_id(ptr);
2368 return nativeResponseValue;
2371 export function LDKMessageSendEvent_HandleError_get_action(ptr: bigint): bigint {
2372 if(!isWasmInitialized) {
2373 throw new Error("initializeWasm() must be awaited first!");
2375 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_action(ptr);
2376 return nativeResponseValue;
2379 export function LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr: bigint): number {
2380 if(!isWasmInitialized) {
2381 throw new Error("initializeWasm() must be awaited first!");
2383 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr);
2384 return nativeResponseValue;
2387 export function LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr: bigint): bigint {
2388 if(!isWasmInitialized) {
2389 throw new Error("initializeWasm() must be awaited first!");
2391 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr);
2392 return nativeResponseValue;
2395 export function LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr: bigint): number {
2396 if(!isWasmInitialized) {
2397 throw new Error("initializeWasm() must be awaited first!");
2399 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr);
2400 return nativeResponseValue;
2403 export function LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr: bigint): bigint {
2404 if(!isWasmInitialized) {
2405 throw new Error("initializeWasm() must be awaited first!");
2407 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr);
2408 return nativeResponseValue;
2411 export function LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr: bigint): number {
2412 if(!isWasmInitialized) {
2413 throw new Error("initializeWasm() must be awaited first!");
2415 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr);
2416 return nativeResponseValue;
2419 export function LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr: bigint): bigint {
2420 if(!isWasmInitialized) {
2421 throw new Error("initializeWasm() must be awaited first!");
2423 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr);
2424 return nativeResponseValue;
2427 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr: bigint): number {
2428 if(!isWasmInitialized) {
2429 throw new Error("initializeWasm() must be awaited first!");
2431 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr);
2432 return nativeResponseValue;
2435 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr: bigint): bigint {
2436 if(!isWasmInitialized) {
2437 throw new Error("initializeWasm() must be awaited first!");
2439 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr);
2440 return nativeResponseValue;
2442 // struct LDKTxOut CResult_TxOutAccessErrorZ_get_ok(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
2444 export function CResult_TxOutAccessErrorZ_get_ok(owner: bigint): bigint {
2445 if(!isWasmInitialized) {
2446 throw new Error("initializeWasm() must be awaited first!");
2448 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_ok(owner);
2449 return nativeResponseValue;
2451 // enum LDKAccessError CResult_TxOutAccessErrorZ_get_err(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
2453 export function CResult_TxOutAccessErrorZ_get_err(owner: bigint): AccessError {
2454 if(!isWasmInitialized) {
2455 throw new Error("initializeWasm() must be awaited first!");
2457 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_err(owner);
2458 return nativeResponseValue;
2460 // uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2462 export function C2Tuple_usizeTransactionZ_get_a(owner: bigint): number {
2463 if(!isWasmInitialized) {
2464 throw new Error("initializeWasm() must be awaited first!");
2466 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_a(owner);
2467 return nativeResponseValue;
2469 // struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2471 export function C2Tuple_usizeTransactionZ_get_b(owner: bigint): number {
2472 if(!isWasmInitialized) {
2473 throw new Error("initializeWasm() must be awaited first!");
2475 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_b(owner);
2476 return nativeResponseValue;
2478 // void CResult_NoneChannelMonitorUpdateErrZ_get_ok(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR owner);
2480 export function CResult_NoneChannelMonitorUpdateErrZ_get_ok(owner: bigint): void {
2481 if(!isWasmInitialized) {
2482 throw new Error("initializeWasm() must be awaited first!");
2484 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_get_ok(owner);
2485 // debug statements here
2487 // enum LDKChannelMonitorUpdateErr CResult_NoneChannelMonitorUpdateErrZ_get_err(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR owner);
2489 export function CResult_NoneChannelMonitorUpdateErrZ_get_err(owner: bigint): ChannelMonitorUpdateErr {
2490 if(!isWasmInitialized) {
2491 throw new Error("initializeWasm() must be awaited first!");
2493 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_get_err(owner);
2494 return nativeResponseValue;
2497 export class LDKMonitorEvent {
2498 protected constructor() {}
2501 export function LDKMonitorEvent_ty_from_ptr(ptr: bigint): number {
2502 if(!isWasmInitialized) {
2503 throw new Error("initializeWasm() must be awaited first!");
2505 const nativeResponseValue = wasm.TS_LDKMonitorEvent_ty_from_ptr(ptr);
2506 return nativeResponseValue;
2509 export function LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr: bigint): bigint {
2510 if(!isWasmInitialized) {
2511 throw new Error("initializeWasm() must be awaited first!");
2513 const nativeResponseValue = wasm.TS_LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr);
2514 return nativeResponseValue;
2517 export function LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr: bigint): bigint {
2518 if(!isWasmInitialized) {
2519 throw new Error("initializeWasm() must be awaited first!");
2521 const nativeResponseValue = wasm.TS_LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr);
2522 return nativeResponseValue;
2525 export function LDKMonitorEvent_UpdateCompleted_get_funding_txo(ptr: bigint): bigint {
2526 if(!isWasmInitialized) {
2527 throw new Error("initializeWasm() must be awaited first!");
2529 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateCompleted_get_funding_txo(ptr);
2530 return nativeResponseValue;
2533 export function LDKMonitorEvent_UpdateCompleted_get_monitor_update_id(ptr: bigint): bigint {
2534 if(!isWasmInitialized) {
2535 throw new Error("initializeWasm() must be awaited first!");
2537 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateCompleted_get_monitor_update_id(ptr);
2538 return nativeResponseValue;
2541 export function LDKMonitorEvent_UpdateFailed_get_update_failed(ptr: bigint): bigint {
2542 if(!isWasmInitialized) {
2543 throw new Error("initializeWasm() must be awaited first!");
2545 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateFailed_get_update_failed(ptr);
2546 return nativeResponseValue;
2548 // struct LDKOutPoint C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2550 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner: bigint): bigint {
2551 if(!isWasmInitialized) {
2552 throw new Error("initializeWasm() must be awaited first!");
2554 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner);
2555 return nativeResponseValue;
2557 // struct LDKCVec_MonitorEventZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2559 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner: bigint): number {
2560 if(!isWasmInitialized) {
2561 throw new Error("initializeWasm() must be awaited first!");
2563 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner);
2564 return nativeResponseValue;
2566 // struct LDKPublicKey C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2568 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner: bigint): number {
2569 if(!isWasmInitialized) {
2570 throw new Error("initializeWasm() must be awaited first!");
2572 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner);
2573 return nativeResponseValue;
2575 // struct LDKFixedPenaltyScorer CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2577 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner: bigint): bigint {
2578 if(!isWasmInitialized) {
2579 throw new Error("initializeWasm() must be awaited first!");
2581 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner);
2582 return nativeResponseValue;
2584 // struct LDKDecodeError CResult_FixedPenaltyScorerDecodeErrorZ_get_err(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2586 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner: bigint): bigint {
2587 if(!isWasmInitialized) {
2588 throw new Error("initializeWasm() must be awaited first!");
2590 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner);
2591 return nativeResponseValue;
2593 // uint64_t C2Tuple_u64u64Z_get_a(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
2595 export function C2Tuple_u64u64Z_get_a(owner: bigint): bigint {
2596 if(!isWasmInitialized) {
2597 throw new Error("initializeWasm() must be awaited first!");
2599 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_a(owner);
2600 return nativeResponseValue;
2602 // uint64_t C2Tuple_u64u64Z_get_b(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
2604 export function C2Tuple_u64u64Z_get_b(owner: bigint): bigint {
2605 if(!isWasmInitialized) {
2606 throw new Error("initializeWasm() must be awaited first!");
2608 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_b(owner);
2609 return nativeResponseValue;
2612 export class LDKCOption_C2Tuple_u64u64ZZ {
2613 protected constructor() {}
2616 export function LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr: bigint): number {
2617 if(!isWasmInitialized) {
2618 throw new Error("initializeWasm() must be awaited first!");
2620 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr);
2621 return nativeResponseValue;
2624 export function LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr: bigint): bigint {
2625 if(!isWasmInitialized) {
2626 throw new Error("initializeWasm() must be awaited first!");
2628 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr);
2629 return nativeResponseValue;
2632 export interface LDKLogger {
2633 log (record: bigint): void;
2637 export function LDKLogger_new(impl: LDKLogger): [bigint, number] {
2638 if(!isWasmInitialized) {
2639 throw new Error("initializeWasm() must be awaited first!");
2641 var new_obj_idx = js_objs.length;
2642 for (var i = 0; i < js_objs.length; i++) {
2643 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2645 js_objs[i] = new WeakRef(impl);
2646 return [wasm.TS_LDKLogger_new(i), i];
2648 // struct LDKProbabilisticScorer CResult_ProbabilisticScorerDecodeErrorZ_get_ok(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2650 export function CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner: bigint): bigint {
2651 if(!isWasmInitialized) {
2652 throw new Error("initializeWasm() must be awaited first!");
2654 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner);
2655 return nativeResponseValue;
2657 // struct LDKDecodeError CResult_ProbabilisticScorerDecodeErrorZ_get_err(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2659 export function CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner: bigint): bigint {
2660 if(!isWasmInitialized) {
2661 throw new Error("initializeWasm() must be awaited first!");
2663 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner);
2664 return nativeResponseValue;
2666 // struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2668 export function CResult_InitFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2669 if(!isWasmInitialized) {
2670 throw new Error("initializeWasm() must be awaited first!");
2672 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_ok(owner);
2673 return nativeResponseValue;
2675 // struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2677 export function CResult_InitFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2678 if(!isWasmInitialized) {
2679 throw new Error("initializeWasm() must be awaited first!");
2681 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_err(owner);
2682 return nativeResponseValue;
2684 // struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2686 export function CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2687 if(!isWasmInitialized) {
2688 throw new Error("initializeWasm() must be awaited first!");
2690 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner);
2691 return nativeResponseValue;
2693 // struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2695 export function CResult_ChannelFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2696 if(!isWasmInitialized) {
2697 throw new Error("initializeWasm() must be awaited first!");
2699 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(owner);
2700 return nativeResponseValue;
2702 // struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2704 export function CResult_NodeFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2705 if(!isWasmInitialized) {
2706 throw new Error("initializeWasm() must be awaited first!");
2708 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(owner);
2709 return nativeResponseValue;
2711 // struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2713 export function CResult_NodeFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2714 if(!isWasmInitialized) {
2715 throw new Error("initializeWasm() must be awaited first!");
2717 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_err(owner);
2718 return nativeResponseValue;
2720 // struct LDKInvoiceFeatures CResult_InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2722 export function CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2723 if(!isWasmInitialized) {
2724 throw new Error("initializeWasm() must be awaited first!");
2726 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner);
2727 return nativeResponseValue;
2729 // struct LDKDecodeError CResult_InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2731 export function CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2732 if(!isWasmInitialized) {
2733 throw new Error("initializeWasm() must be awaited first!");
2735 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner);
2736 return nativeResponseValue;
2738 // struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2740 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2741 if(!isWasmInitialized) {
2742 throw new Error("initializeWasm() must be awaited first!");
2744 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner);
2745 return nativeResponseValue;
2747 // struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2749 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2750 if(!isWasmInitialized) {
2751 throw new Error("initializeWasm() must be awaited first!");
2753 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner);
2754 return nativeResponseValue;
2756 // struct LDKNodeId CResult_NodeIdDecodeErrorZ_get_ok(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2758 export function CResult_NodeIdDecodeErrorZ_get_ok(owner: bigint): bigint {
2759 if(!isWasmInitialized) {
2760 throw new Error("initializeWasm() must be awaited first!");
2762 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_ok(owner);
2763 return nativeResponseValue;
2765 // struct LDKDecodeError CResult_NodeIdDecodeErrorZ_get_err(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2767 export function CResult_NodeIdDecodeErrorZ_get_err(owner: bigint): bigint {
2768 if(!isWasmInitialized) {
2769 throw new Error("initializeWasm() must be awaited first!");
2771 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_err(owner);
2772 return nativeResponseValue;
2774 // struct LDKCOption_NetworkUpdateZ CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2776 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner: bigint): bigint {
2777 if(!isWasmInitialized) {
2778 throw new Error("initializeWasm() must be awaited first!");
2780 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner);
2781 return nativeResponseValue;
2783 // struct LDKDecodeError CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2785 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner: bigint): bigint {
2786 if(!isWasmInitialized) {
2787 throw new Error("initializeWasm() must be awaited first!");
2789 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner);
2790 return nativeResponseValue;
2793 export interface LDKAccess {
2794 get_utxo (genesis_hash: number, short_channel_id: bigint): bigint;
2798 export function LDKAccess_new(impl: LDKAccess): [bigint, number] {
2799 if(!isWasmInitialized) {
2800 throw new Error("initializeWasm() must be awaited first!");
2802 var new_obj_idx = js_objs.length;
2803 for (var i = 0; i < js_objs.length; i++) {
2804 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2806 js_objs[i] = new WeakRef(impl);
2807 return [wasm.TS_LDKAccess_new(i), i];
2809 // LDKCResult_TxOutAccessErrorZ Access_get_utxo LDKAccess *NONNULL_PTR this_arg, const uint8_t (*genesis_hash)[32], uint64_t short_channel_id
2811 export function Access_get_utxo(this_arg: bigint, genesis_hash: number, short_channel_id: bigint): bigint {
2812 if(!isWasmInitialized) {
2813 throw new Error("initializeWasm() must be awaited first!");
2815 const nativeResponseValue = wasm.TS_Access_get_utxo(this_arg, genesis_hash, short_channel_id);
2816 return nativeResponseValue;
2819 export class LDKCOption_AccessZ {
2820 protected constructor() {}
2823 export function LDKCOption_AccessZ_ty_from_ptr(ptr: bigint): number {
2824 if(!isWasmInitialized) {
2825 throw new Error("initializeWasm() must be awaited first!");
2827 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_ty_from_ptr(ptr);
2828 return nativeResponseValue;
2831 export function LDKCOption_AccessZ_Some_get_some(ptr: bigint): bigint {
2832 if(!isWasmInitialized) {
2833 throw new Error("initializeWasm() must be awaited first!");
2835 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_Some_get_some(ptr);
2836 return nativeResponseValue;
2838 // bool CResult_boolLightningErrorZ_get_ok(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
2840 export function CResult_boolLightningErrorZ_get_ok(owner: bigint): boolean {
2841 if(!isWasmInitialized) {
2842 throw new Error("initializeWasm() must be awaited first!");
2844 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_ok(owner);
2845 return nativeResponseValue;
2847 // struct LDKLightningError CResult_boolLightningErrorZ_get_err(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
2849 export function CResult_boolLightningErrorZ_get_err(owner: bigint): bigint {
2850 if(!isWasmInitialized) {
2851 throw new Error("initializeWasm() must be awaited first!");
2853 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_err(owner);
2854 return nativeResponseValue;
2856 // struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2858 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner: bigint): bigint {
2859 if(!isWasmInitialized) {
2860 throw new Error("initializeWasm() must be awaited first!");
2862 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner);
2863 return nativeResponseValue;
2865 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2867 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner: bigint): bigint {
2868 if(!isWasmInitialized) {
2869 throw new Error("initializeWasm() must be awaited first!");
2871 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner);
2872 return nativeResponseValue;
2874 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2876 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner: bigint): bigint {
2877 if(!isWasmInitialized) {
2878 throw new Error("initializeWasm() must be awaited first!");
2880 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner);
2881 return nativeResponseValue;
2884 export class LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
2885 protected constructor() {}
2888 export function LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_ty_from_ptr(ptr: bigint): number {
2889 if(!isWasmInitialized) {
2890 throw new Error("initializeWasm() must be awaited first!");
2892 const nativeResponseValue = wasm.TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_ty_from_ptr(ptr);
2893 return nativeResponseValue;
2896 export function LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_get_some(ptr: bigint): bigint {
2897 if(!isWasmInitialized) {
2898 throw new Error("initializeWasm() must be awaited first!");
2900 const nativeResponseValue = wasm.TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_get_some(ptr);
2901 return nativeResponseValue;
2903 // void CResult_NoneLightningErrorZ_get_ok(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
2905 export function CResult_NoneLightningErrorZ_get_ok(owner: bigint): void {
2906 if(!isWasmInitialized) {
2907 throw new Error("initializeWasm() must be awaited first!");
2909 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_ok(owner);
2910 // debug statements here
2912 // struct LDKLightningError CResult_NoneLightningErrorZ_get_err(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
2914 export function CResult_NoneLightningErrorZ_get_err(owner: bigint): bigint {
2915 if(!isWasmInitialized) {
2916 throw new Error("initializeWasm() must be awaited first!");
2918 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_err(owner);
2919 return nativeResponseValue;
2921 // struct LDKChannelUpdateInfo CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
2923 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
2924 if(!isWasmInitialized) {
2925 throw new Error("initializeWasm() must be awaited first!");
2927 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner);
2928 return nativeResponseValue;
2930 // struct LDKDecodeError CResult_ChannelUpdateInfoDecodeErrorZ_get_err(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
2932 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner: bigint): bigint {
2933 if(!isWasmInitialized) {
2934 throw new Error("initializeWasm() must be awaited first!");
2936 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner);
2937 return nativeResponseValue;
2939 // struct LDKChannelInfo CResult_ChannelInfoDecodeErrorZ_get_ok(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
2941 export function CResult_ChannelInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
2942 if(!isWasmInitialized) {
2943 throw new Error("initializeWasm() must be awaited first!");
2945 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_ok(owner);
2946 return nativeResponseValue;
2948 // struct LDKDecodeError CResult_ChannelInfoDecodeErrorZ_get_err(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
2950 export function CResult_ChannelInfoDecodeErrorZ_get_err(owner: bigint): bigint {
2951 if(!isWasmInitialized) {
2952 throw new Error("initializeWasm() must be awaited first!");
2954 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_err(owner);
2955 return nativeResponseValue;
2957 // struct LDKRoutingFees CResult_RoutingFeesDecodeErrorZ_get_ok(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
2959 export function CResult_RoutingFeesDecodeErrorZ_get_ok(owner: bigint): bigint {
2960 if(!isWasmInitialized) {
2961 throw new Error("initializeWasm() must be awaited first!");
2963 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_ok(owner);
2964 return nativeResponseValue;
2966 // struct LDKDecodeError CResult_RoutingFeesDecodeErrorZ_get_err(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
2968 export function CResult_RoutingFeesDecodeErrorZ_get_err(owner: bigint): bigint {
2969 if(!isWasmInitialized) {
2970 throw new Error("initializeWasm() must be awaited first!");
2972 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_err(owner);
2973 return nativeResponseValue;
2976 export class LDKNetAddress {
2977 protected constructor() {}
2980 export function LDKNetAddress_ty_from_ptr(ptr: bigint): number {
2981 if(!isWasmInitialized) {
2982 throw new Error("initializeWasm() must be awaited first!");
2984 const nativeResponseValue = wasm.TS_LDKNetAddress_ty_from_ptr(ptr);
2985 return nativeResponseValue;
2988 export function LDKNetAddress_IPv4_get_addr(ptr: bigint): number {
2989 if(!isWasmInitialized) {
2990 throw new Error("initializeWasm() must be awaited first!");
2992 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_addr(ptr);
2993 return nativeResponseValue;
2996 export function LDKNetAddress_IPv4_get_port(ptr: bigint): number {
2997 if(!isWasmInitialized) {
2998 throw new Error("initializeWasm() must be awaited first!");
3000 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_port(ptr);
3001 return nativeResponseValue;
3004 export function LDKNetAddress_IPv6_get_addr(ptr: bigint): number {
3005 if(!isWasmInitialized) {
3006 throw new Error("initializeWasm() must be awaited first!");
3008 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_addr(ptr);
3009 return nativeResponseValue;
3012 export function LDKNetAddress_IPv6_get_port(ptr: bigint): number {
3013 if(!isWasmInitialized) {
3014 throw new Error("initializeWasm() must be awaited first!");
3016 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_port(ptr);
3017 return nativeResponseValue;
3020 export function LDKNetAddress_OnionV2_get_onion_v2(ptr: bigint): number {
3021 if(!isWasmInitialized) {
3022 throw new Error("initializeWasm() must be awaited first!");
3024 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV2_get_onion_v2(ptr);
3025 return nativeResponseValue;
3028 export function LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr: bigint): number {
3029 if(!isWasmInitialized) {
3030 throw new Error("initializeWasm() must be awaited first!");
3032 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr);
3033 return nativeResponseValue;
3036 export function LDKNetAddress_OnionV3_get_checksum(ptr: bigint): number {
3037 if(!isWasmInitialized) {
3038 throw new Error("initializeWasm() must be awaited first!");
3040 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_checksum(ptr);
3041 return nativeResponseValue;
3044 export function LDKNetAddress_OnionV3_get_version(ptr: bigint): number {
3045 if(!isWasmInitialized) {
3046 throw new Error("initializeWasm() must be awaited first!");
3048 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_version(ptr);
3049 return nativeResponseValue;
3052 export function LDKNetAddress_OnionV3_get_port(ptr: bigint): number {
3053 if(!isWasmInitialized) {
3054 throw new Error("initializeWasm() must be awaited first!");
3056 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_port(ptr);
3057 return nativeResponseValue;
3060 export function LDKNetAddress_Hostname_get_hostname(ptr: bigint): bigint {
3061 if(!isWasmInitialized) {
3062 throw new Error("initializeWasm() must be awaited first!");
3064 const nativeResponseValue = wasm.TS_LDKNetAddress_Hostname_get_hostname(ptr);
3065 return nativeResponseValue;
3068 export function LDKNetAddress_Hostname_get_port(ptr: bigint): number {
3069 if(!isWasmInitialized) {
3070 throw new Error("initializeWasm() must be awaited first!");
3072 const nativeResponseValue = wasm.TS_LDKNetAddress_Hostname_get_port(ptr);
3073 return nativeResponseValue;
3075 // struct LDKNodeAnnouncementInfo CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
3077 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
3078 if(!isWasmInitialized) {
3079 throw new Error("initializeWasm() must be awaited first!");
3081 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner);
3082 return nativeResponseValue;
3084 // struct LDKDecodeError CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
3086 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner: bigint): bigint {
3087 if(!isWasmInitialized) {
3088 throw new Error("initializeWasm() must be awaited first!");
3090 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner);
3091 return nativeResponseValue;
3093 // struct LDKNodeAlias CResult_NodeAliasDecodeErrorZ_get_ok(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
3095 export function CResult_NodeAliasDecodeErrorZ_get_ok(owner: bigint): bigint {
3096 if(!isWasmInitialized) {
3097 throw new Error("initializeWasm() must be awaited first!");
3099 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_ok(owner);
3100 return nativeResponseValue;
3102 // struct LDKDecodeError CResult_NodeAliasDecodeErrorZ_get_err(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
3104 export function CResult_NodeAliasDecodeErrorZ_get_err(owner: bigint): bigint {
3105 if(!isWasmInitialized) {
3106 throw new Error("initializeWasm() must be awaited first!");
3108 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_err(owner);
3109 return nativeResponseValue;
3111 // struct LDKNodeInfo CResult_NodeInfoDecodeErrorZ_get_ok(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
3113 export function CResult_NodeInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
3114 if(!isWasmInitialized) {
3115 throw new Error("initializeWasm() must be awaited first!");
3117 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_ok(owner);
3118 return nativeResponseValue;
3120 // struct LDKDecodeError CResult_NodeInfoDecodeErrorZ_get_err(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
3122 export function CResult_NodeInfoDecodeErrorZ_get_err(owner: bigint): bigint {
3123 if(!isWasmInitialized) {
3124 throw new Error("initializeWasm() must be awaited first!");
3126 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_err(owner);
3127 return nativeResponseValue;
3129 // struct LDKNetworkGraph CResult_NetworkGraphDecodeErrorZ_get_ok(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
3131 export function CResult_NetworkGraphDecodeErrorZ_get_ok(owner: bigint): bigint {
3132 if(!isWasmInitialized) {
3133 throw new Error("initializeWasm() must be awaited first!");
3135 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_ok(owner);
3136 return nativeResponseValue;
3138 // struct LDKDecodeError CResult_NetworkGraphDecodeErrorZ_get_err(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
3140 export function CResult_NetworkGraphDecodeErrorZ_get_err(owner: bigint): bigint {
3141 if(!isWasmInitialized) {
3142 throw new Error("initializeWasm() must be awaited first!");
3144 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_err(owner);
3145 return nativeResponseValue;
3148 export class LDKCOption_CVec_NetAddressZZ {
3149 protected constructor() {}
3152 export function LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr: bigint): number {
3153 if(!isWasmInitialized) {
3154 throw new Error("initializeWasm() must be awaited first!");
3156 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr);
3157 return nativeResponseValue;
3160 export function LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr: bigint): number {
3161 if(!isWasmInitialized) {
3162 throw new Error("initializeWasm() must be awaited first!");
3164 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr);
3165 return nativeResponseValue;
3167 // struct LDKDelayedPaymentOutputDescriptor CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3169 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
3170 if(!isWasmInitialized) {
3171 throw new Error("initializeWasm() must be awaited first!");
3173 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
3174 return nativeResponseValue;
3176 // struct LDKDecodeError CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3178 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
3179 if(!isWasmInitialized) {
3180 throw new Error("initializeWasm() must be awaited first!");
3182 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
3183 return nativeResponseValue;
3185 // struct LDKStaticPaymentOutputDescriptor CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3187 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
3188 if(!isWasmInitialized) {
3189 throw new Error("initializeWasm() must be awaited first!");
3191 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
3192 return nativeResponseValue;
3194 // struct LDKDecodeError CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3196 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
3197 if(!isWasmInitialized) {
3198 throw new Error("initializeWasm() must be awaited first!");
3200 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
3201 return nativeResponseValue;
3203 // struct LDKSpendableOutputDescriptor CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3205 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
3206 if(!isWasmInitialized) {
3207 throw new Error("initializeWasm() must be awaited first!");
3209 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner);
3210 return nativeResponseValue;
3212 // struct LDKDecodeError CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3214 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
3215 if(!isWasmInitialized) {
3216 throw new Error("initializeWasm() must be awaited first!");
3218 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner);
3219 return nativeResponseValue;
3221 // struct LDKSignature C2Tuple_SignatureCVec_SignatureZZ_get_a(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
3223 export function C2Tuple_SignatureCVec_SignatureZZ_get_a(owner: bigint): number {
3224 if(!isWasmInitialized) {
3225 throw new Error("initializeWasm() must be awaited first!");
3227 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_a(owner);
3228 return nativeResponseValue;
3230 // struct LDKCVec_SignatureZ C2Tuple_SignatureCVec_SignatureZZ_get_b(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
3232 export function C2Tuple_SignatureCVec_SignatureZZ_get_b(owner: bigint): number {
3233 if(!isWasmInitialized) {
3234 throw new Error("initializeWasm() must be awaited first!");
3236 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_b(owner);
3237 return nativeResponseValue;
3239 // struct LDKC2Tuple_SignatureCVec_SignatureZZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
3241 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner: bigint): bigint {
3242 if(!isWasmInitialized) {
3243 throw new Error("initializeWasm() must be awaited first!");
3245 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner);
3246 return nativeResponseValue;
3248 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
3250 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner: bigint): void {
3251 if(!isWasmInitialized) {
3252 throw new Error("initializeWasm() must be awaited first!");
3254 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner);
3255 // debug statements here
3257 // struct LDKSignature CResult_SignatureNoneZ_get_ok(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
3259 export function CResult_SignatureNoneZ_get_ok(owner: bigint): number {
3260 if(!isWasmInitialized) {
3261 throw new Error("initializeWasm() must be awaited first!");
3263 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_ok(owner);
3264 return nativeResponseValue;
3266 // void CResult_SignatureNoneZ_get_err(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
3268 export function CResult_SignatureNoneZ_get_err(owner: bigint): void {
3269 if(!isWasmInitialized) {
3270 throw new Error("initializeWasm() must be awaited first!");
3272 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_err(owner);
3273 // debug statements here
3275 // struct LDKSignature C2Tuple_SignatureSignatureZ_get_a(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner);
3277 export function C2Tuple_SignatureSignatureZ_get_a(owner: bigint): number {
3278 if(!isWasmInitialized) {
3279 throw new Error("initializeWasm() must be awaited first!");
3281 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_get_a(owner);
3282 return nativeResponseValue;
3284 // struct LDKSignature C2Tuple_SignatureSignatureZ_get_b(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner);
3286 export function C2Tuple_SignatureSignatureZ_get_b(owner: bigint): number {
3287 if(!isWasmInitialized) {
3288 throw new Error("initializeWasm() must be awaited first!");
3290 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_get_b(owner);
3291 return nativeResponseValue;
3293 // struct LDKC2Tuple_SignatureSignatureZ CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner);
3295 export function CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner: bigint): bigint {
3296 if(!isWasmInitialized) {
3297 throw new Error("initializeWasm() must be awaited first!");
3299 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner);
3300 return nativeResponseValue;
3302 // void CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner);
3304 export function CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner: bigint): void {
3305 if(!isWasmInitialized) {
3306 throw new Error("initializeWasm() must be awaited first!");
3308 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner);
3309 // debug statements here
3311 // struct LDKSecretKey CResult_SecretKeyNoneZ_get_ok(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner);
3313 export function CResult_SecretKeyNoneZ_get_ok(owner: bigint): number {
3314 if(!isWasmInitialized) {
3315 throw new Error("initializeWasm() must be awaited first!");
3317 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_get_ok(owner);
3318 return nativeResponseValue;
3320 // void CResult_SecretKeyNoneZ_get_err(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner);
3322 export function CResult_SecretKeyNoneZ_get_err(owner: bigint): void {
3323 if(!isWasmInitialized) {
3324 throw new Error("initializeWasm() must be awaited first!");
3326 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_get_err(owner);
3327 // debug statements here
3330 export class LDKCOption_ScalarZ {
3331 protected constructor() {}
3334 export function LDKCOption_ScalarZ_ty_from_ptr(ptr: bigint): number {
3335 if(!isWasmInitialized) {
3336 throw new Error("initializeWasm() must be awaited first!");
3338 const nativeResponseValue = wasm.TS_LDKCOption_ScalarZ_ty_from_ptr(ptr);
3339 return nativeResponseValue;
3342 export function LDKCOption_ScalarZ_Some_get_some(ptr: bigint): bigint {
3343 if(!isWasmInitialized) {
3344 throw new Error("initializeWasm() must be awaited first!");
3346 const nativeResponseValue = wasm.TS_LDKCOption_ScalarZ_Some_get_some(ptr);
3347 return nativeResponseValue;
3349 // struct LDKThirtyTwoBytes CResult_SharedSecretNoneZ_get_ok(LDKCResult_SharedSecretNoneZ *NONNULL_PTR owner);
3351 export function CResult_SharedSecretNoneZ_get_ok(owner: bigint): number {
3352 if(!isWasmInitialized) {
3353 throw new Error("initializeWasm() must be awaited first!");
3355 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_get_ok(owner);
3356 return nativeResponseValue;
3358 // void CResult_SharedSecretNoneZ_get_err(LDKCResult_SharedSecretNoneZ *NONNULL_PTR owner);
3360 export function CResult_SharedSecretNoneZ_get_err(owner: bigint): void {
3361 if(!isWasmInitialized) {
3362 throw new Error("initializeWasm() must be awaited first!");
3364 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_get_err(owner);
3365 // debug statements here
3368 export interface LDKBaseSign {
3369 get_per_commitment_point (idx: bigint): number;
3370 release_commitment_secret (idx: bigint): number;
3371 validate_holder_commitment (holder_tx: bigint, preimages: number): bigint;
3372 channel_keys_id (): number;
3373 sign_counterparty_commitment (commitment_tx: bigint, preimages: number): bigint;
3374 validate_counterparty_revocation (idx: bigint, secret: number): bigint;
3375 sign_holder_commitment_and_htlcs (commitment_tx: bigint): bigint;
3376 sign_justice_revoked_output (justice_tx: number, input: number, amount: bigint, per_commitment_key: number): bigint;
3377 sign_justice_revoked_htlc (justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: bigint): bigint;
3378 sign_counterparty_htlc_transaction (htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: bigint): bigint;
3379 sign_closing_transaction (closing_tx: bigint): bigint;
3380 sign_channel_announcement (msg: bigint): bigint;
3381 ready_channel (channel_parameters: bigint): void;
3385 export function LDKBaseSign_new(impl: LDKBaseSign, pubkeys: bigint): [bigint, number] {
3386 if(!isWasmInitialized) {
3387 throw new Error("initializeWasm() must be awaited first!");
3389 var new_obj_idx = js_objs.length;
3390 for (var i = 0; i < js_objs.length; i++) {
3391 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3393 js_objs[i] = new WeakRef(impl);
3394 return [wasm.TS_LDKBaseSign_new(i, pubkeys), i];
3396 // LDKPublicKey BaseSign_get_per_commitment_point LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
3398 export function BaseSign_get_per_commitment_point(this_arg: bigint, idx: bigint): number {
3399 if(!isWasmInitialized) {
3400 throw new Error("initializeWasm() must be awaited first!");
3402 const nativeResponseValue = wasm.TS_BaseSign_get_per_commitment_point(this_arg, idx);
3403 return nativeResponseValue;
3405 // LDKThirtyTwoBytes BaseSign_release_commitment_secret LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
3407 export function BaseSign_release_commitment_secret(this_arg: bigint, idx: bigint): number {
3408 if(!isWasmInitialized) {
3409 throw new Error("initializeWasm() must be awaited first!");
3411 const nativeResponseValue = wasm.TS_BaseSign_release_commitment_secret(this_arg, idx);
3412 return nativeResponseValue;
3414 // LDKCResult_NoneNoneZ BaseSign_validate_holder_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_PaymentPreimageZ preimages
3416 export function BaseSign_validate_holder_commitment(this_arg: bigint, holder_tx: bigint, preimages: number): bigint {
3417 if(!isWasmInitialized) {
3418 throw new Error("initializeWasm() must be awaited first!");
3420 const nativeResponseValue = wasm.TS_BaseSign_validate_holder_commitment(this_arg, holder_tx, preimages);
3421 return nativeResponseValue;
3423 // LDKThirtyTwoBytes BaseSign_channel_keys_id LDKBaseSign *NONNULL_PTR this_arg
3425 export function BaseSign_channel_keys_id(this_arg: bigint): number {
3426 if(!isWasmInitialized) {
3427 throw new Error("initializeWasm() must be awaited first!");
3429 const nativeResponseValue = wasm.TS_BaseSign_channel_keys_id(this_arg);
3430 return nativeResponseValue;
3432 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_counterparty_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_PaymentPreimageZ preimages
3434 export function BaseSign_sign_counterparty_commitment(this_arg: bigint, commitment_tx: bigint, preimages: number): bigint {
3435 if(!isWasmInitialized) {
3436 throw new Error("initializeWasm() must be awaited first!");
3438 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_commitment(this_arg, commitment_tx, preimages);
3439 return nativeResponseValue;
3441 // LDKCResult_NoneNoneZ BaseSign_validate_counterparty_revocation LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx, const uint8_t (*secret)[32]
3443 export function BaseSign_validate_counterparty_revocation(this_arg: bigint, idx: bigint, secret: number): bigint {
3444 if(!isWasmInitialized) {
3445 throw new Error("initializeWasm() must be awaited first!");
3447 const nativeResponseValue = wasm.TS_BaseSign_validate_counterparty_revocation(this_arg, idx, secret);
3448 return nativeResponseValue;
3450 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_holder_commitment_and_htlcs LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx
3452 export function BaseSign_sign_holder_commitment_and_htlcs(this_arg: bigint, commitment_tx: bigint): bigint {
3453 if(!isWasmInitialized) {
3454 throw new Error("initializeWasm() must be awaited first!");
3456 const nativeResponseValue = wasm.TS_BaseSign_sign_holder_commitment_and_htlcs(this_arg, commitment_tx);
3457 return nativeResponseValue;
3459 // 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]
3461 export function BaseSign_sign_justice_revoked_output(this_arg: bigint, justice_tx: number, input: number, amount: bigint, per_commitment_key: number): bigint {
3462 if(!isWasmInitialized) {
3463 throw new Error("initializeWasm() must be awaited first!");
3465 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_output(this_arg, justice_tx, input, amount, per_commitment_key);
3466 return nativeResponseValue;
3468 // 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
3470 export function BaseSign_sign_justice_revoked_htlc(this_arg: bigint, justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: bigint): bigint {
3471 if(!isWasmInitialized) {
3472 throw new Error("initializeWasm() must be awaited first!");
3474 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_htlc(this_arg, justice_tx, input, amount, per_commitment_key, htlc);
3475 return nativeResponseValue;
3477 // 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
3479 export function BaseSign_sign_counterparty_htlc_transaction(this_arg: bigint, htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: bigint): bigint {
3480 if(!isWasmInitialized) {
3481 throw new Error("initializeWasm() must be awaited first!");
3483 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_htlc_transaction(this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
3484 return nativeResponseValue;
3486 // LDKCResult_SignatureNoneZ BaseSign_sign_closing_transaction LDKBaseSign *NONNULL_PTR this_arg, const struct LDKClosingTransaction *NONNULL_PTR closing_tx
3488 export function BaseSign_sign_closing_transaction(this_arg: bigint, closing_tx: bigint): bigint {
3489 if(!isWasmInitialized) {
3490 throw new Error("initializeWasm() must be awaited first!");
3492 const nativeResponseValue = wasm.TS_BaseSign_sign_closing_transaction(this_arg, closing_tx);
3493 return nativeResponseValue;
3495 // LDKCResult_C2Tuple_SignatureSignatureZNoneZ BaseSign_sign_channel_announcement LDKBaseSign *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg
3497 export function BaseSign_sign_channel_announcement(this_arg: bigint, msg: bigint): bigint {
3498 if(!isWasmInitialized) {
3499 throw new Error("initializeWasm() must be awaited first!");
3501 const nativeResponseValue = wasm.TS_BaseSign_sign_channel_announcement(this_arg, msg);
3502 return nativeResponseValue;
3504 // void BaseSign_ready_channel LDKBaseSign *NONNULL_PTR this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters
3506 export function BaseSign_ready_channel(this_arg: bigint, channel_parameters: bigint): void {
3507 if(!isWasmInitialized) {
3508 throw new Error("initializeWasm() must be awaited first!");
3510 const nativeResponseValue = wasm.TS_BaseSign_ready_channel(this_arg, channel_parameters);
3511 // debug statements here
3513 // LDKChannelPublicKeys BaseSign_get_pubkeys LDKBaseSign *NONNULL_PTR this_arg
3515 export function BaseSign_get_pubkeys(this_arg: bigint): bigint {
3516 if(!isWasmInitialized) {
3517 throw new Error("initializeWasm() must be awaited first!");
3519 const nativeResponseValue = wasm.TS_BaseSign_get_pubkeys(this_arg);
3520 return nativeResponseValue;
3523 export interface LDKSign {
3528 export function LDKSign_new(impl: LDKSign, BaseSign: number, pubkeys: bigint): [bigint, number] {
3529 if(!isWasmInitialized) {
3530 throw new Error("initializeWasm() must be awaited first!");
3532 var new_obj_idx = js_objs.length;
3533 for (var i = 0; i < js_objs.length; i++) {
3534 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3536 js_objs[i] = new WeakRef(impl);
3537 return [wasm.TS_LDKSign_new(i, BaseSign, pubkeys), i];
3539 // LDKCVec_u8Z Sign_write LDKSign *NONNULL_PTR this_arg
3541 export function Sign_write(this_arg: bigint): number {
3542 if(!isWasmInitialized) {
3543 throw new Error("initializeWasm() must be awaited first!");
3545 const nativeResponseValue = wasm.TS_Sign_write(this_arg);
3546 return nativeResponseValue;
3548 // struct LDKSign CResult_SignDecodeErrorZ_get_ok(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
3550 export function CResult_SignDecodeErrorZ_get_ok(owner: bigint): bigint {
3551 if(!isWasmInitialized) {
3552 throw new Error("initializeWasm() must be awaited first!");
3554 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_ok(owner);
3555 return nativeResponseValue;
3557 // struct LDKDecodeError CResult_SignDecodeErrorZ_get_err(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
3559 export function CResult_SignDecodeErrorZ_get_err(owner: bigint): bigint {
3560 if(!isWasmInitialized) {
3561 throw new Error("initializeWasm() must be awaited first!");
3563 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_err(owner);
3564 return nativeResponseValue;
3566 // struct LDKRecoverableSignature CResult_RecoverableSignatureNoneZ_get_ok(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
3568 export function CResult_RecoverableSignatureNoneZ_get_ok(owner: bigint): number {
3569 if(!isWasmInitialized) {
3570 throw new Error("initializeWasm() must be awaited first!");
3572 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_ok(owner);
3573 return nativeResponseValue;
3575 // void CResult_RecoverableSignatureNoneZ_get_err(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
3577 export function CResult_RecoverableSignatureNoneZ_get_err(owner: bigint): void {
3578 if(!isWasmInitialized) {
3579 throw new Error("initializeWasm() must be awaited first!");
3581 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_err(owner);
3582 // debug statements here
3584 // struct LDKCVec_CVec_u8ZZ CResult_CVec_CVec_u8ZZNoneZ_get_ok(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
3586 export function CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner: bigint): number {
3587 if(!isWasmInitialized) {
3588 throw new Error("initializeWasm() must be awaited first!");
3590 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner);
3591 return nativeResponseValue;
3593 // void CResult_CVec_CVec_u8ZZNoneZ_get_err(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
3595 export function CResult_CVec_CVec_u8ZZNoneZ_get_err(owner: bigint): void {
3596 if(!isWasmInitialized) {
3597 throw new Error("initializeWasm() must be awaited first!");
3599 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_err(owner);
3600 // debug statements here
3602 // struct LDKInMemorySigner CResult_InMemorySignerDecodeErrorZ_get_ok(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
3604 export function CResult_InMemorySignerDecodeErrorZ_get_ok(owner: bigint): bigint {
3605 if(!isWasmInitialized) {
3606 throw new Error("initializeWasm() must be awaited first!");
3608 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_ok(owner);
3609 return nativeResponseValue;
3611 // struct LDKDecodeError CResult_InMemorySignerDecodeErrorZ_get_err(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
3613 export function CResult_InMemorySignerDecodeErrorZ_get_err(owner: bigint): bigint {
3614 if(!isWasmInitialized) {
3615 throw new Error("initializeWasm() must be awaited first!");
3617 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_err(owner);
3618 return nativeResponseValue;
3620 // struct LDKTransaction CResult_TransactionNoneZ_get_ok(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
3622 export function CResult_TransactionNoneZ_get_ok(owner: bigint): number {
3623 if(!isWasmInitialized) {
3624 throw new Error("initializeWasm() must be awaited first!");
3626 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_ok(owner);
3627 return nativeResponseValue;
3629 // void CResult_TransactionNoneZ_get_err(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
3631 export function CResult_TransactionNoneZ_get_err(owner: bigint): void {
3632 if(!isWasmInitialized) {
3633 throw new Error("initializeWasm() must be awaited first!");
3635 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_err(owner);
3636 // debug statements here
3639 export class LDKCOption_u16Z {
3640 protected constructor() {}
3643 export function LDKCOption_u16Z_ty_from_ptr(ptr: bigint): number {
3644 if(!isWasmInitialized) {
3645 throw new Error("initializeWasm() must be awaited first!");
3647 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_ty_from_ptr(ptr);
3648 return nativeResponseValue;
3651 export function LDKCOption_u16Z_Some_get_some(ptr: bigint): number {
3652 if(!isWasmInitialized) {
3653 throw new Error("initializeWasm() must be awaited first!");
3655 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_Some_get_some(ptr);
3656 return nativeResponseValue;
3659 export class LDKAPIError {
3660 protected constructor() {}
3663 export function LDKAPIError_ty_from_ptr(ptr: bigint): number {
3664 if(!isWasmInitialized) {
3665 throw new Error("initializeWasm() must be awaited first!");
3667 const nativeResponseValue = wasm.TS_LDKAPIError_ty_from_ptr(ptr);
3668 return nativeResponseValue;
3671 export function LDKAPIError_APIMisuseError_get_err(ptr: bigint): number {
3672 if(!isWasmInitialized) {
3673 throw new Error("initializeWasm() must be awaited first!");
3675 const nativeResponseValue = wasm.TS_LDKAPIError_APIMisuseError_get_err(ptr);
3676 return nativeResponseValue;
3679 export function LDKAPIError_FeeRateTooHigh_get_err(ptr: bigint): number {
3680 if(!isWasmInitialized) {
3681 throw new Error("initializeWasm() must be awaited first!");
3683 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_err(ptr);
3684 return nativeResponseValue;
3687 export function LDKAPIError_FeeRateTooHigh_get_feerate(ptr: bigint): number {
3688 if(!isWasmInitialized) {
3689 throw new Error("initializeWasm() must be awaited first!");
3691 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_feerate(ptr);
3692 return nativeResponseValue;
3695 export function LDKAPIError_RouteError_get_err(ptr: bigint): number {
3696 if(!isWasmInitialized) {
3697 throw new Error("initializeWasm() must be awaited first!");
3699 const nativeResponseValue = wasm.TS_LDKAPIError_RouteError_get_err(ptr);
3700 return nativeResponseValue;
3703 export function LDKAPIError_ChannelUnavailable_get_err(ptr: bigint): number {
3704 if(!isWasmInitialized) {
3705 throw new Error("initializeWasm() must be awaited first!");
3707 const nativeResponseValue = wasm.TS_LDKAPIError_ChannelUnavailable_get_err(ptr);
3708 return nativeResponseValue;
3711 export function LDKAPIError_IncompatibleShutdownScript_get_script(ptr: bigint): bigint {
3712 if(!isWasmInitialized) {
3713 throw new Error("initializeWasm() must be awaited first!");
3715 const nativeResponseValue = wasm.TS_LDKAPIError_IncompatibleShutdownScript_get_script(ptr);
3716 return nativeResponseValue;
3718 // void CResult_NoneAPIErrorZ_get_ok(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
3720 export function CResult_NoneAPIErrorZ_get_ok(owner: bigint): void {
3721 if(!isWasmInitialized) {
3722 throw new Error("initializeWasm() must be awaited first!");
3724 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_ok(owner);
3725 // debug statements here
3727 // struct LDKAPIError CResult_NoneAPIErrorZ_get_err(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
3729 export function CResult_NoneAPIErrorZ_get_err(owner: bigint): bigint {
3730 if(!isWasmInitialized) {
3731 throw new Error("initializeWasm() must be awaited first!");
3733 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_err(owner);
3734 return nativeResponseValue;
3736 // struct LDKThirtyTwoBytes CResult__u832APIErrorZ_get_ok(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
3738 export function CResult__u832APIErrorZ_get_ok(owner: bigint): number {
3739 if(!isWasmInitialized) {
3740 throw new Error("initializeWasm() must be awaited first!");
3742 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_ok(owner);
3743 return nativeResponseValue;
3745 // struct LDKAPIError CResult__u832APIErrorZ_get_err(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
3747 export function CResult__u832APIErrorZ_get_err(owner: bigint): bigint {
3748 if(!isWasmInitialized) {
3749 throw new Error("initializeWasm() must be awaited first!");
3751 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_err(owner);
3752 return nativeResponseValue;
3755 export class LDKPaymentSendFailure {
3756 protected constructor() {}
3759 export function LDKPaymentSendFailure_ty_from_ptr(ptr: bigint): number {
3760 if(!isWasmInitialized) {
3761 throw new Error("initializeWasm() must be awaited first!");
3763 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ty_from_ptr(ptr);
3764 return nativeResponseValue;
3767 export function LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr: bigint): bigint {
3768 if(!isWasmInitialized) {
3769 throw new Error("initializeWasm() must be awaited first!");
3771 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr);
3772 return nativeResponseValue;
3775 export function LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr: bigint): number {
3776 if(!isWasmInitialized) {
3777 throw new Error("initializeWasm() must be awaited first!");
3779 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr);
3780 return nativeResponseValue;
3783 export function LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr: bigint): number {
3784 if(!isWasmInitialized) {
3785 throw new Error("initializeWasm() must be awaited first!");
3787 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr);
3788 return nativeResponseValue;
3791 export function LDKPaymentSendFailure_PartialFailure_get_results(ptr: bigint): number {
3792 if(!isWasmInitialized) {
3793 throw new Error("initializeWasm() must be awaited first!");
3795 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_results(ptr);
3796 return nativeResponseValue;
3799 export function LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr: bigint): bigint {
3800 if(!isWasmInitialized) {
3801 throw new Error("initializeWasm() must be awaited first!");
3803 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr);
3804 return nativeResponseValue;
3807 export function LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr: bigint): number {
3808 if(!isWasmInitialized) {
3809 throw new Error("initializeWasm() must be awaited first!");
3811 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr);
3812 return nativeResponseValue;
3814 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentSendFailureZ_get_ok(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
3816 export function CResult_PaymentIdPaymentSendFailureZ_get_ok(owner: bigint): number {
3817 if(!isWasmInitialized) {
3818 throw new Error("initializeWasm() must be awaited first!");
3820 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_ok(owner);
3821 return nativeResponseValue;
3823 // struct LDKPaymentSendFailure CResult_PaymentIdPaymentSendFailureZ_get_err(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
3825 export function CResult_PaymentIdPaymentSendFailureZ_get_err(owner: bigint): bigint {
3826 if(!isWasmInitialized) {
3827 throw new Error("initializeWasm() must be awaited first!");
3829 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_err(owner);
3830 return nativeResponseValue;
3832 // void CResult_NonePaymentSendFailureZ_get_ok(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
3834 export function CResult_NonePaymentSendFailureZ_get_ok(owner: bigint): void {
3835 if(!isWasmInitialized) {
3836 throw new Error("initializeWasm() must be awaited first!");
3838 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_ok(owner);
3839 // debug statements here
3841 // struct LDKPaymentSendFailure CResult_NonePaymentSendFailureZ_get_err(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
3843 export function CResult_NonePaymentSendFailureZ_get_err(owner: bigint): bigint {
3844 if(!isWasmInitialized) {
3845 throw new Error("initializeWasm() must be awaited first!");
3847 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_err(owner);
3848 return nativeResponseValue;
3850 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_a(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
3852 export function C2Tuple_PaymentHashPaymentIdZ_get_a(owner: bigint): number {
3853 if(!isWasmInitialized) {
3854 throw new Error("initializeWasm() must be awaited first!");
3856 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_a(owner);
3857 return nativeResponseValue;
3859 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_b(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
3861 export function C2Tuple_PaymentHashPaymentIdZ_get_b(owner: bigint): number {
3862 if(!isWasmInitialized) {
3863 throw new Error("initializeWasm() must be awaited first!");
3865 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_b(owner);
3866 return nativeResponseValue;
3868 // struct LDKC2Tuple_PaymentHashPaymentIdZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
3870 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner: bigint): bigint {
3871 if(!isWasmInitialized) {
3872 throw new Error("initializeWasm() must be awaited first!");
3874 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner);
3875 return nativeResponseValue;
3877 // struct LDKPaymentSendFailure CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
3879 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner: bigint): bigint {
3880 if(!isWasmInitialized) {
3881 throw new Error("initializeWasm() must be awaited first!");
3883 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner);
3884 return nativeResponseValue;
3886 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_a(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
3888 export function C2Tuple_PaymentHashPaymentSecretZ_get_a(owner: bigint): number {
3889 if(!isWasmInitialized) {
3890 throw new Error("initializeWasm() must be awaited first!");
3892 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_a(owner);
3893 return nativeResponseValue;
3895 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_b(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
3897 export function C2Tuple_PaymentHashPaymentSecretZ_get_b(owner: bigint): number {
3898 if(!isWasmInitialized) {
3899 throw new Error("initializeWasm() must be awaited first!");
3901 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_b(owner);
3902 return nativeResponseValue;
3904 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
3906 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner: bigint): bigint {
3907 if(!isWasmInitialized) {
3908 throw new Error("initializeWasm() must be awaited first!");
3910 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner);
3911 return nativeResponseValue;
3913 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
3915 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner: bigint): void {
3916 if(!isWasmInitialized) {
3917 throw new Error("initializeWasm() must be awaited first!");
3919 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner);
3920 // debug statements here
3922 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
3924 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner: bigint): bigint {
3925 if(!isWasmInitialized) {
3926 throw new Error("initializeWasm() must be awaited first!");
3928 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner);
3929 return nativeResponseValue;
3931 // struct LDKAPIError CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
3933 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner: bigint): bigint {
3934 if(!isWasmInitialized) {
3935 throw new Error("initializeWasm() must be awaited first!");
3937 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner);
3938 return nativeResponseValue;
3940 // struct LDKThirtyTwoBytes CResult_PaymentSecretNoneZ_get_ok(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
3942 export function CResult_PaymentSecretNoneZ_get_ok(owner: bigint): number {
3943 if(!isWasmInitialized) {
3944 throw new Error("initializeWasm() must be awaited first!");
3946 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_ok(owner);
3947 return nativeResponseValue;
3949 // void CResult_PaymentSecretNoneZ_get_err(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
3951 export function CResult_PaymentSecretNoneZ_get_err(owner: bigint): void {
3952 if(!isWasmInitialized) {
3953 throw new Error("initializeWasm() must be awaited first!");
3955 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_err(owner);
3956 // debug statements here
3958 // struct LDKThirtyTwoBytes CResult_PaymentSecretAPIErrorZ_get_ok(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
3960 export function CResult_PaymentSecretAPIErrorZ_get_ok(owner: bigint): number {
3961 if(!isWasmInitialized) {
3962 throw new Error("initializeWasm() must be awaited first!");
3964 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_ok(owner);
3965 return nativeResponseValue;
3967 // struct LDKAPIError CResult_PaymentSecretAPIErrorZ_get_err(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
3969 export function CResult_PaymentSecretAPIErrorZ_get_err(owner: bigint): bigint {
3970 if(!isWasmInitialized) {
3971 throw new Error("initializeWasm() must be awaited first!");
3973 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_err(owner);
3974 return nativeResponseValue;
3976 // struct LDKThirtyTwoBytes CResult_PaymentPreimageAPIErrorZ_get_ok(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
3978 export function CResult_PaymentPreimageAPIErrorZ_get_ok(owner: bigint): number {
3979 if(!isWasmInitialized) {
3980 throw new Error("initializeWasm() must be awaited first!");
3982 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_ok(owner);
3983 return nativeResponseValue;
3985 // struct LDKAPIError CResult_PaymentPreimageAPIErrorZ_get_err(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
3987 export function CResult_PaymentPreimageAPIErrorZ_get_err(owner: bigint): bigint {
3988 if(!isWasmInitialized) {
3989 throw new Error("initializeWasm() must be awaited first!");
3991 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_err(owner);
3992 return nativeResponseValue;
3994 // struct LDKCounterpartyForwardingInfo CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
3996 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
3997 if(!isWasmInitialized) {
3998 throw new Error("initializeWasm() must be awaited first!");
4000 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner);
4001 return nativeResponseValue;
4003 // struct LDKDecodeError CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
4005 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner: bigint): bigint {
4006 if(!isWasmInitialized) {
4007 throw new Error("initializeWasm() must be awaited first!");
4009 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner);
4010 return nativeResponseValue;
4012 // struct LDKChannelCounterparty CResult_ChannelCounterpartyDecodeErrorZ_get_ok(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
4014 export function CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner: bigint): bigint {
4015 if(!isWasmInitialized) {
4016 throw new Error("initializeWasm() must be awaited first!");
4018 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner);
4019 return nativeResponseValue;
4021 // struct LDKDecodeError CResult_ChannelCounterpartyDecodeErrorZ_get_err(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
4023 export function CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner: bigint): bigint {
4024 if(!isWasmInitialized) {
4025 throw new Error("initializeWasm() must be awaited first!");
4027 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner);
4028 return nativeResponseValue;
4030 // struct LDKChannelDetails CResult_ChannelDetailsDecodeErrorZ_get_ok(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
4032 export function CResult_ChannelDetailsDecodeErrorZ_get_ok(owner: bigint): bigint {
4033 if(!isWasmInitialized) {
4034 throw new Error("initializeWasm() must be awaited first!");
4036 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_ok(owner);
4037 return nativeResponseValue;
4039 // struct LDKDecodeError CResult_ChannelDetailsDecodeErrorZ_get_err(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
4041 export function CResult_ChannelDetailsDecodeErrorZ_get_err(owner: bigint): bigint {
4042 if(!isWasmInitialized) {
4043 throw new Error("initializeWasm() must be awaited first!");
4045 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_err(owner);
4046 return nativeResponseValue;
4048 // struct LDKPhantomRouteHints CResult_PhantomRouteHintsDecodeErrorZ_get_ok(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
4050 export function CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner: bigint): bigint {
4051 if(!isWasmInitialized) {
4052 throw new Error("initializeWasm() must be awaited first!");
4054 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner);
4055 return nativeResponseValue;
4057 // struct LDKDecodeError CResult_PhantomRouteHintsDecodeErrorZ_get_err(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
4059 export function CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner: bigint): bigint {
4060 if(!isWasmInitialized) {
4061 throw new Error("initializeWasm() must be awaited first!");
4063 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner);
4064 return nativeResponseValue;
4067 export interface LDKWatch {
4068 watch_channel (funding_txo: bigint, monitor: bigint): bigint;
4069 update_channel (funding_txo: bigint, update: bigint): bigint;
4070 release_pending_monitor_events (): number;
4074 export function LDKWatch_new(impl: LDKWatch): [bigint, number] {
4075 if(!isWasmInitialized) {
4076 throw new Error("initializeWasm() must be awaited first!");
4078 var new_obj_idx = js_objs.length;
4079 for (var i = 0; i < js_objs.length; i++) {
4080 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4082 js_objs[i] = new WeakRef(impl);
4083 return [wasm.TS_LDKWatch_new(i), i];
4085 // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_watch_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor
4087 export function Watch_watch_channel(this_arg: bigint, funding_txo: bigint, monitor: bigint): bigint {
4088 if(!isWasmInitialized) {
4089 throw new Error("initializeWasm() must be awaited first!");
4091 const nativeResponseValue = wasm.TS_Watch_watch_channel(this_arg, funding_txo, monitor);
4092 return nativeResponseValue;
4094 // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_update_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update
4096 export function Watch_update_channel(this_arg: bigint, funding_txo: bigint, update: bigint): bigint {
4097 if(!isWasmInitialized) {
4098 throw new Error("initializeWasm() must be awaited first!");
4100 const nativeResponseValue = wasm.TS_Watch_update_channel(this_arg, funding_txo, update);
4101 return nativeResponseValue;
4103 // LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Watch_release_pending_monitor_events LDKWatch *NONNULL_PTR this_arg
4105 export function Watch_release_pending_monitor_events(this_arg: bigint): number {
4106 if(!isWasmInitialized) {
4107 throw new Error("initializeWasm() must be awaited first!");
4109 const nativeResponseValue = wasm.TS_Watch_release_pending_monitor_events(this_arg);
4110 return nativeResponseValue;
4113 export interface LDKBroadcasterInterface {
4114 broadcast_transaction (tx: number): void;
4118 export function LDKBroadcasterInterface_new(impl: LDKBroadcasterInterface): [bigint, number] {
4119 if(!isWasmInitialized) {
4120 throw new Error("initializeWasm() must be awaited first!");
4122 var new_obj_idx = js_objs.length;
4123 for (var i = 0; i < js_objs.length; i++) {
4124 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4126 js_objs[i] = new WeakRef(impl);
4127 return [wasm.TS_LDKBroadcasterInterface_new(i), i];
4129 // void BroadcasterInterface_broadcast_transaction LDKBroadcasterInterface *NONNULL_PTR this_arg, struct LDKTransaction tx
4131 export function BroadcasterInterface_broadcast_transaction(this_arg: bigint, tx: number): void {
4132 if(!isWasmInitialized) {
4133 throw new Error("initializeWasm() must be awaited first!");
4135 const nativeResponseValue = wasm.TS_BroadcasterInterface_broadcast_transaction(this_arg, tx);
4136 // debug statements here
4139 export interface LDKKeysInterface {
4140 get_node_secret (recipient: Recipient): bigint;
4141 ecdh (recipient: Recipient, other_key: number, tweak: bigint): bigint;
4142 get_destination_script (): number;
4143 get_shutdown_scriptpubkey (): bigint;
4144 get_channel_signer (inbound: boolean, channel_value_satoshis: bigint): bigint;
4145 get_secure_random_bytes (): number;
4146 read_chan_signer (reader: number): bigint;
4147 sign_invoice (hrp_bytes: number, invoice_data: number, receipient: Recipient): bigint;
4148 get_inbound_payment_key_material (): number;
4152 export function LDKKeysInterface_new(impl: LDKKeysInterface): [bigint, number] {
4153 if(!isWasmInitialized) {
4154 throw new Error("initializeWasm() must be awaited first!");
4156 var new_obj_idx = js_objs.length;
4157 for (var i = 0; i < js_objs.length; i++) {
4158 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4160 js_objs[i] = new WeakRef(impl);
4161 return [wasm.TS_LDKKeysInterface_new(i), i];
4163 // LDKCResult_SecretKeyNoneZ KeysInterface_get_node_secret LDKKeysInterface *NONNULL_PTR this_arg, enum LDKRecipient recipient
4165 export function KeysInterface_get_node_secret(this_arg: bigint, recipient: Recipient): bigint {
4166 if(!isWasmInitialized) {
4167 throw new Error("initializeWasm() must be awaited first!");
4169 const nativeResponseValue = wasm.TS_KeysInterface_get_node_secret(this_arg, recipient);
4170 return nativeResponseValue;
4172 // LDKCResult_SharedSecretNoneZ KeysInterface_ecdh LDKKeysInterface *NONNULL_PTR this_arg, enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_ScalarZ tweak
4174 export function KeysInterface_ecdh(this_arg: bigint, recipient: Recipient, other_key: number, tweak: bigint): bigint {
4175 if(!isWasmInitialized) {
4176 throw new Error("initializeWasm() must be awaited first!");
4178 const nativeResponseValue = wasm.TS_KeysInterface_ecdh(this_arg, recipient, other_key, tweak);
4179 return nativeResponseValue;
4181 // LDKCVec_u8Z KeysInterface_get_destination_script LDKKeysInterface *NONNULL_PTR this_arg
4183 export function KeysInterface_get_destination_script(this_arg: bigint): number {
4184 if(!isWasmInitialized) {
4185 throw new Error("initializeWasm() must be awaited first!");
4187 const nativeResponseValue = wasm.TS_KeysInterface_get_destination_script(this_arg);
4188 return nativeResponseValue;
4190 // LDKShutdownScript KeysInterface_get_shutdown_scriptpubkey LDKKeysInterface *NONNULL_PTR this_arg
4192 export function KeysInterface_get_shutdown_scriptpubkey(this_arg: bigint): bigint {
4193 if(!isWasmInitialized) {
4194 throw new Error("initializeWasm() must be awaited first!");
4196 const nativeResponseValue = wasm.TS_KeysInterface_get_shutdown_scriptpubkey(this_arg);
4197 return nativeResponseValue;
4199 // LDKSign KeysInterface_get_channel_signer LDKKeysInterface *NONNULL_PTR this_arg, bool inbound, uint64_t channel_value_satoshis
4201 export function KeysInterface_get_channel_signer(this_arg: bigint, inbound: boolean, channel_value_satoshis: bigint): bigint {
4202 if(!isWasmInitialized) {
4203 throw new Error("initializeWasm() must be awaited first!");
4205 const nativeResponseValue = wasm.TS_KeysInterface_get_channel_signer(this_arg, inbound, channel_value_satoshis);
4206 return nativeResponseValue;
4208 // LDKThirtyTwoBytes KeysInterface_get_secure_random_bytes LDKKeysInterface *NONNULL_PTR this_arg
4210 export function KeysInterface_get_secure_random_bytes(this_arg: bigint): number {
4211 if(!isWasmInitialized) {
4212 throw new Error("initializeWasm() must be awaited first!");
4214 const nativeResponseValue = wasm.TS_KeysInterface_get_secure_random_bytes(this_arg);
4215 return nativeResponseValue;
4217 // LDKCResult_SignDecodeErrorZ KeysInterface_read_chan_signer LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice reader
4219 export function KeysInterface_read_chan_signer(this_arg: bigint, reader: number): bigint {
4220 if(!isWasmInitialized) {
4221 throw new Error("initializeWasm() must be awaited first!");
4223 const nativeResponseValue = wasm.TS_KeysInterface_read_chan_signer(this_arg, reader);
4224 return nativeResponseValue;
4226 // LDKCResult_RecoverableSignatureNoneZ KeysInterface_sign_invoice LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z invoice_data, enum LDKRecipient receipient
4228 export function KeysInterface_sign_invoice(this_arg: bigint, hrp_bytes: number, invoice_data: number, receipient: Recipient): bigint {
4229 if(!isWasmInitialized) {
4230 throw new Error("initializeWasm() must be awaited first!");
4232 const nativeResponseValue = wasm.TS_KeysInterface_sign_invoice(this_arg, hrp_bytes, invoice_data, receipient);
4233 return nativeResponseValue;
4235 // LDKThirtyTwoBytes KeysInterface_get_inbound_payment_key_material LDKKeysInterface *NONNULL_PTR this_arg
4237 export function KeysInterface_get_inbound_payment_key_material(this_arg: bigint): number {
4238 if(!isWasmInitialized) {
4239 throw new Error("initializeWasm() must be awaited first!");
4241 const nativeResponseValue = wasm.TS_KeysInterface_get_inbound_payment_key_material(this_arg);
4242 return nativeResponseValue;
4245 export interface LDKFeeEstimator {
4246 get_est_sat_per_1000_weight (confirmation_target: ConfirmationTarget): number;
4250 export function LDKFeeEstimator_new(impl: LDKFeeEstimator): [bigint, number] {
4251 if(!isWasmInitialized) {
4252 throw new Error("initializeWasm() must be awaited first!");
4254 var new_obj_idx = js_objs.length;
4255 for (var i = 0; i < js_objs.length; i++) {
4256 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4258 js_objs[i] = new WeakRef(impl);
4259 return [wasm.TS_LDKFeeEstimator_new(i), i];
4261 // uint32_t FeeEstimator_get_est_sat_per_1000_weight LDKFeeEstimator *NONNULL_PTR this_arg, enum LDKConfirmationTarget confirmation_target
4263 export function FeeEstimator_get_est_sat_per_1000_weight(this_arg: bigint, confirmation_target: ConfirmationTarget): number {
4264 if(!isWasmInitialized) {
4265 throw new Error("initializeWasm() must be awaited first!");
4267 const nativeResponseValue = wasm.TS_FeeEstimator_get_est_sat_per_1000_weight(this_arg, confirmation_target);
4268 return nativeResponseValue;
4270 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelManagerZ_get_a(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
4272 export function C2Tuple_BlockHashChannelManagerZ_get_a(owner: bigint): number {
4273 if(!isWasmInitialized) {
4274 throw new Error("initializeWasm() must be awaited first!");
4276 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_a(owner);
4277 return nativeResponseValue;
4279 // struct LDKChannelManager C2Tuple_BlockHashChannelManagerZ_get_b(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
4281 export function C2Tuple_BlockHashChannelManagerZ_get_b(owner: bigint): bigint {
4282 if(!isWasmInitialized) {
4283 throw new Error("initializeWasm() must be awaited first!");
4285 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_b(owner);
4286 return nativeResponseValue;
4288 // struct LDKC2Tuple_BlockHashChannelManagerZ *CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
4290 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner: bigint): bigint {
4291 if(!isWasmInitialized) {
4292 throw new Error("initializeWasm() must be awaited first!");
4294 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner);
4295 return nativeResponseValue;
4297 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
4299 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner: bigint): bigint {
4300 if(!isWasmInitialized) {
4301 throw new Error("initializeWasm() must be awaited first!");
4303 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner);
4304 return nativeResponseValue;
4306 // struct LDKChannelConfig CResult_ChannelConfigDecodeErrorZ_get_ok(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
4308 export function CResult_ChannelConfigDecodeErrorZ_get_ok(owner: bigint): bigint {
4309 if(!isWasmInitialized) {
4310 throw new Error("initializeWasm() must be awaited first!");
4312 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_ok(owner);
4313 return nativeResponseValue;
4315 // struct LDKDecodeError CResult_ChannelConfigDecodeErrorZ_get_err(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
4317 export function CResult_ChannelConfigDecodeErrorZ_get_err(owner: bigint): bigint {
4318 if(!isWasmInitialized) {
4319 throw new Error("initializeWasm() must be awaited first!");
4321 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_err(owner);
4322 return nativeResponseValue;
4324 // struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
4326 export function CResult_OutPointDecodeErrorZ_get_ok(owner: bigint): bigint {
4327 if(!isWasmInitialized) {
4328 throw new Error("initializeWasm() must be awaited first!");
4330 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_ok(owner);
4331 return nativeResponseValue;
4333 // struct LDKDecodeError CResult_OutPointDecodeErrorZ_get_err(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
4335 export function CResult_OutPointDecodeErrorZ_get_err(owner: bigint): bigint {
4336 if(!isWasmInitialized) {
4337 throw new Error("initializeWasm() must be awaited first!");
4339 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_err(owner);
4340 return nativeResponseValue;
4343 export interface LDKType {
4345 debug_str (): number;
4350 export function LDKType_new(impl: LDKType): [bigint, number] {
4351 if(!isWasmInitialized) {
4352 throw new Error("initializeWasm() must be awaited first!");
4354 var new_obj_idx = js_objs.length;
4355 for (var i = 0; i < js_objs.length; i++) {
4356 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4358 js_objs[i] = new WeakRef(impl);
4359 return [wasm.TS_LDKType_new(i), i];
4361 // uint16_t Type_type_id LDKType *NONNULL_PTR this_arg
4363 export function Type_type_id(this_arg: bigint): number {
4364 if(!isWasmInitialized) {
4365 throw new Error("initializeWasm() must be awaited first!");
4367 const nativeResponseValue = wasm.TS_Type_type_id(this_arg);
4368 return nativeResponseValue;
4370 // LDKStr Type_debug_str LDKType *NONNULL_PTR this_arg
4372 export function Type_debug_str(this_arg: bigint): number {
4373 if(!isWasmInitialized) {
4374 throw new Error("initializeWasm() must be awaited first!");
4376 const nativeResponseValue = wasm.TS_Type_debug_str(this_arg);
4377 return nativeResponseValue;
4379 // LDKCVec_u8Z Type_write LDKType *NONNULL_PTR this_arg
4381 export function Type_write(this_arg: bigint): number {
4382 if(!isWasmInitialized) {
4383 throw new Error("initializeWasm() must be awaited first!");
4385 const nativeResponseValue = wasm.TS_Type_write(this_arg);
4386 return nativeResponseValue;
4389 export class LDKCOption_TypeZ {
4390 protected constructor() {}
4393 export function LDKCOption_TypeZ_ty_from_ptr(ptr: bigint): number {
4394 if(!isWasmInitialized) {
4395 throw new Error("initializeWasm() must be awaited first!");
4397 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_ty_from_ptr(ptr);
4398 return nativeResponseValue;
4401 export function LDKCOption_TypeZ_Some_get_some(ptr: bigint): bigint {
4402 if(!isWasmInitialized) {
4403 throw new Error("initializeWasm() must be awaited first!");
4405 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_Some_get_some(ptr);
4406 return nativeResponseValue;
4408 // struct LDKCOption_TypeZ CResult_COption_TypeZDecodeErrorZ_get_ok(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
4410 export function CResult_COption_TypeZDecodeErrorZ_get_ok(owner: bigint): bigint {
4411 if(!isWasmInitialized) {
4412 throw new Error("initializeWasm() must be awaited first!");
4414 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_ok(owner);
4415 return nativeResponseValue;
4417 // struct LDKDecodeError CResult_COption_TypeZDecodeErrorZ_get_err(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
4419 export function CResult_COption_TypeZDecodeErrorZ_get_err(owner: bigint): bigint {
4420 if(!isWasmInitialized) {
4421 throw new Error("initializeWasm() must be awaited first!");
4423 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_err(owner);
4424 return nativeResponseValue;
4427 export class LDKPaymentError {
4428 protected constructor() {}
4431 export function LDKPaymentError_ty_from_ptr(ptr: bigint): number {
4432 if(!isWasmInitialized) {
4433 throw new Error("initializeWasm() must be awaited first!");
4435 const nativeResponseValue = wasm.TS_LDKPaymentError_ty_from_ptr(ptr);
4436 return nativeResponseValue;
4439 export function LDKPaymentError_Invoice_get_invoice(ptr: bigint): number {
4440 if(!isWasmInitialized) {
4441 throw new Error("initializeWasm() must be awaited first!");
4443 const nativeResponseValue = wasm.TS_LDKPaymentError_Invoice_get_invoice(ptr);
4444 return nativeResponseValue;
4447 export function LDKPaymentError_Routing_get_routing(ptr: bigint): bigint {
4448 if(!isWasmInitialized) {
4449 throw new Error("initializeWasm() must be awaited first!");
4451 const nativeResponseValue = wasm.TS_LDKPaymentError_Routing_get_routing(ptr);
4452 return nativeResponseValue;
4455 export function LDKPaymentError_Sending_get_sending(ptr: bigint): bigint {
4456 if(!isWasmInitialized) {
4457 throw new Error("initializeWasm() must be awaited first!");
4459 const nativeResponseValue = wasm.TS_LDKPaymentError_Sending_get_sending(ptr);
4460 return nativeResponseValue;
4462 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentErrorZ_get_ok(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
4464 export function CResult_PaymentIdPaymentErrorZ_get_ok(owner: bigint): number {
4465 if(!isWasmInitialized) {
4466 throw new Error("initializeWasm() must be awaited first!");
4468 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_ok(owner);
4469 return nativeResponseValue;
4471 // struct LDKPaymentError CResult_PaymentIdPaymentErrorZ_get_err(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
4473 export function CResult_PaymentIdPaymentErrorZ_get_err(owner: bigint): bigint {
4474 if(!isWasmInitialized) {
4475 throw new Error("initializeWasm() must be awaited first!");
4477 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_err(owner);
4478 return nativeResponseValue;
4480 // struct LDKInFlightHtlcs CResult_InFlightHtlcsDecodeErrorZ_get_ok(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner);
4482 export function CResult_InFlightHtlcsDecodeErrorZ_get_ok(owner: bigint): bigint {
4483 if(!isWasmInitialized) {
4484 throw new Error("initializeWasm() must be awaited first!");
4486 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_get_ok(owner);
4487 return nativeResponseValue;
4489 // struct LDKDecodeError CResult_InFlightHtlcsDecodeErrorZ_get_err(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner);
4491 export function CResult_InFlightHtlcsDecodeErrorZ_get_err(owner: bigint): bigint {
4492 if(!isWasmInitialized) {
4493 throw new Error("initializeWasm() must be awaited first!");
4495 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_get_err(owner);
4496 return nativeResponseValue;
4499 export class LDKParseError {
4500 protected constructor() {}
4503 export function LDKParseError_ty_from_ptr(ptr: bigint): number {
4504 if(!isWasmInitialized) {
4505 throw new Error("initializeWasm() must be awaited first!");
4507 const nativeResponseValue = wasm.TS_LDKParseError_ty_from_ptr(ptr);
4508 return nativeResponseValue;
4511 export function LDKParseError_Bech32Error_get_bech32_error(ptr: bigint): bigint {
4512 if(!isWasmInitialized) {
4513 throw new Error("initializeWasm() must be awaited first!");
4515 const nativeResponseValue = wasm.TS_LDKParseError_Bech32Error_get_bech32_error(ptr);
4516 return nativeResponseValue;
4519 export function LDKParseError_ParseAmountError_get_parse_amount_error(ptr: bigint): number {
4520 if(!isWasmInitialized) {
4521 throw new Error("initializeWasm() must be awaited first!");
4523 const nativeResponseValue = wasm.TS_LDKParseError_ParseAmountError_get_parse_amount_error(ptr);
4524 return nativeResponseValue;
4527 export function LDKParseError_MalformedSignature_get_malformed_signature(ptr: bigint): Secp256k1Error {
4528 if(!isWasmInitialized) {
4529 throw new Error("initializeWasm() must be awaited first!");
4531 const nativeResponseValue = wasm.TS_LDKParseError_MalformedSignature_get_malformed_signature(ptr);
4532 return nativeResponseValue;
4535 export function LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr: bigint): number {
4536 if(!isWasmInitialized) {
4537 throw new Error("initializeWasm() must be awaited first!");
4539 const nativeResponseValue = wasm.TS_LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr);
4540 return nativeResponseValue;
4543 export function LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr: bigint): number {
4544 if(!isWasmInitialized) {
4545 throw new Error("initializeWasm() must be awaited first!");
4547 const nativeResponseValue = wasm.TS_LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr);
4548 return nativeResponseValue;
4550 // enum LDKSiPrefix CResult_SiPrefixParseErrorZ_get_ok(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
4552 export function CResult_SiPrefixParseErrorZ_get_ok(owner: bigint): SiPrefix {
4553 if(!isWasmInitialized) {
4554 throw new Error("initializeWasm() must be awaited first!");
4556 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_ok(owner);
4557 return nativeResponseValue;
4559 // struct LDKParseError CResult_SiPrefixParseErrorZ_get_err(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
4561 export function CResult_SiPrefixParseErrorZ_get_err(owner: bigint): bigint {
4562 if(!isWasmInitialized) {
4563 throw new Error("initializeWasm() must be awaited first!");
4565 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_err(owner);
4566 return nativeResponseValue;
4569 export class LDKParseOrSemanticError {
4570 protected constructor() {}
4573 export function LDKParseOrSemanticError_ty_from_ptr(ptr: bigint): number {
4574 if(!isWasmInitialized) {
4575 throw new Error("initializeWasm() must be awaited first!");
4577 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ty_from_ptr(ptr);
4578 return nativeResponseValue;
4581 export function LDKParseOrSemanticError_ParseError_get_parse_error(ptr: bigint): bigint {
4582 if(!isWasmInitialized) {
4583 throw new Error("initializeWasm() must be awaited first!");
4585 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ParseError_get_parse_error(ptr);
4586 return nativeResponseValue;
4589 export function LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr: bigint): SemanticError {
4590 if(!isWasmInitialized) {
4591 throw new Error("initializeWasm() must be awaited first!");
4593 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr);
4594 return nativeResponseValue;
4596 // struct LDKInvoice CResult_InvoiceParseOrSemanticErrorZ_get_ok(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
4598 export function CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner: bigint): bigint {
4599 if(!isWasmInitialized) {
4600 throw new Error("initializeWasm() must be awaited first!");
4602 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner);
4603 return nativeResponseValue;
4605 // struct LDKParseOrSemanticError CResult_InvoiceParseOrSemanticErrorZ_get_err(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
4607 export function CResult_InvoiceParseOrSemanticErrorZ_get_err(owner: bigint): bigint {
4608 if(!isWasmInitialized) {
4609 throw new Error("initializeWasm() must be awaited first!");
4611 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_err(owner);
4612 return nativeResponseValue;
4614 // struct LDKSignedRawInvoice CResult_SignedRawInvoiceParseErrorZ_get_ok(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
4616 export function CResult_SignedRawInvoiceParseErrorZ_get_ok(owner: bigint): bigint {
4617 if(!isWasmInitialized) {
4618 throw new Error("initializeWasm() must be awaited first!");
4620 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_ok(owner);
4621 return nativeResponseValue;
4623 // struct LDKParseError CResult_SignedRawInvoiceParseErrorZ_get_err(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
4625 export function CResult_SignedRawInvoiceParseErrorZ_get_err(owner: bigint): bigint {
4626 if(!isWasmInitialized) {
4627 throw new Error("initializeWasm() must be awaited first!");
4629 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_err(owner);
4630 return nativeResponseValue;
4632 // struct LDKRawInvoice C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
4634 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner: bigint): bigint {
4635 if(!isWasmInitialized) {
4636 throw new Error("initializeWasm() must be awaited first!");
4638 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner);
4639 return nativeResponseValue;
4641 // struct LDKThirtyTwoBytes C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
4643 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner: bigint): number {
4644 if(!isWasmInitialized) {
4645 throw new Error("initializeWasm() must be awaited first!");
4647 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner);
4648 return nativeResponseValue;
4650 // struct LDKInvoiceSignature C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
4652 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner: bigint): bigint {
4653 if(!isWasmInitialized) {
4654 throw new Error("initializeWasm() must be awaited first!");
4656 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner);
4657 return nativeResponseValue;
4659 // struct LDKPayeePubKey CResult_PayeePubKeyErrorZ_get_ok(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
4661 export function CResult_PayeePubKeyErrorZ_get_ok(owner: bigint): bigint {
4662 if(!isWasmInitialized) {
4663 throw new Error("initializeWasm() must be awaited first!");
4665 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_ok(owner);
4666 return nativeResponseValue;
4668 // enum LDKSecp256k1Error CResult_PayeePubKeyErrorZ_get_err(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
4670 export function CResult_PayeePubKeyErrorZ_get_err(owner: bigint): Secp256k1Error {
4671 if(!isWasmInitialized) {
4672 throw new Error("initializeWasm() must be awaited first!");
4674 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_err(owner);
4675 return nativeResponseValue;
4677 // struct LDKPositiveTimestamp CResult_PositiveTimestampCreationErrorZ_get_ok(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
4679 export function CResult_PositiveTimestampCreationErrorZ_get_ok(owner: bigint): bigint {
4680 if(!isWasmInitialized) {
4681 throw new Error("initializeWasm() must be awaited first!");
4683 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_ok(owner);
4684 return nativeResponseValue;
4686 // enum LDKCreationError CResult_PositiveTimestampCreationErrorZ_get_err(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
4688 export function CResult_PositiveTimestampCreationErrorZ_get_err(owner: bigint): CreationError {
4689 if(!isWasmInitialized) {
4690 throw new Error("initializeWasm() must be awaited first!");
4692 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_err(owner);
4693 return nativeResponseValue;
4695 // void CResult_NoneSemanticErrorZ_get_ok(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
4697 export function CResult_NoneSemanticErrorZ_get_ok(owner: bigint): void {
4698 if(!isWasmInitialized) {
4699 throw new Error("initializeWasm() must be awaited first!");
4701 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_ok(owner);
4702 // debug statements here
4704 // enum LDKSemanticError CResult_NoneSemanticErrorZ_get_err(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
4706 export function CResult_NoneSemanticErrorZ_get_err(owner: bigint): SemanticError {
4707 if(!isWasmInitialized) {
4708 throw new Error("initializeWasm() must be awaited first!");
4710 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_err(owner);
4711 return nativeResponseValue;
4713 // struct LDKInvoice CResult_InvoiceSemanticErrorZ_get_ok(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
4715 export function CResult_InvoiceSemanticErrorZ_get_ok(owner: bigint): bigint {
4716 if(!isWasmInitialized) {
4717 throw new Error("initializeWasm() must be awaited first!");
4719 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_ok(owner);
4720 return nativeResponseValue;
4722 // enum LDKSemanticError CResult_InvoiceSemanticErrorZ_get_err(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
4724 export function CResult_InvoiceSemanticErrorZ_get_err(owner: bigint): SemanticError {
4725 if(!isWasmInitialized) {
4726 throw new Error("initializeWasm() must be awaited first!");
4728 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_err(owner);
4729 return nativeResponseValue;
4731 // struct LDKDescription CResult_DescriptionCreationErrorZ_get_ok(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
4733 export function CResult_DescriptionCreationErrorZ_get_ok(owner: bigint): bigint {
4734 if(!isWasmInitialized) {
4735 throw new Error("initializeWasm() must be awaited first!");
4737 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_ok(owner);
4738 return nativeResponseValue;
4740 // enum LDKCreationError CResult_DescriptionCreationErrorZ_get_err(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
4742 export function CResult_DescriptionCreationErrorZ_get_err(owner: bigint): CreationError {
4743 if(!isWasmInitialized) {
4744 throw new Error("initializeWasm() must be awaited first!");
4746 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_err(owner);
4747 return nativeResponseValue;
4749 // struct LDKPrivateRoute CResult_PrivateRouteCreationErrorZ_get_ok(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
4751 export function CResult_PrivateRouteCreationErrorZ_get_ok(owner: bigint): bigint {
4752 if(!isWasmInitialized) {
4753 throw new Error("initializeWasm() must be awaited first!");
4755 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_ok(owner);
4756 return nativeResponseValue;
4758 // enum LDKCreationError CResult_PrivateRouteCreationErrorZ_get_err(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
4760 export function CResult_PrivateRouteCreationErrorZ_get_err(owner: bigint): CreationError {
4761 if(!isWasmInitialized) {
4762 throw new Error("initializeWasm() must be awaited first!");
4764 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_err(owner);
4765 return nativeResponseValue;
4767 // struct LDKStr CResult_StringErrorZ_get_ok(LDKCResult_StringErrorZ *NONNULL_PTR owner);
4769 export function CResult_StringErrorZ_get_ok(owner: bigint): number {
4770 if(!isWasmInitialized) {
4771 throw new Error("initializeWasm() must be awaited first!");
4773 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_ok(owner);
4774 return nativeResponseValue;
4776 // enum LDKSecp256k1Error CResult_StringErrorZ_get_err(LDKCResult_StringErrorZ *NONNULL_PTR owner);
4778 export function CResult_StringErrorZ_get_err(owner: bigint): Secp256k1Error {
4779 if(!isWasmInitialized) {
4780 throw new Error("initializeWasm() must be awaited first!");
4782 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_err(owner);
4783 return nativeResponseValue;
4785 // struct LDKChannelMonitorUpdate CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
4787 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
4788 if(!isWasmInitialized) {
4789 throw new Error("initializeWasm() must be awaited first!");
4791 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner);
4792 return nativeResponseValue;
4794 // struct LDKDecodeError CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
4796 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
4797 if(!isWasmInitialized) {
4798 throw new Error("initializeWasm() must be awaited first!");
4800 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner);
4801 return nativeResponseValue;
4804 export class LDKCOption_MonitorEventZ {
4805 protected constructor() {}
4808 export function LDKCOption_MonitorEventZ_ty_from_ptr(ptr: bigint): number {
4809 if(!isWasmInitialized) {
4810 throw new Error("initializeWasm() must be awaited first!");
4812 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_ty_from_ptr(ptr);
4813 return nativeResponseValue;
4816 export function LDKCOption_MonitorEventZ_Some_get_some(ptr: bigint): bigint {
4817 if(!isWasmInitialized) {
4818 throw new Error("initializeWasm() must be awaited first!");
4820 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_Some_get_some(ptr);
4821 return nativeResponseValue;
4823 // struct LDKCOption_MonitorEventZ CResult_COption_MonitorEventZDecodeErrorZ_get_ok(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
4825 export function CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner: bigint): bigint {
4826 if(!isWasmInitialized) {
4827 throw new Error("initializeWasm() must be awaited first!");
4829 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner);
4830 return nativeResponseValue;
4832 // struct LDKDecodeError CResult_COption_MonitorEventZDecodeErrorZ_get_err(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
4834 export function CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner: bigint): bigint {
4835 if(!isWasmInitialized) {
4836 throw new Error("initializeWasm() must be awaited first!");
4838 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner);
4839 return nativeResponseValue;
4841 // struct LDKHTLCUpdate CResult_HTLCUpdateDecodeErrorZ_get_ok(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
4843 export function CResult_HTLCUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
4844 if(!isWasmInitialized) {
4845 throw new Error("initializeWasm() must be awaited first!");
4847 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_ok(owner);
4848 return nativeResponseValue;
4850 // struct LDKDecodeError CResult_HTLCUpdateDecodeErrorZ_get_err(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
4852 export function CResult_HTLCUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
4853 if(!isWasmInitialized) {
4854 throw new Error("initializeWasm() must be awaited first!");
4856 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_err(owner);
4857 return nativeResponseValue;
4859 // struct LDKOutPoint C2Tuple_OutPointScriptZ_get_a(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
4861 export function C2Tuple_OutPointScriptZ_get_a(owner: bigint): bigint {
4862 if(!isWasmInitialized) {
4863 throw new Error("initializeWasm() must be awaited first!");
4865 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_a(owner);
4866 return nativeResponseValue;
4868 // struct LDKCVec_u8Z C2Tuple_OutPointScriptZ_get_b(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
4870 export function C2Tuple_OutPointScriptZ_get_b(owner: bigint): number {
4871 if(!isWasmInitialized) {
4872 throw new Error("initializeWasm() must be awaited first!");
4874 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_b(owner);
4875 return nativeResponseValue;
4877 // uint32_t C2Tuple_u32ScriptZ_get_a(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
4879 export function C2Tuple_u32ScriptZ_get_a(owner: bigint): number {
4880 if(!isWasmInitialized) {
4881 throw new Error("initializeWasm() must be awaited first!");
4883 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_a(owner);
4884 return nativeResponseValue;
4886 // struct LDKCVec_u8Z C2Tuple_u32ScriptZ_get_b(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
4888 export function C2Tuple_u32ScriptZ_get_b(owner: bigint): number {
4889 if(!isWasmInitialized) {
4890 throw new Error("initializeWasm() must be awaited first!");
4892 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_b(owner);
4893 return nativeResponseValue;
4895 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
4897 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner: bigint): number {
4898 if(!isWasmInitialized) {
4899 throw new Error("initializeWasm() must be awaited first!");
4901 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner);
4902 return nativeResponseValue;
4904 // struct LDKCVec_C2Tuple_u32ScriptZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
4906 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner: bigint): number {
4907 if(!isWasmInitialized) {
4908 throw new Error("initializeWasm() must be awaited first!");
4910 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner);
4911 return nativeResponseValue;
4913 // uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
4915 export function C2Tuple_u32TxOutZ_get_a(owner: bigint): number {
4916 if(!isWasmInitialized) {
4917 throw new Error("initializeWasm() must be awaited first!");
4919 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_a(owner);
4920 return nativeResponseValue;
4922 // struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
4924 export function C2Tuple_u32TxOutZ_get_b(owner: bigint): bigint {
4925 if(!isWasmInitialized) {
4926 throw new Error("initializeWasm() must be awaited first!");
4928 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_b(owner);
4929 return nativeResponseValue;
4931 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
4933 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner: bigint): number {
4934 if(!isWasmInitialized) {
4935 throw new Error("initializeWasm() must be awaited first!");
4937 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner);
4938 return nativeResponseValue;
4940 // struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
4942 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner: bigint): number {
4943 if(!isWasmInitialized) {
4944 throw new Error("initializeWasm() must be awaited first!");
4946 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner);
4947 return nativeResponseValue;
4950 export class LDKBalance {
4951 protected constructor() {}
4954 export function LDKBalance_ty_from_ptr(ptr: bigint): number {
4955 if(!isWasmInitialized) {
4956 throw new Error("initializeWasm() must be awaited first!");
4958 const nativeResponseValue = wasm.TS_LDKBalance_ty_from_ptr(ptr);
4959 return nativeResponseValue;
4962 export function LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr: bigint): bigint {
4963 if(!isWasmInitialized) {
4964 throw new Error("initializeWasm() must be awaited first!");
4966 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr);
4967 return nativeResponseValue;
4970 export function LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr: bigint): bigint {
4971 if(!isWasmInitialized) {
4972 throw new Error("initializeWasm() must be awaited first!");
4974 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr);
4975 return nativeResponseValue;
4978 export function LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr: bigint): number {
4979 if(!isWasmInitialized) {
4980 throw new Error("initializeWasm() must be awaited first!");
4982 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr);
4983 return nativeResponseValue;
4986 export function LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr: bigint): bigint {
4987 if(!isWasmInitialized) {
4988 throw new Error("initializeWasm() must be awaited first!");
4990 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr);
4991 return nativeResponseValue;
4994 export function LDKBalance_ContentiousClaimable_get_timeout_height(ptr: bigint): number {
4995 if(!isWasmInitialized) {
4996 throw new Error("initializeWasm() must be awaited first!");
4998 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_timeout_height(ptr);
4999 return nativeResponseValue;
5002 export function LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_amount_satoshis(ptr: bigint): bigint {
5003 if(!isWasmInitialized) {
5004 throw new Error("initializeWasm() must be awaited first!");
5006 const nativeResponseValue = wasm.TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_amount_satoshis(ptr);
5007 return nativeResponseValue;
5010 export function LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_height(ptr: bigint): number {
5011 if(!isWasmInitialized) {
5012 throw new Error("initializeWasm() must be awaited first!");
5014 const nativeResponseValue = wasm.TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_height(ptr);
5015 return nativeResponseValue;
5018 export function LDKBalance_MaybePreimageClaimableHTLC_get_claimable_amount_satoshis(ptr: bigint): bigint {
5019 if(!isWasmInitialized) {
5020 throw new Error("initializeWasm() must be awaited first!");
5022 const nativeResponseValue = wasm.TS_LDKBalance_MaybePreimageClaimableHTLC_get_claimable_amount_satoshis(ptr);
5023 return nativeResponseValue;
5026 export function LDKBalance_MaybePreimageClaimableHTLC_get_expiry_height(ptr: bigint): number {
5027 if(!isWasmInitialized) {
5028 throw new Error("initializeWasm() must be awaited first!");
5030 const nativeResponseValue = wasm.TS_LDKBalance_MaybePreimageClaimableHTLC_get_expiry_height(ptr);
5031 return nativeResponseValue;
5034 export function LDKBalance_CounterpartyRevokedOutputClaimable_get_claimable_amount_satoshis(ptr: bigint): bigint {
5035 if(!isWasmInitialized) {
5036 throw new Error("initializeWasm() must be awaited first!");
5038 const nativeResponseValue = wasm.TS_LDKBalance_CounterpartyRevokedOutputClaimable_get_claimable_amount_satoshis(ptr);
5039 return nativeResponseValue;
5041 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelMonitorZ_get_a(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
5043 export function C2Tuple_BlockHashChannelMonitorZ_get_a(owner: bigint): number {
5044 if(!isWasmInitialized) {
5045 throw new Error("initializeWasm() must be awaited first!");
5047 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_a(owner);
5048 return nativeResponseValue;
5050 // struct LDKChannelMonitor C2Tuple_BlockHashChannelMonitorZ_get_b(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
5052 export function C2Tuple_BlockHashChannelMonitorZ_get_b(owner: bigint): bigint {
5053 if(!isWasmInitialized) {
5054 throw new Error("initializeWasm() must be awaited first!");
5056 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_b(owner);
5057 return nativeResponseValue;
5059 // struct LDKC2Tuple_BlockHashChannelMonitorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
5061 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner: bigint): bigint {
5062 if(!isWasmInitialized) {
5063 throw new Error("initializeWasm() must be awaited first!");
5065 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner);
5066 return nativeResponseValue;
5068 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
5070 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner: bigint): bigint {
5071 if(!isWasmInitialized) {
5072 throw new Error("initializeWasm() must be awaited first!");
5074 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner);
5075 return nativeResponseValue;
5077 // struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
5079 export function C2Tuple_PublicKeyTypeZ_get_a(owner: bigint): number {
5080 if(!isWasmInitialized) {
5081 throw new Error("initializeWasm() must be awaited first!");
5083 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_a(owner);
5084 return nativeResponseValue;
5086 // struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
5088 export function C2Tuple_PublicKeyTypeZ_get_b(owner: bigint): bigint {
5089 if(!isWasmInitialized) {
5090 throw new Error("initializeWasm() must be awaited first!");
5092 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_b(owner);
5093 return nativeResponseValue;
5096 export class LDKCOption_NetAddressZ {
5097 protected constructor() {}
5100 export function LDKCOption_NetAddressZ_ty_from_ptr(ptr: bigint): number {
5101 if(!isWasmInitialized) {
5102 throw new Error("initializeWasm() must be awaited first!");
5104 const nativeResponseValue = wasm.TS_LDKCOption_NetAddressZ_ty_from_ptr(ptr);
5105 return nativeResponseValue;
5108 export function LDKCOption_NetAddressZ_Some_get_some(ptr: bigint): bigint {
5109 if(!isWasmInitialized) {
5110 throw new Error("initializeWasm() must be awaited first!");
5112 const nativeResponseValue = wasm.TS_LDKCOption_NetAddressZ_Some_get_some(ptr);
5113 return nativeResponseValue;
5115 // struct LDKCVec_u8Z CResult_CVec_u8ZPeerHandleErrorZ_get_ok(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
5117 export function CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner: bigint): number {
5118 if(!isWasmInitialized) {
5119 throw new Error("initializeWasm() must be awaited first!");
5121 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner);
5122 return nativeResponseValue;
5124 // struct LDKPeerHandleError CResult_CVec_u8ZPeerHandleErrorZ_get_err(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
5126 export function CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner: bigint): bigint {
5127 if(!isWasmInitialized) {
5128 throw new Error("initializeWasm() must be awaited first!");
5130 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner);
5131 return nativeResponseValue;
5133 // void CResult_NonePeerHandleErrorZ_get_ok(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
5135 export function CResult_NonePeerHandleErrorZ_get_ok(owner: bigint): void {
5136 if(!isWasmInitialized) {
5137 throw new Error("initializeWasm() must be awaited first!");
5139 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_ok(owner);
5140 // debug statements here
5142 // struct LDKPeerHandleError CResult_NonePeerHandleErrorZ_get_err(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
5144 export function CResult_NonePeerHandleErrorZ_get_err(owner: bigint): bigint {
5145 if(!isWasmInitialized) {
5146 throw new Error("initializeWasm() must be awaited first!");
5148 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_err(owner);
5149 return nativeResponseValue;
5151 // bool CResult_boolPeerHandleErrorZ_get_ok(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
5153 export function CResult_boolPeerHandleErrorZ_get_ok(owner: bigint): boolean {
5154 if(!isWasmInitialized) {
5155 throw new Error("initializeWasm() must be awaited first!");
5157 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_ok(owner);
5158 return nativeResponseValue;
5160 // struct LDKPeerHandleError CResult_boolPeerHandleErrorZ_get_err(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
5162 export function CResult_boolPeerHandleErrorZ_get_err(owner: bigint): bigint {
5163 if(!isWasmInitialized) {
5164 throw new Error("initializeWasm() must be awaited first!");
5166 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_err(owner);
5167 return nativeResponseValue;
5170 export class LDKSendError {
5171 protected constructor() {}
5174 export function LDKSendError_ty_from_ptr(ptr: bigint): number {
5175 if(!isWasmInitialized) {
5176 throw new Error("initializeWasm() must be awaited first!");
5178 const nativeResponseValue = wasm.TS_LDKSendError_ty_from_ptr(ptr);
5179 return nativeResponseValue;
5182 export function LDKSendError_Secp256k1_get_secp256k1(ptr: bigint): Secp256k1Error {
5183 if(!isWasmInitialized) {
5184 throw new Error("initializeWasm() must be awaited first!");
5186 const nativeResponseValue = wasm.TS_LDKSendError_Secp256k1_get_secp256k1(ptr);
5187 return nativeResponseValue;
5189 // void CResult_NoneSendErrorZ_get_ok(LDKCResult_NoneSendErrorZ *NONNULL_PTR owner);
5191 export function CResult_NoneSendErrorZ_get_ok(owner: bigint): void {
5192 if(!isWasmInitialized) {
5193 throw new Error("initializeWasm() must be awaited first!");
5195 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_get_ok(owner);
5196 // debug statements here
5198 // struct LDKSendError CResult_NoneSendErrorZ_get_err(LDKCResult_NoneSendErrorZ *NONNULL_PTR owner);
5200 export function CResult_NoneSendErrorZ_get_err(owner: bigint): bigint {
5201 if(!isWasmInitialized) {
5202 throw new Error("initializeWasm() must be awaited first!");
5204 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_get_err(owner);
5205 return nativeResponseValue;
5208 export class LDKGraphSyncError {
5209 protected constructor() {}
5212 export function LDKGraphSyncError_ty_from_ptr(ptr: bigint): number {
5213 if(!isWasmInitialized) {
5214 throw new Error("initializeWasm() must be awaited first!");
5216 const nativeResponseValue = wasm.TS_LDKGraphSyncError_ty_from_ptr(ptr);
5217 return nativeResponseValue;
5220 export function LDKGraphSyncError_DecodeError_get_decode_error(ptr: bigint): bigint {
5221 if(!isWasmInitialized) {
5222 throw new Error("initializeWasm() must be awaited first!");
5224 const nativeResponseValue = wasm.TS_LDKGraphSyncError_DecodeError_get_decode_error(ptr);
5225 return nativeResponseValue;
5228 export function LDKGraphSyncError_LightningError_get_lightning_error(ptr: bigint): bigint {
5229 if(!isWasmInitialized) {
5230 throw new Error("initializeWasm() must be awaited first!");
5232 const nativeResponseValue = wasm.TS_LDKGraphSyncError_LightningError_get_lightning_error(ptr);
5233 return nativeResponseValue;
5235 // uint32_t CResult_u32GraphSyncErrorZ_get_ok(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner);
5237 export function CResult_u32GraphSyncErrorZ_get_ok(owner: bigint): number {
5238 if(!isWasmInitialized) {
5239 throw new Error("initializeWasm() must be awaited first!");
5241 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_get_ok(owner);
5242 return nativeResponseValue;
5244 // struct LDKGraphSyncError CResult_u32GraphSyncErrorZ_get_err(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner);
5246 export function CResult_u32GraphSyncErrorZ_get_err(owner: bigint): bigint {
5247 if(!isWasmInitialized) {
5248 throw new Error("initializeWasm() must be awaited first!");
5250 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_get_err(owner);
5251 return nativeResponseValue;
5253 // void CResult_NoneErrorZ_get_ok(LDKCResult_NoneErrorZ *NONNULL_PTR owner);
5255 export function CResult_NoneErrorZ_get_ok(owner: bigint): void {
5256 if(!isWasmInitialized) {
5257 throw new Error("initializeWasm() must be awaited first!");
5259 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_get_ok(owner);
5260 // debug statements here
5262 // enum LDKIOError CResult_NoneErrorZ_get_err(LDKCResult_NoneErrorZ *NONNULL_PTR owner);
5264 export function CResult_NoneErrorZ_get_err(owner: bigint): IOError {
5265 if(!isWasmInitialized) {
5266 throw new Error("initializeWasm() must be awaited first!");
5268 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_get_err(owner);
5269 return nativeResponseValue;
5271 // struct LDKNetAddress CResult_NetAddressDecodeErrorZ_get_ok(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
5273 export function CResult_NetAddressDecodeErrorZ_get_ok(owner: bigint): bigint {
5274 if(!isWasmInitialized) {
5275 throw new Error("initializeWasm() must be awaited first!");
5277 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_ok(owner);
5278 return nativeResponseValue;
5280 // struct LDKDecodeError CResult_NetAddressDecodeErrorZ_get_err(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
5282 export function CResult_NetAddressDecodeErrorZ_get_err(owner: bigint): bigint {
5283 if(!isWasmInitialized) {
5284 throw new Error("initializeWasm() must be awaited first!");
5286 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_err(owner);
5287 return nativeResponseValue;
5289 // struct LDKAcceptChannel CResult_AcceptChannelDecodeErrorZ_get_ok(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
5291 export function CResult_AcceptChannelDecodeErrorZ_get_ok(owner: bigint): bigint {
5292 if(!isWasmInitialized) {
5293 throw new Error("initializeWasm() must be awaited first!");
5295 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_ok(owner);
5296 return nativeResponseValue;
5298 // struct LDKDecodeError CResult_AcceptChannelDecodeErrorZ_get_err(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
5300 export function CResult_AcceptChannelDecodeErrorZ_get_err(owner: bigint): bigint {
5301 if(!isWasmInitialized) {
5302 throw new Error("initializeWasm() must be awaited first!");
5304 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_err(owner);
5305 return nativeResponseValue;
5307 // struct LDKAnnouncementSignatures CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
5309 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
5310 if(!isWasmInitialized) {
5311 throw new Error("initializeWasm() must be awaited first!");
5313 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner);
5314 return nativeResponseValue;
5316 // struct LDKDecodeError CResult_AnnouncementSignaturesDecodeErrorZ_get_err(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
5318 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner: bigint): bigint {
5319 if(!isWasmInitialized) {
5320 throw new Error("initializeWasm() must be awaited first!");
5322 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner);
5323 return nativeResponseValue;
5325 // struct LDKChannelReestablish CResult_ChannelReestablishDecodeErrorZ_get_ok(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
5327 export function CResult_ChannelReestablishDecodeErrorZ_get_ok(owner: bigint): bigint {
5328 if(!isWasmInitialized) {
5329 throw new Error("initializeWasm() must be awaited first!");
5331 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_ok(owner);
5332 return nativeResponseValue;
5334 // struct LDKDecodeError CResult_ChannelReestablishDecodeErrorZ_get_err(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
5336 export function CResult_ChannelReestablishDecodeErrorZ_get_err(owner: bigint): bigint {
5337 if(!isWasmInitialized) {
5338 throw new Error("initializeWasm() must be awaited first!");
5340 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_err(owner);
5341 return nativeResponseValue;
5343 // struct LDKClosingSigned CResult_ClosingSignedDecodeErrorZ_get_ok(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
5345 export function CResult_ClosingSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
5346 if(!isWasmInitialized) {
5347 throw new Error("initializeWasm() must be awaited first!");
5349 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_ok(owner);
5350 return nativeResponseValue;
5352 // struct LDKDecodeError CResult_ClosingSignedDecodeErrorZ_get_err(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
5354 export function CResult_ClosingSignedDecodeErrorZ_get_err(owner: bigint): bigint {
5355 if(!isWasmInitialized) {
5356 throw new Error("initializeWasm() must be awaited first!");
5358 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_err(owner);
5359 return nativeResponseValue;
5361 // struct LDKClosingSignedFeeRange CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
5363 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
5364 if(!isWasmInitialized) {
5365 throw new Error("initializeWasm() must be awaited first!");
5367 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner);
5368 return nativeResponseValue;
5370 // struct LDKDecodeError CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
5372 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner: bigint): bigint {
5373 if(!isWasmInitialized) {
5374 throw new Error("initializeWasm() must be awaited first!");
5376 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner);
5377 return nativeResponseValue;
5379 // struct LDKCommitmentSigned CResult_CommitmentSignedDecodeErrorZ_get_ok(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
5381 export function CResult_CommitmentSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
5382 if(!isWasmInitialized) {
5383 throw new Error("initializeWasm() must be awaited first!");
5385 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_ok(owner);
5386 return nativeResponseValue;
5388 // struct LDKDecodeError CResult_CommitmentSignedDecodeErrorZ_get_err(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
5390 export function CResult_CommitmentSignedDecodeErrorZ_get_err(owner: bigint): bigint {
5391 if(!isWasmInitialized) {
5392 throw new Error("initializeWasm() must be awaited first!");
5394 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_err(owner);
5395 return nativeResponseValue;
5397 // struct LDKFundingCreated CResult_FundingCreatedDecodeErrorZ_get_ok(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
5399 export function CResult_FundingCreatedDecodeErrorZ_get_ok(owner: bigint): bigint {
5400 if(!isWasmInitialized) {
5401 throw new Error("initializeWasm() must be awaited first!");
5403 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_ok(owner);
5404 return nativeResponseValue;
5406 // struct LDKDecodeError CResult_FundingCreatedDecodeErrorZ_get_err(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
5408 export function CResult_FundingCreatedDecodeErrorZ_get_err(owner: bigint): bigint {
5409 if(!isWasmInitialized) {
5410 throw new Error("initializeWasm() must be awaited first!");
5412 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_err(owner);
5413 return nativeResponseValue;
5415 // struct LDKFundingSigned CResult_FundingSignedDecodeErrorZ_get_ok(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
5417 export function CResult_FundingSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
5418 if(!isWasmInitialized) {
5419 throw new Error("initializeWasm() must be awaited first!");
5421 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_ok(owner);
5422 return nativeResponseValue;
5424 // struct LDKDecodeError CResult_FundingSignedDecodeErrorZ_get_err(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
5426 export function CResult_FundingSignedDecodeErrorZ_get_err(owner: bigint): bigint {
5427 if(!isWasmInitialized) {
5428 throw new Error("initializeWasm() must be awaited first!");
5430 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_err(owner);
5431 return nativeResponseValue;
5433 // struct LDKChannelReady CResult_ChannelReadyDecodeErrorZ_get_ok(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
5435 export function CResult_ChannelReadyDecodeErrorZ_get_ok(owner: bigint): bigint {
5436 if(!isWasmInitialized) {
5437 throw new Error("initializeWasm() must be awaited first!");
5439 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_ok(owner);
5440 return nativeResponseValue;
5442 // struct LDKDecodeError CResult_ChannelReadyDecodeErrorZ_get_err(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
5444 export function CResult_ChannelReadyDecodeErrorZ_get_err(owner: bigint): bigint {
5445 if(!isWasmInitialized) {
5446 throw new Error("initializeWasm() must be awaited first!");
5448 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_err(owner);
5449 return nativeResponseValue;
5451 // struct LDKInit CResult_InitDecodeErrorZ_get_ok(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
5453 export function CResult_InitDecodeErrorZ_get_ok(owner: bigint): bigint {
5454 if(!isWasmInitialized) {
5455 throw new Error("initializeWasm() must be awaited first!");
5457 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_ok(owner);
5458 return nativeResponseValue;
5460 // struct LDKDecodeError CResult_InitDecodeErrorZ_get_err(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
5462 export function CResult_InitDecodeErrorZ_get_err(owner: bigint): bigint {
5463 if(!isWasmInitialized) {
5464 throw new Error("initializeWasm() must be awaited first!");
5466 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_err(owner);
5467 return nativeResponseValue;
5469 // struct LDKOpenChannel CResult_OpenChannelDecodeErrorZ_get_ok(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
5471 export function CResult_OpenChannelDecodeErrorZ_get_ok(owner: bigint): bigint {
5472 if(!isWasmInitialized) {
5473 throw new Error("initializeWasm() must be awaited first!");
5475 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_ok(owner);
5476 return nativeResponseValue;
5478 // struct LDKDecodeError CResult_OpenChannelDecodeErrorZ_get_err(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
5480 export function CResult_OpenChannelDecodeErrorZ_get_err(owner: bigint): bigint {
5481 if(!isWasmInitialized) {
5482 throw new Error("initializeWasm() must be awaited first!");
5484 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_err(owner);
5485 return nativeResponseValue;
5487 // struct LDKRevokeAndACK CResult_RevokeAndACKDecodeErrorZ_get_ok(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
5489 export function CResult_RevokeAndACKDecodeErrorZ_get_ok(owner: bigint): bigint {
5490 if(!isWasmInitialized) {
5491 throw new Error("initializeWasm() must be awaited first!");
5493 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_ok(owner);
5494 return nativeResponseValue;
5496 // struct LDKDecodeError CResult_RevokeAndACKDecodeErrorZ_get_err(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
5498 export function CResult_RevokeAndACKDecodeErrorZ_get_err(owner: bigint): bigint {
5499 if(!isWasmInitialized) {
5500 throw new Error("initializeWasm() must be awaited first!");
5502 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_err(owner);
5503 return nativeResponseValue;
5505 // struct LDKShutdown CResult_ShutdownDecodeErrorZ_get_ok(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
5507 export function CResult_ShutdownDecodeErrorZ_get_ok(owner: bigint): bigint {
5508 if(!isWasmInitialized) {
5509 throw new Error("initializeWasm() must be awaited first!");
5511 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_ok(owner);
5512 return nativeResponseValue;
5514 // struct LDKDecodeError CResult_ShutdownDecodeErrorZ_get_err(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
5516 export function CResult_ShutdownDecodeErrorZ_get_err(owner: bigint): bigint {
5517 if(!isWasmInitialized) {
5518 throw new Error("initializeWasm() must be awaited first!");
5520 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_err(owner);
5521 return nativeResponseValue;
5523 // struct LDKUpdateFailHTLC CResult_UpdateFailHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
5525 export function CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
5526 if(!isWasmInitialized) {
5527 throw new Error("initializeWasm() must be awaited first!");
5529 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner);
5530 return nativeResponseValue;
5532 // struct LDKDecodeError CResult_UpdateFailHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
5534 export function CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
5535 if(!isWasmInitialized) {
5536 throw new Error("initializeWasm() must be awaited first!");
5538 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner);
5539 return nativeResponseValue;
5541 // struct LDKUpdateFailMalformedHTLC CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
5543 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
5544 if(!isWasmInitialized) {
5545 throw new Error("initializeWasm() must be awaited first!");
5547 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner);
5548 return nativeResponseValue;
5550 // struct LDKDecodeError CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
5552 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
5553 if(!isWasmInitialized) {
5554 throw new Error("initializeWasm() must be awaited first!");
5556 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner);
5557 return nativeResponseValue;
5559 // struct LDKUpdateFee CResult_UpdateFeeDecodeErrorZ_get_ok(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
5561 export function CResult_UpdateFeeDecodeErrorZ_get_ok(owner: bigint): bigint {
5562 if(!isWasmInitialized) {
5563 throw new Error("initializeWasm() must be awaited first!");
5565 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_ok(owner);
5566 return nativeResponseValue;
5568 // struct LDKDecodeError CResult_UpdateFeeDecodeErrorZ_get_err(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
5570 export function CResult_UpdateFeeDecodeErrorZ_get_err(owner: bigint): bigint {
5571 if(!isWasmInitialized) {
5572 throw new Error("initializeWasm() must be awaited first!");
5574 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_err(owner);
5575 return nativeResponseValue;
5577 // struct LDKUpdateFulfillHTLC CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
5579 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
5580 if(!isWasmInitialized) {
5581 throw new Error("initializeWasm() must be awaited first!");
5583 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner);
5584 return nativeResponseValue;
5586 // struct LDKDecodeError CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
5588 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
5589 if(!isWasmInitialized) {
5590 throw new Error("initializeWasm() must be awaited first!");
5592 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner);
5593 return nativeResponseValue;
5595 // struct LDKUpdateAddHTLC CResult_UpdateAddHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
5597 export function CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
5598 if(!isWasmInitialized) {
5599 throw new Error("initializeWasm() must be awaited first!");
5601 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner);
5602 return nativeResponseValue;
5604 // struct LDKDecodeError CResult_UpdateAddHTLCDecodeErrorZ_get_err(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
5606 export function CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
5607 if(!isWasmInitialized) {
5608 throw new Error("initializeWasm() must be awaited first!");
5610 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner);
5611 return nativeResponseValue;
5613 // struct LDKOnionMessage CResult_OnionMessageDecodeErrorZ_get_ok(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner);
5615 export function CResult_OnionMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
5616 if(!isWasmInitialized) {
5617 throw new Error("initializeWasm() must be awaited first!");
5619 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_get_ok(owner);
5620 return nativeResponseValue;
5622 // struct LDKDecodeError CResult_OnionMessageDecodeErrorZ_get_err(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner);
5624 export function CResult_OnionMessageDecodeErrorZ_get_err(owner: bigint): bigint {
5625 if(!isWasmInitialized) {
5626 throw new Error("initializeWasm() must be awaited first!");
5628 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_get_err(owner);
5629 return nativeResponseValue;
5631 // struct LDKPing CResult_PingDecodeErrorZ_get_ok(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
5633 export function CResult_PingDecodeErrorZ_get_ok(owner: bigint): bigint {
5634 if(!isWasmInitialized) {
5635 throw new Error("initializeWasm() must be awaited first!");
5637 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_ok(owner);
5638 return nativeResponseValue;
5640 // struct LDKDecodeError CResult_PingDecodeErrorZ_get_err(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
5642 export function CResult_PingDecodeErrorZ_get_err(owner: bigint): bigint {
5643 if(!isWasmInitialized) {
5644 throw new Error("initializeWasm() must be awaited first!");
5646 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_err(owner);
5647 return nativeResponseValue;
5649 // struct LDKPong CResult_PongDecodeErrorZ_get_ok(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
5651 export function CResult_PongDecodeErrorZ_get_ok(owner: bigint): bigint {
5652 if(!isWasmInitialized) {
5653 throw new Error("initializeWasm() must be awaited first!");
5655 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_ok(owner);
5656 return nativeResponseValue;
5658 // struct LDKDecodeError CResult_PongDecodeErrorZ_get_err(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
5660 export function CResult_PongDecodeErrorZ_get_err(owner: bigint): bigint {
5661 if(!isWasmInitialized) {
5662 throw new Error("initializeWasm() must be awaited first!");
5664 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_err(owner);
5665 return nativeResponseValue;
5667 // struct LDKUnsignedChannelAnnouncement CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5669 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
5670 if(!isWasmInitialized) {
5671 throw new Error("initializeWasm() must be awaited first!");
5673 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner);
5674 return nativeResponseValue;
5676 // struct LDKDecodeError CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5678 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
5679 if(!isWasmInitialized) {
5680 throw new Error("initializeWasm() must be awaited first!");
5682 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner);
5683 return nativeResponseValue;
5685 // struct LDKChannelAnnouncement CResult_ChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5687 export function CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
5688 if(!isWasmInitialized) {
5689 throw new Error("initializeWasm() must be awaited first!");
5691 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner);
5692 return nativeResponseValue;
5694 // struct LDKDecodeError CResult_ChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5696 export function CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
5697 if(!isWasmInitialized) {
5698 throw new Error("initializeWasm() must be awaited first!");
5700 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner);
5701 return nativeResponseValue;
5703 // struct LDKUnsignedChannelUpdate CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5705 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
5706 if(!isWasmInitialized) {
5707 throw new Error("initializeWasm() must be awaited first!");
5709 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner);
5710 return nativeResponseValue;
5712 // struct LDKDecodeError CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5714 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
5715 if(!isWasmInitialized) {
5716 throw new Error("initializeWasm() must be awaited first!");
5718 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner);
5719 return nativeResponseValue;
5721 // struct LDKChannelUpdate CResult_ChannelUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5723 export function CResult_ChannelUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
5724 if(!isWasmInitialized) {
5725 throw new Error("initializeWasm() must be awaited first!");
5727 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_ok(owner);
5728 return nativeResponseValue;
5730 // struct LDKDecodeError CResult_ChannelUpdateDecodeErrorZ_get_err(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5732 export function CResult_ChannelUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
5733 if(!isWasmInitialized) {
5734 throw new Error("initializeWasm() must be awaited first!");
5736 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_err(owner);
5737 return nativeResponseValue;
5739 // struct LDKErrorMessage CResult_ErrorMessageDecodeErrorZ_get_ok(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
5741 export function CResult_ErrorMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
5742 if(!isWasmInitialized) {
5743 throw new Error("initializeWasm() must be awaited first!");
5745 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_ok(owner);
5746 return nativeResponseValue;
5748 // struct LDKDecodeError CResult_ErrorMessageDecodeErrorZ_get_err(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
5750 export function CResult_ErrorMessageDecodeErrorZ_get_err(owner: bigint): bigint {
5751 if(!isWasmInitialized) {
5752 throw new Error("initializeWasm() must be awaited first!");
5754 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_err(owner);
5755 return nativeResponseValue;
5757 // struct LDKWarningMessage CResult_WarningMessageDecodeErrorZ_get_ok(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
5759 export function CResult_WarningMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
5760 if(!isWasmInitialized) {
5761 throw new Error("initializeWasm() must be awaited first!");
5763 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_ok(owner);
5764 return nativeResponseValue;
5766 // struct LDKDecodeError CResult_WarningMessageDecodeErrorZ_get_err(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
5768 export function CResult_WarningMessageDecodeErrorZ_get_err(owner: bigint): bigint {
5769 if(!isWasmInitialized) {
5770 throw new Error("initializeWasm() must be awaited first!");
5772 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_err(owner);
5773 return nativeResponseValue;
5775 // struct LDKUnsignedNodeAnnouncement CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5777 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
5778 if(!isWasmInitialized) {
5779 throw new Error("initializeWasm() must be awaited first!");
5781 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner);
5782 return nativeResponseValue;
5784 // struct LDKDecodeError CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5786 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
5787 if(!isWasmInitialized) {
5788 throw new Error("initializeWasm() must be awaited first!");
5790 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner);
5791 return nativeResponseValue;
5793 // struct LDKNodeAnnouncement CResult_NodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5795 export function CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
5796 if(!isWasmInitialized) {
5797 throw new Error("initializeWasm() must be awaited first!");
5799 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner);
5800 return nativeResponseValue;
5802 // struct LDKDecodeError CResult_NodeAnnouncementDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5804 export function CResult_NodeAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
5805 if(!isWasmInitialized) {
5806 throw new Error("initializeWasm() must be awaited first!");
5808 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_err(owner);
5809 return nativeResponseValue;
5811 // struct LDKQueryShortChannelIds CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
5813 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner: bigint): bigint {
5814 if(!isWasmInitialized) {
5815 throw new Error("initializeWasm() must be awaited first!");
5817 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner);
5818 return nativeResponseValue;
5820 // struct LDKDecodeError CResult_QueryShortChannelIdsDecodeErrorZ_get_err(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
5822 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner: bigint): bigint {
5823 if(!isWasmInitialized) {
5824 throw new Error("initializeWasm() must be awaited first!");
5826 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner);
5827 return nativeResponseValue;
5829 // struct LDKReplyShortChannelIdsEnd CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
5831 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner: bigint): bigint {
5832 if(!isWasmInitialized) {
5833 throw new Error("initializeWasm() must be awaited first!");
5835 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner);
5836 return nativeResponseValue;
5838 // struct LDKDecodeError CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
5840 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner: bigint): bigint {
5841 if(!isWasmInitialized) {
5842 throw new Error("initializeWasm() must be awaited first!");
5844 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner);
5845 return nativeResponseValue;
5847 // struct LDKQueryChannelRange CResult_QueryChannelRangeDecodeErrorZ_get_ok(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5849 export function CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
5850 if(!isWasmInitialized) {
5851 throw new Error("initializeWasm() must be awaited first!");
5853 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner);
5854 return nativeResponseValue;
5856 // struct LDKDecodeError CResult_QueryChannelRangeDecodeErrorZ_get_err(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5858 export function CResult_QueryChannelRangeDecodeErrorZ_get_err(owner: bigint): bigint {
5859 if(!isWasmInitialized) {
5860 throw new Error("initializeWasm() must be awaited first!");
5862 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_err(owner);
5863 return nativeResponseValue;
5865 // struct LDKReplyChannelRange CResult_ReplyChannelRangeDecodeErrorZ_get_ok(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5867 export function CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
5868 if(!isWasmInitialized) {
5869 throw new Error("initializeWasm() must be awaited first!");
5871 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner);
5872 return nativeResponseValue;
5874 // struct LDKDecodeError CResult_ReplyChannelRangeDecodeErrorZ_get_err(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5876 export function CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner: bigint): bigint {
5877 if(!isWasmInitialized) {
5878 throw new Error("initializeWasm() must be awaited first!");
5880 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner);
5881 return nativeResponseValue;
5883 // struct LDKGossipTimestampFilter CResult_GossipTimestampFilterDecodeErrorZ_get_ok(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
5885 export function CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner: bigint): bigint {
5886 if(!isWasmInitialized) {
5887 throw new Error("initializeWasm() must be awaited first!");
5889 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner);
5890 return nativeResponseValue;
5892 // struct LDKDecodeError CResult_GossipTimestampFilterDecodeErrorZ_get_err(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
5894 export function CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner: bigint): bigint {
5895 if(!isWasmInitialized) {
5896 throw new Error("initializeWasm() must be awaited first!");
5898 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner);
5899 return nativeResponseValue;
5902 export class LDKSignOrCreationError {
5903 protected constructor() {}
5906 export function LDKSignOrCreationError_ty_from_ptr(ptr: bigint): number {
5907 if(!isWasmInitialized) {
5908 throw new Error("initializeWasm() must be awaited first!");
5910 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_ty_from_ptr(ptr);
5911 return nativeResponseValue;
5914 export function LDKSignOrCreationError_CreationError_get_creation_error(ptr: bigint): CreationError {
5915 if(!isWasmInitialized) {
5916 throw new Error("initializeWasm() must be awaited first!");
5918 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_CreationError_get_creation_error(ptr);
5919 return nativeResponseValue;
5921 // struct LDKInvoice CResult_InvoiceSignOrCreationErrorZ_get_ok(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
5923 export function CResult_InvoiceSignOrCreationErrorZ_get_ok(owner: bigint): bigint {
5924 if(!isWasmInitialized) {
5925 throw new Error("initializeWasm() must be awaited first!");
5927 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_ok(owner);
5928 return nativeResponseValue;
5930 // struct LDKSignOrCreationError CResult_InvoiceSignOrCreationErrorZ_get_err(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
5932 export function CResult_InvoiceSignOrCreationErrorZ_get_err(owner: bigint): bigint {
5933 if(!isWasmInitialized) {
5934 throw new Error("initializeWasm() must be awaited first!");
5936 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_err(owner);
5937 return nativeResponseValue;
5940 export interface LDKFilter {
5941 register_tx (txid: number, script_pubkey: number): void;
5942 register_output (output: bigint): void;
5946 export function LDKFilter_new(impl: LDKFilter): [bigint, number] {
5947 if(!isWasmInitialized) {
5948 throw new Error("initializeWasm() must be awaited first!");
5950 var new_obj_idx = js_objs.length;
5951 for (var i = 0; i < js_objs.length; i++) {
5952 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5954 js_objs[i] = new WeakRef(impl);
5955 return [wasm.TS_LDKFilter_new(i), i];
5957 // void Filter_register_tx LDKFilter *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
5959 export function Filter_register_tx(this_arg: bigint, txid: number, script_pubkey: number): void {
5960 if(!isWasmInitialized) {
5961 throw new Error("initializeWasm() must be awaited first!");
5963 const nativeResponseValue = wasm.TS_Filter_register_tx(this_arg, txid, script_pubkey);
5964 // debug statements here
5966 // void Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
5968 export function Filter_register_output(this_arg: bigint, output: bigint): void {
5969 if(!isWasmInitialized) {
5970 throw new Error("initializeWasm() must be awaited first!");
5972 const nativeResponseValue = wasm.TS_Filter_register_output(this_arg, output);
5973 // debug statements here
5976 export class LDKCOption_FilterZ {
5977 protected constructor() {}
5980 export function LDKCOption_FilterZ_ty_from_ptr(ptr: bigint): number {
5981 if(!isWasmInitialized) {
5982 throw new Error("initializeWasm() must be awaited first!");
5984 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_ty_from_ptr(ptr);
5985 return nativeResponseValue;
5988 export function LDKCOption_FilterZ_Some_get_some(ptr: bigint): bigint {
5989 if(!isWasmInitialized) {
5990 throw new Error("initializeWasm() must be awaited first!");
5992 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_Some_get_some(ptr);
5993 return nativeResponseValue;
5995 // struct LDKLockedChannelMonitor CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
5997 export function CResult_LockedChannelMonitorNoneZ_get_ok(owner: bigint): bigint {
5998 if(!isWasmInitialized) {
5999 throw new Error("initializeWasm() must be awaited first!");
6001 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_ok(owner);
6002 return nativeResponseValue;
6004 // void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
6006 export function CResult_LockedChannelMonitorNoneZ_get_err(owner: bigint): void {
6007 if(!isWasmInitialized) {
6008 throw new Error("initializeWasm() must be awaited first!");
6010 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_err(owner);
6011 // debug statements here
6014 export interface LDKMessageSendEventsProvider {
6015 get_and_clear_pending_msg_events (): number;
6019 export function LDKMessageSendEventsProvider_new(impl: LDKMessageSendEventsProvider): [bigint, number] {
6020 if(!isWasmInitialized) {
6021 throw new Error("initializeWasm() must be awaited first!");
6023 var new_obj_idx = js_objs.length;
6024 for (var i = 0; i < js_objs.length; i++) {
6025 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6027 js_objs[i] = new WeakRef(impl);
6028 return [wasm.TS_LDKMessageSendEventsProvider_new(i), i];
6030 // LDKCVec_MessageSendEventZ MessageSendEventsProvider_get_and_clear_pending_msg_events LDKMessageSendEventsProvider *NONNULL_PTR this_arg
6032 export function MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg: bigint): number {
6033 if(!isWasmInitialized) {
6034 throw new Error("initializeWasm() must be awaited first!");
6036 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg);
6037 return nativeResponseValue;
6040 export interface LDKOnionMessageProvider {
6041 next_onion_message_for_peer (peer_node_id: number): bigint;
6045 export function LDKOnionMessageProvider_new(impl: LDKOnionMessageProvider): [bigint, number] {
6046 if(!isWasmInitialized) {
6047 throw new Error("initializeWasm() must be awaited first!");
6049 var new_obj_idx = js_objs.length;
6050 for (var i = 0; i < js_objs.length; i++) {
6051 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6053 js_objs[i] = new WeakRef(impl);
6054 return [wasm.TS_LDKOnionMessageProvider_new(i), i];
6056 // LDKOnionMessage OnionMessageProvider_next_onion_message_for_peer LDKOnionMessageProvider *NONNULL_PTR this_arg, struct LDKPublicKey peer_node_id
6058 export function OnionMessageProvider_next_onion_message_for_peer(this_arg: bigint, peer_node_id: number): bigint {
6059 if(!isWasmInitialized) {
6060 throw new Error("initializeWasm() must be awaited first!");
6062 const nativeResponseValue = wasm.TS_OnionMessageProvider_next_onion_message_for_peer(this_arg, peer_node_id);
6063 return nativeResponseValue;
6066 export interface LDKEventHandler {
6067 handle_event (event: bigint): void;
6071 export function LDKEventHandler_new(impl: LDKEventHandler): [bigint, number] {
6072 if(!isWasmInitialized) {
6073 throw new Error("initializeWasm() must be awaited first!");
6075 var new_obj_idx = js_objs.length;
6076 for (var i = 0; i < js_objs.length; i++) {
6077 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6079 js_objs[i] = new WeakRef(impl);
6080 return [wasm.TS_LDKEventHandler_new(i), i];
6082 // void EventHandler_handle_event LDKEventHandler *NONNULL_PTR this_arg, const struct LDKEvent *NONNULL_PTR event
6084 export function EventHandler_handle_event(this_arg: bigint, event: bigint): void {
6085 if(!isWasmInitialized) {
6086 throw new Error("initializeWasm() must be awaited first!");
6088 const nativeResponseValue = wasm.TS_EventHandler_handle_event(this_arg, event);
6089 // debug statements here
6092 export interface LDKEventsProvider {
6093 process_pending_events (handler: bigint): void;
6097 export function LDKEventsProvider_new(impl: LDKEventsProvider): [bigint, number] {
6098 if(!isWasmInitialized) {
6099 throw new Error("initializeWasm() must be awaited first!");
6101 var new_obj_idx = js_objs.length;
6102 for (var i = 0; i < js_objs.length; i++) {
6103 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6105 js_objs[i] = new WeakRef(impl);
6106 return [wasm.TS_LDKEventsProvider_new(i), i];
6108 // void EventsProvider_process_pending_events LDKEventsProvider *NONNULL_PTR this_arg, struct LDKEventHandler handler
6110 export function EventsProvider_process_pending_events(this_arg: bigint, handler: bigint): void {
6111 if(!isWasmInitialized) {
6112 throw new Error("initializeWasm() must be awaited first!");
6114 const nativeResponseValue = wasm.TS_EventsProvider_process_pending_events(this_arg, handler);
6115 // debug statements here
6118 export interface LDKScore {
6119 channel_penalty_msat (short_channel_id: bigint, source: bigint, target: bigint, usage: bigint): bigint;
6120 payment_path_failed (path: number, short_channel_id: bigint): void;
6121 payment_path_successful (path: number): void;
6122 probe_failed (path: number, short_channel_id: bigint): void;
6123 probe_successful (path: number): void;
6128 export function LDKScore_new(impl: LDKScore): [bigint, number] {
6129 if(!isWasmInitialized) {
6130 throw new Error("initializeWasm() must be awaited first!");
6132 var new_obj_idx = js_objs.length;
6133 for (var i = 0; i < js_objs.length; i++) {
6134 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6136 js_objs[i] = new WeakRef(impl);
6137 return [wasm.TS_LDKScore_new(i), i];
6139 // uint64_t Score_channel_penalty_msat LDKScore *NONNULL_PTR this_arg, uint64_t short_channel_id, const struct LDKNodeId *NONNULL_PTR source, const struct LDKNodeId *NONNULL_PTR target, struct LDKChannelUsage usage
6141 export function Score_channel_penalty_msat(this_arg: bigint, short_channel_id: bigint, source: bigint, target: bigint, usage: bigint): bigint {
6142 if(!isWasmInitialized) {
6143 throw new Error("initializeWasm() must be awaited first!");
6145 const nativeResponseValue = wasm.TS_Score_channel_penalty_msat(this_arg, short_channel_id, source, target, usage);
6146 return nativeResponseValue;
6148 // void Score_payment_path_failed LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
6150 export function Score_payment_path_failed(this_arg: bigint, path: number, short_channel_id: bigint): void {
6151 if(!isWasmInitialized) {
6152 throw new Error("initializeWasm() must be awaited first!");
6154 const nativeResponseValue = wasm.TS_Score_payment_path_failed(this_arg, path, short_channel_id);
6155 // debug statements here
6157 // void Score_payment_path_successful LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
6159 export function Score_payment_path_successful(this_arg: bigint, path: number): void {
6160 if(!isWasmInitialized) {
6161 throw new Error("initializeWasm() must be awaited first!");
6163 const nativeResponseValue = wasm.TS_Score_payment_path_successful(this_arg, path);
6164 // debug statements here
6166 // void Score_probe_failed LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
6168 export function Score_probe_failed(this_arg: bigint, path: number, short_channel_id: bigint): void {
6169 if(!isWasmInitialized) {
6170 throw new Error("initializeWasm() must be awaited first!");
6172 const nativeResponseValue = wasm.TS_Score_probe_failed(this_arg, path, short_channel_id);
6173 // debug statements here
6175 // void Score_probe_successful LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
6177 export function Score_probe_successful(this_arg: bigint, path: number): void {
6178 if(!isWasmInitialized) {
6179 throw new Error("initializeWasm() must be awaited first!");
6181 const nativeResponseValue = wasm.TS_Score_probe_successful(this_arg, path);
6182 // debug statements here
6184 // LDKCVec_u8Z Score_write LDKScore *NONNULL_PTR this_arg
6186 export function Score_write(this_arg: bigint): number {
6187 if(!isWasmInitialized) {
6188 throw new Error("initializeWasm() must be awaited first!");
6190 const nativeResponseValue = wasm.TS_Score_write(this_arg);
6191 return nativeResponseValue;
6194 export interface LDKLockableScore {
6199 export function LDKLockableScore_new(impl: LDKLockableScore): [bigint, number] {
6200 if(!isWasmInitialized) {
6201 throw new Error("initializeWasm() must be awaited first!");
6203 var new_obj_idx = js_objs.length;
6204 for (var i = 0; i < js_objs.length; i++) {
6205 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6207 js_objs[i] = new WeakRef(impl);
6208 return [wasm.TS_LDKLockableScore_new(i), i];
6210 // LDKScore LockableScore_lock LDKLockableScore *NONNULL_PTR this_arg
6212 export function LockableScore_lock(this_arg: bigint): bigint {
6213 if(!isWasmInitialized) {
6214 throw new Error("initializeWasm() must be awaited first!");
6216 const nativeResponseValue = wasm.TS_LockableScore_lock(this_arg);
6217 return nativeResponseValue;
6220 export interface LDKWriteableScore {
6225 export function LDKWriteableScore_new(impl: LDKWriteableScore, LockableScore: number): [bigint, number] {
6226 if(!isWasmInitialized) {
6227 throw new Error("initializeWasm() must be awaited first!");
6229 var new_obj_idx = js_objs.length;
6230 for (var i = 0; i < js_objs.length; i++) {
6231 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6233 js_objs[i] = new WeakRef(impl);
6234 return [wasm.TS_LDKWriteableScore_new(i, LockableScore), i];
6236 // LDKCVec_u8Z WriteableScore_write LDKWriteableScore *NONNULL_PTR this_arg
6238 export function WriteableScore_write(this_arg: bigint): number {
6239 if(!isWasmInitialized) {
6240 throw new Error("initializeWasm() must be awaited first!");
6242 const nativeResponseValue = wasm.TS_WriteableScore_write(this_arg);
6243 return nativeResponseValue;
6246 export interface LDKPersister {
6247 persist_manager (channel_manager: bigint): bigint;
6248 persist_graph (network_graph: bigint): bigint;
6249 persist_scorer (scorer: bigint): bigint;
6253 export function LDKPersister_new(impl: LDKPersister): [bigint, number] {
6254 if(!isWasmInitialized) {
6255 throw new Error("initializeWasm() must be awaited first!");
6257 var new_obj_idx = js_objs.length;
6258 for (var i = 0; i < js_objs.length; i++) {
6259 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6261 js_objs[i] = new WeakRef(impl);
6262 return [wasm.TS_LDKPersister_new(i), i];
6264 // LDKCResult_NoneErrorZ Persister_persist_manager LDKPersister *NONNULL_PTR this_arg, const struct LDKChannelManager *NONNULL_PTR channel_manager
6266 export function Persister_persist_manager(this_arg: bigint, channel_manager: bigint): bigint {
6267 if(!isWasmInitialized) {
6268 throw new Error("initializeWasm() must be awaited first!");
6270 const nativeResponseValue = wasm.TS_Persister_persist_manager(this_arg, channel_manager);
6271 return nativeResponseValue;
6273 // LDKCResult_NoneErrorZ Persister_persist_graph LDKPersister *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR network_graph
6275 export function Persister_persist_graph(this_arg: bigint, network_graph: bigint): bigint {
6276 if(!isWasmInitialized) {
6277 throw new Error("initializeWasm() must be awaited first!");
6279 const nativeResponseValue = wasm.TS_Persister_persist_graph(this_arg, network_graph);
6280 return nativeResponseValue;
6282 // LDKCResult_NoneErrorZ Persister_persist_scorer LDKPersister *NONNULL_PTR this_arg, const struct LDKWriteableScore *NONNULL_PTR scorer
6284 export function Persister_persist_scorer(this_arg: bigint, scorer: bigint): bigint {
6285 if(!isWasmInitialized) {
6286 throw new Error("initializeWasm() must be awaited first!");
6288 const nativeResponseValue = wasm.TS_Persister_persist_scorer(this_arg, scorer);
6289 return nativeResponseValue;
6292 export interface LDKFutureCallback {
6297 export function LDKFutureCallback_new(impl: LDKFutureCallback): [bigint, number] {
6298 if(!isWasmInitialized) {
6299 throw new Error("initializeWasm() must be awaited first!");
6301 var new_obj_idx = js_objs.length;
6302 for (var i = 0; i < js_objs.length; i++) {
6303 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6305 js_objs[i] = new WeakRef(impl);
6306 return [wasm.TS_LDKFutureCallback_new(i), i];
6308 // void FutureCallback_call LDKFutureCallback *NONNULL_PTR this_arg
6310 export function FutureCallback_call(this_arg: bigint): void {
6311 if(!isWasmInitialized) {
6312 throw new Error("initializeWasm() must be awaited first!");
6314 const nativeResponseValue = wasm.TS_FutureCallback_call(this_arg);
6315 // debug statements here
6318 export interface LDKListen {
6319 filtered_block_connected (header: number, txdata: number, height: number): void;
6320 block_connected (block: number, height: number): void;
6321 block_disconnected (header: number, height: number): void;
6325 export function LDKListen_new(impl: LDKListen): [bigint, number] {
6326 if(!isWasmInitialized) {
6327 throw new Error("initializeWasm() must be awaited first!");
6329 var new_obj_idx = js_objs.length;
6330 for (var i = 0; i < js_objs.length; i++) {
6331 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6333 js_objs[i] = new WeakRef(impl);
6334 return [wasm.TS_LDKListen_new(i), i];
6336 // void Listen_filtered_block_connected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
6338 export function Listen_filtered_block_connected(this_arg: bigint, header: number, txdata: number, height: number): void {
6339 if(!isWasmInitialized) {
6340 throw new Error("initializeWasm() must be awaited first!");
6342 const nativeResponseValue = wasm.TS_Listen_filtered_block_connected(this_arg, header, txdata, height);
6343 // debug statements here
6345 // void Listen_block_connected LDKListen *NONNULL_PTR this_arg, struct LDKu8slice block, uint32_t height
6347 export function Listen_block_connected(this_arg: bigint, block: number, height: number): void {
6348 if(!isWasmInitialized) {
6349 throw new Error("initializeWasm() must be awaited first!");
6351 const nativeResponseValue = wasm.TS_Listen_block_connected(this_arg, block, height);
6352 // debug statements here
6354 // void Listen_block_disconnected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
6356 export function Listen_block_disconnected(this_arg: bigint, header: number, height: number): void {
6357 if(!isWasmInitialized) {
6358 throw new Error("initializeWasm() must be awaited first!");
6360 const nativeResponseValue = wasm.TS_Listen_block_disconnected(this_arg, header, height);
6361 // debug statements here
6364 export interface LDKConfirm {
6365 transactions_confirmed (header: number, txdata: number, height: number): void;
6366 transaction_unconfirmed (txid: number): void;
6367 best_block_updated (header: number, height: number): void;
6368 get_relevant_txids (): number;
6372 export function LDKConfirm_new(impl: LDKConfirm): [bigint, number] {
6373 if(!isWasmInitialized) {
6374 throw new Error("initializeWasm() must be awaited first!");
6376 var new_obj_idx = js_objs.length;
6377 for (var i = 0; i < js_objs.length; i++) {
6378 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6380 js_objs[i] = new WeakRef(impl);
6381 return [wasm.TS_LDKConfirm_new(i), i];
6383 // void Confirm_transactions_confirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
6385 export function Confirm_transactions_confirmed(this_arg: bigint, header: number, txdata: number, height: number): void {
6386 if(!isWasmInitialized) {
6387 throw new Error("initializeWasm() must be awaited first!");
6389 const nativeResponseValue = wasm.TS_Confirm_transactions_confirmed(this_arg, header, txdata, height);
6390 // debug statements here
6392 // void Confirm_transaction_unconfirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*txid)[32]
6394 export function Confirm_transaction_unconfirmed(this_arg: bigint, txid: number): void {
6395 if(!isWasmInitialized) {
6396 throw new Error("initializeWasm() must be awaited first!");
6398 const nativeResponseValue = wasm.TS_Confirm_transaction_unconfirmed(this_arg, txid);
6399 // debug statements here
6401 // void Confirm_best_block_updated LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
6403 export function Confirm_best_block_updated(this_arg: bigint, header: number, height: number): void {
6404 if(!isWasmInitialized) {
6405 throw new Error("initializeWasm() must be awaited first!");
6407 const nativeResponseValue = wasm.TS_Confirm_best_block_updated(this_arg, header, height);
6408 // debug statements here
6410 // LDKCVec_TxidZ Confirm_get_relevant_txids LDKConfirm *NONNULL_PTR this_arg
6412 export function Confirm_get_relevant_txids(this_arg: bigint): number {
6413 if(!isWasmInitialized) {
6414 throw new Error("initializeWasm() must be awaited first!");
6416 const nativeResponseValue = wasm.TS_Confirm_get_relevant_txids(this_arg);
6417 return nativeResponseValue;
6420 export interface LDKPersist {
6421 persist_new_channel (channel_id: bigint, data: bigint, update_id: bigint): bigint;
6422 update_persisted_channel (channel_id: bigint, update: bigint, data: bigint, update_id: bigint): bigint;
6426 export function LDKPersist_new(impl: LDKPersist): [bigint, number] {
6427 if(!isWasmInitialized) {
6428 throw new Error("initializeWasm() must be awaited first!");
6430 var new_obj_idx = js_objs.length;
6431 for (var i = 0; i < js_objs.length; i++) {
6432 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6434 js_objs[i] = new WeakRef(impl);
6435 return [wasm.TS_LDKPersist_new(i), i];
6437 // 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
6439 export function Persist_persist_new_channel(this_arg: bigint, channel_id: bigint, data: bigint, update_id: bigint): bigint {
6440 if(!isWasmInitialized) {
6441 throw new Error("initializeWasm() must be awaited first!");
6443 const nativeResponseValue = wasm.TS_Persist_persist_new_channel(this_arg, channel_id, data, update_id);
6444 return nativeResponseValue;
6446 // 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
6448 export function Persist_update_persisted_channel(this_arg: bigint, channel_id: bigint, update: bigint, data: bigint, update_id: bigint): bigint {
6449 if(!isWasmInitialized) {
6450 throw new Error("initializeWasm() must be awaited first!");
6452 const nativeResponseValue = wasm.TS_Persist_update_persisted_channel(this_arg, channel_id, update, data, update_id);
6453 return nativeResponseValue;
6456 export interface LDKChannelMessageHandler {
6457 handle_open_channel (their_node_id: number, their_features: bigint, msg: bigint): void;
6458 handle_accept_channel (their_node_id: number, their_features: bigint, msg: bigint): void;
6459 handle_funding_created (their_node_id: number, msg: bigint): void;
6460 handle_funding_signed (their_node_id: number, msg: bigint): void;
6461 handle_channel_ready (their_node_id: number, msg: bigint): void;
6462 handle_shutdown (their_node_id: number, their_features: bigint, msg: bigint): void;
6463 handle_closing_signed (their_node_id: number, msg: bigint): void;
6464 handle_update_add_htlc (their_node_id: number, msg: bigint): void;
6465 handle_update_fulfill_htlc (their_node_id: number, msg: bigint): void;
6466 handle_update_fail_htlc (their_node_id: number, msg: bigint): void;
6467 handle_update_fail_malformed_htlc (their_node_id: number, msg: bigint): void;
6468 handle_commitment_signed (their_node_id: number, msg: bigint): void;
6469 handle_revoke_and_ack (their_node_id: number, msg: bigint): void;
6470 handle_update_fee (their_node_id: number, msg: bigint): void;
6471 handle_announcement_signatures (their_node_id: number, msg: bigint): void;
6472 peer_disconnected (their_node_id: number, no_connection_possible: boolean): void;
6473 peer_connected (their_node_id: number, msg: bigint): void;
6474 handle_channel_reestablish (their_node_id: number, msg: bigint): void;
6475 handle_channel_update (their_node_id: number, msg: bigint): void;
6476 handle_error (their_node_id: number, msg: bigint): void;
6477 provided_node_features (): bigint;
6478 provided_init_features (their_node_id: number): bigint;
6482 export function LDKChannelMessageHandler_new(impl: LDKChannelMessageHandler, MessageSendEventsProvider: number): [bigint, number] {
6483 if(!isWasmInitialized) {
6484 throw new Error("initializeWasm() must be awaited first!");
6486 var new_obj_idx = js_objs.length;
6487 for (var i = 0; i < js_objs.length; i++) {
6488 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6490 js_objs[i] = new WeakRef(impl);
6491 return [wasm.TS_LDKChannelMessageHandler_new(i, MessageSendEventsProvider), i];
6493 // 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
6495 export function ChannelMessageHandler_handle_open_channel(this_arg: bigint, their_node_id: number, their_features: bigint, msg: bigint): void {
6496 if(!isWasmInitialized) {
6497 throw new Error("initializeWasm() must be awaited first!");
6499 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_open_channel(this_arg, their_node_id, their_features, msg);
6500 // debug statements here
6502 // 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
6504 export function ChannelMessageHandler_handle_accept_channel(this_arg: bigint, their_node_id: number, their_features: bigint, msg: bigint): void {
6505 if(!isWasmInitialized) {
6506 throw new Error("initializeWasm() must be awaited first!");
6508 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_accept_channel(this_arg, their_node_id, their_features, msg);
6509 // debug statements here
6511 // void ChannelMessageHandler_handle_funding_created LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg
6513 export function ChannelMessageHandler_handle_funding_created(this_arg: bigint, their_node_id: number, msg: bigint): void {
6514 if(!isWasmInitialized) {
6515 throw new Error("initializeWasm() must be awaited first!");
6517 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_created(this_arg, their_node_id, msg);
6518 // debug statements here
6520 // void ChannelMessageHandler_handle_funding_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg
6522 export function ChannelMessageHandler_handle_funding_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
6523 if(!isWasmInitialized) {
6524 throw new Error("initializeWasm() must be awaited first!");
6526 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_signed(this_arg, their_node_id, msg);
6527 // debug statements here
6529 // void ChannelMessageHandler_handle_channel_ready LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg
6531 export function ChannelMessageHandler_handle_channel_ready(this_arg: bigint, their_node_id: number, msg: bigint): void {
6532 if(!isWasmInitialized) {
6533 throw new Error("initializeWasm() must be awaited first!");
6535 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_ready(this_arg, their_node_id, msg);
6536 // debug statements here
6538 // 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
6540 export function ChannelMessageHandler_handle_shutdown(this_arg: bigint, their_node_id: number, their_features: bigint, msg: bigint): void {
6541 if(!isWasmInitialized) {
6542 throw new Error("initializeWasm() must be awaited first!");
6544 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_shutdown(this_arg, their_node_id, their_features, msg);
6545 // debug statements here
6547 // void ChannelMessageHandler_handle_closing_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg
6549 export function ChannelMessageHandler_handle_closing_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
6550 if(!isWasmInitialized) {
6551 throw new Error("initializeWasm() must be awaited first!");
6553 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_closing_signed(this_arg, their_node_id, msg);
6554 // debug statements here
6556 // void ChannelMessageHandler_handle_update_add_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg
6558 export function ChannelMessageHandler_handle_update_add_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
6559 if(!isWasmInitialized) {
6560 throw new Error("initializeWasm() must be awaited first!");
6562 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_add_htlc(this_arg, their_node_id, msg);
6563 // debug statements here
6565 // void ChannelMessageHandler_handle_update_fulfill_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg
6567 export function ChannelMessageHandler_handle_update_fulfill_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
6568 if(!isWasmInitialized) {
6569 throw new Error("initializeWasm() must be awaited first!");
6571 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fulfill_htlc(this_arg, their_node_id, msg);
6572 // debug statements here
6574 // void ChannelMessageHandler_handle_update_fail_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg
6576 export function ChannelMessageHandler_handle_update_fail_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
6577 if(!isWasmInitialized) {
6578 throw new Error("initializeWasm() must be awaited first!");
6580 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_htlc(this_arg, their_node_id, msg);
6581 // debug statements here
6583 // void ChannelMessageHandler_handle_update_fail_malformed_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg
6585 export function ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
6586 if(!isWasmInitialized) {
6587 throw new Error("initializeWasm() must be awaited first!");
6589 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg, their_node_id, msg);
6590 // debug statements here
6592 // void ChannelMessageHandler_handle_commitment_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg
6594 export function ChannelMessageHandler_handle_commitment_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
6595 if(!isWasmInitialized) {
6596 throw new Error("initializeWasm() must be awaited first!");
6598 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_commitment_signed(this_arg, their_node_id, msg);
6599 // debug statements here
6601 // void ChannelMessageHandler_handle_revoke_and_ack LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg
6603 export function ChannelMessageHandler_handle_revoke_and_ack(this_arg: bigint, their_node_id: number, msg: bigint): void {
6604 if(!isWasmInitialized) {
6605 throw new Error("initializeWasm() must be awaited first!");
6607 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_revoke_and_ack(this_arg, their_node_id, msg);
6608 // debug statements here
6610 // void ChannelMessageHandler_handle_update_fee LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg
6612 export function ChannelMessageHandler_handle_update_fee(this_arg: bigint, their_node_id: number, msg: bigint): void {
6613 if(!isWasmInitialized) {
6614 throw new Error("initializeWasm() must be awaited first!");
6616 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fee(this_arg, their_node_id, msg);
6617 // debug statements here
6619 // void ChannelMessageHandler_handle_announcement_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg
6621 export function ChannelMessageHandler_handle_announcement_signatures(this_arg: bigint, their_node_id: number, msg: bigint): void {
6622 if(!isWasmInitialized) {
6623 throw new Error("initializeWasm() must be awaited first!");
6625 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_announcement_signatures(this_arg, their_node_id, msg);
6626 // debug statements here
6628 // void ChannelMessageHandler_peer_disconnected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, bool no_connection_possible
6630 export function ChannelMessageHandler_peer_disconnected(this_arg: bigint, their_node_id: number, no_connection_possible: boolean): void {
6631 if(!isWasmInitialized) {
6632 throw new Error("initializeWasm() must be awaited first!");
6634 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_disconnected(this_arg, their_node_id, no_connection_possible);
6635 // debug statements here
6637 // void ChannelMessageHandler_peer_connected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg
6639 export function ChannelMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, msg: bigint): void {
6640 if(!isWasmInitialized) {
6641 throw new Error("initializeWasm() must be awaited first!");
6643 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_connected(this_arg, their_node_id, msg);
6644 // debug statements here
6646 // void ChannelMessageHandler_handle_channel_reestablish LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg
6648 export function ChannelMessageHandler_handle_channel_reestablish(this_arg: bigint, their_node_id: number, msg: bigint): void {
6649 if(!isWasmInitialized) {
6650 throw new Error("initializeWasm() must be awaited first!");
6652 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_reestablish(this_arg, their_node_id, msg);
6653 // debug statements here
6655 // void ChannelMessageHandler_handle_channel_update LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg
6657 export function ChannelMessageHandler_handle_channel_update(this_arg: bigint, their_node_id: number, msg: bigint): void {
6658 if(!isWasmInitialized) {
6659 throw new Error("initializeWasm() must be awaited first!");
6661 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_update(this_arg, their_node_id, msg);
6662 // debug statements here
6664 // void ChannelMessageHandler_handle_error LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
6666 export function ChannelMessageHandler_handle_error(this_arg: bigint, their_node_id: number, msg: bigint): void {
6667 if(!isWasmInitialized) {
6668 throw new Error("initializeWasm() must be awaited first!");
6670 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_error(this_arg, their_node_id, msg);
6671 // debug statements here
6673 // LDKNodeFeatures ChannelMessageHandler_provided_node_features LDKChannelMessageHandler *NONNULL_PTR this_arg
6675 export function ChannelMessageHandler_provided_node_features(this_arg: bigint): bigint {
6676 if(!isWasmInitialized) {
6677 throw new Error("initializeWasm() must be awaited first!");
6679 const nativeResponseValue = wasm.TS_ChannelMessageHandler_provided_node_features(this_arg);
6680 return nativeResponseValue;
6682 // LDKInitFeatures ChannelMessageHandler_provided_init_features LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
6684 export function ChannelMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
6685 if(!isWasmInitialized) {
6686 throw new Error("initializeWasm() must be awaited first!");
6688 const nativeResponseValue = wasm.TS_ChannelMessageHandler_provided_init_features(this_arg, their_node_id);
6689 return nativeResponseValue;
6692 export interface LDKRoutingMessageHandler {
6693 handle_node_announcement (msg: bigint): bigint;
6694 handle_channel_announcement (msg: bigint): bigint;
6695 handle_channel_update (msg: bigint): bigint;
6696 get_next_channel_announcement (starting_point: bigint): bigint;
6697 get_next_node_announcement (starting_point: number): bigint;
6698 peer_connected (their_node_id: number, init: bigint): void;
6699 handle_reply_channel_range (their_node_id: number, msg: bigint): bigint;
6700 handle_reply_short_channel_ids_end (their_node_id: number, msg: bigint): bigint;
6701 handle_query_channel_range (their_node_id: number, msg: bigint): bigint;
6702 handle_query_short_channel_ids (their_node_id: number, msg: bigint): bigint;
6703 provided_node_features (): bigint;
6704 provided_init_features (their_node_id: number): bigint;
6708 export function LDKRoutingMessageHandler_new(impl: LDKRoutingMessageHandler, MessageSendEventsProvider: number): [bigint, number] {
6709 if(!isWasmInitialized) {
6710 throw new Error("initializeWasm() must be awaited first!");
6712 var new_obj_idx = js_objs.length;
6713 for (var i = 0; i < js_objs.length; i++) {
6714 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6716 js_objs[i] = new WeakRef(impl);
6717 return [wasm.TS_LDKRoutingMessageHandler_new(i, MessageSendEventsProvider), i];
6719 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg
6721 export function RoutingMessageHandler_handle_node_announcement(this_arg: bigint, msg: bigint): bigint {
6722 if(!isWasmInitialized) {
6723 throw new Error("initializeWasm() must be awaited first!");
6725 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_node_announcement(this_arg, msg);
6726 return nativeResponseValue;
6728 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg
6730 export function RoutingMessageHandler_handle_channel_announcement(this_arg: bigint, msg: bigint): bigint {
6731 if(!isWasmInitialized) {
6732 throw new Error("initializeWasm() must be awaited first!");
6734 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_announcement(this_arg, msg);
6735 return nativeResponseValue;
6737 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_update LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg
6739 export function RoutingMessageHandler_handle_channel_update(this_arg: bigint, msg: bigint): bigint {
6740 if(!isWasmInitialized) {
6741 throw new Error("initializeWasm() must be awaited first!");
6743 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_update(this_arg, msg);
6744 return nativeResponseValue;
6746 // LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler_get_next_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, uint64_t starting_point
6748 export function RoutingMessageHandler_get_next_channel_announcement(this_arg: bigint, starting_point: bigint): bigint {
6749 if(!isWasmInitialized) {
6750 throw new Error("initializeWasm() must be awaited first!");
6752 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_channel_announcement(this_arg, starting_point);
6753 return nativeResponseValue;
6755 // LDKNodeAnnouncement RoutingMessageHandler_get_next_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey starting_point
6757 export function RoutingMessageHandler_get_next_node_announcement(this_arg: bigint, starting_point: number): bigint {
6758 if(!isWasmInitialized) {
6759 throw new Error("initializeWasm() must be awaited first!");
6761 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_node_announcement(this_arg, starting_point);
6762 return nativeResponseValue;
6764 // void RoutingMessageHandler_peer_connected LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init
6766 export function RoutingMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, init: bigint): void {
6767 if(!isWasmInitialized) {
6768 throw new Error("initializeWasm() must be awaited first!");
6770 const nativeResponseValue = wasm.TS_RoutingMessageHandler_peer_connected(this_arg, their_node_id, init);
6771 // debug statements here
6773 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg
6775 export function RoutingMessageHandler_handle_reply_channel_range(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
6776 if(!isWasmInitialized) {
6777 throw new Error("initializeWasm() must be awaited first!");
6779 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_channel_range(this_arg, their_node_id, msg);
6780 return nativeResponseValue;
6782 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_short_channel_ids_end LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg
6784 export function RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
6785 if(!isWasmInitialized) {
6786 throw new Error("initializeWasm() must be awaited first!");
6788 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg, their_node_id, msg);
6789 return nativeResponseValue;
6791 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg
6793 export function RoutingMessageHandler_handle_query_channel_range(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
6794 if(!isWasmInitialized) {
6795 throw new Error("initializeWasm() must be awaited first!");
6797 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_channel_range(this_arg, their_node_id, msg);
6798 return nativeResponseValue;
6800 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_short_channel_ids LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg
6802 export function RoutingMessageHandler_handle_query_short_channel_ids(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
6803 if(!isWasmInitialized) {
6804 throw new Error("initializeWasm() must be awaited first!");
6806 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_short_channel_ids(this_arg, their_node_id, msg);
6807 return nativeResponseValue;
6809 // LDKNodeFeatures RoutingMessageHandler_provided_node_features LDKRoutingMessageHandler *NONNULL_PTR this_arg
6811 export function RoutingMessageHandler_provided_node_features(this_arg: bigint): bigint {
6812 if(!isWasmInitialized) {
6813 throw new Error("initializeWasm() must be awaited first!");
6815 const nativeResponseValue = wasm.TS_RoutingMessageHandler_provided_node_features(this_arg);
6816 return nativeResponseValue;
6818 // LDKInitFeatures RoutingMessageHandler_provided_init_features LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
6820 export function RoutingMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
6821 if(!isWasmInitialized) {
6822 throw new Error("initializeWasm() must be awaited first!");
6824 const nativeResponseValue = wasm.TS_RoutingMessageHandler_provided_init_features(this_arg, their_node_id);
6825 return nativeResponseValue;
6828 export interface LDKOnionMessageHandler {
6829 handle_onion_message (peer_node_id: number, msg: bigint): void;
6830 peer_connected (their_node_id: number, init: bigint): void;
6831 peer_disconnected (their_node_id: number, no_connection_possible: boolean): void;
6832 provided_node_features (): bigint;
6833 provided_init_features (their_node_id: number): bigint;
6837 export function LDKOnionMessageHandler_new(impl: LDKOnionMessageHandler, OnionMessageProvider: number): [bigint, number] {
6838 if(!isWasmInitialized) {
6839 throw new Error("initializeWasm() must be awaited first!");
6841 var new_obj_idx = js_objs.length;
6842 for (var i = 0; i < js_objs.length; i++) {
6843 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6845 js_objs[i] = new WeakRef(impl);
6846 return [wasm.TS_LDKOnionMessageHandler_new(i, OnionMessageProvider), i];
6848 // void OnionMessageHandler_handle_onion_message LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg
6850 export function OnionMessageHandler_handle_onion_message(this_arg: bigint, peer_node_id: number, msg: bigint): void {
6851 if(!isWasmInitialized) {
6852 throw new Error("initializeWasm() must be awaited first!");
6854 const nativeResponseValue = wasm.TS_OnionMessageHandler_handle_onion_message(this_arg, peer_node_id, msg);
6855 // debug statements here
6857 // void OnionMessageHandler_peer_connected LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init
6859 export function OnionMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, init: bigint): void {
6860 if(!isWasmInitialized) {
6861 throw new Error("initializeWasm() must be awaited first!");
6863 const nativeResponseValue = wasm.TS_OnionMessageHandler_peer_connected(this_arg, their_node_id, init);
6864 // debug statements here
6866 // void OnionMessageHandler_peer_disconnected LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, bool no_connection_possible
6868 export function OnionMessageHandler_peer_disconnected(this_arg: bigint, their_node_id: number, no_connection_possible: boolean): void {
6869 if(!isWasmInitialized) {
6870 throw new Error("initializeWasm() must be awaited first!");
6872 const nativeResponseValue = wasm.TS_OnionMessageHandler_peer_disconnected(this_arg, their_node_id, no_connection_possible);
6873 // debug statements here
6875 // LDKNodeFeatures OnionMessageHandler_provided_node_features LDKOnionMessageHandler *NONNULL_PTR this_arg
6877 export function OnionMessageHandler_provided_node_features(this_arg: bigint): bigint {
6878 if(!isWasmInitialized) {
6879 throw new Error("initializeWasm() must be awaited first!");
6881 const nativeResponseValue = wasm.TS_OnionMessageHandler_provided_node_features(this_arg);
6882 return nativeResponseValue;
6884 // LDKInitFeatures OnionMessageHandler_provided_init_features LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
6886 export function OnionMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
6887 if(!isWasmInitialized) {
6888 throw new Error("initializeWasm() must be awaited first!");
6890 const nativeResponseValue = wasm.TS_OnionMessageHandler_provided_init_features(this_arg, their_node_id);
6891 return nativeResponseValue;
6894 export interface LDKCustomMessageReader {
6895 read (message_type: number, buffer: number): bigint;
6899 export function LDKCustomMessageReader_new(impl: LDKCustomMessageReader): [bigint, number] {
6900 if(!isWasmInitialized) {
6901 throw new Error("initializeWasm() must be awaited first!");
6903 var new_obj_idx = js_objs.length;
6904 for (var i = 0; i < js_objs.length; i++) {
6905 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6907 js_objs[i] = new WeakRef(impl);
6908 return [wasm.TS_LDKCustomMessageReader_new(i), i];
6910 // LDKCResult_COption_TypeZDecodeErrorZ CustomMessageReader_read LDKCustomMessageReader *NONNULL_PTR this_arg, uint16_t message_type, struct LDKu8slice buffer
6912 export function CustomMessageReader_read(this_arg: bigint, message_type: number, buffer: number): bigint {
6913 if(!isWasmInitialized) {
6914 throw new Error("initializeWasm() must be awaited first!");
6916 const nativeResponseValue = wasm.TS_CustomMessageReader_read(this_arg, message_type, buffer);
6917 return nativeResponseValue;
6920 export interface LDKCustomMessageHandler {
6921 handle_custom_message (msg: bigint, sender_node_id: number): bigint;
6922 get_and_clear_pending_msg (): number;
6926 export function LDKCustomMessageHandler_new(impl: LDKCustomMessageHandler, CustomMessageReader: number): [bigint, number] {
6927 if(!isWasmInitialized) {
6928 throw new Error("initializeWasm() must be awaited first!");
6930 var new_obj_idx = js_objs.length;
6931 for (var i = 0; i < js_objs.length; i++) {
6932 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6934 js_objs[i] = new WeakRef(impl);
6935 return [wasm.TS_LDKCustomMessageHandler_new(i, CustomMessageReader), i];
6937 // LDKCResult_NoneLightningErrorZ CustomMessageHandler_handle_custom_message LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKType msg, struct LDKPublicKey sender_node_id
6939 export function CustomMessageHandler_handle_custom_message(this_arg: bigint, msg: bigint, sender_node_id: number): bigint {
6940 if(!isWasmInitialized) {
6941 throw new Error("initializeWasm() must be awaited first!");
6943 const nativeResponseValue = wasm.TS_CustomMessageHandler_handle_custom_message(this_arg, msg, sender_node_id);
6944 return nativeResponseValue;
6946 // LDKCVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler_get_and_clear_pending_msg LDKCustomMessageHandler *NONNULL_PTR this_arg
6948 export function CustomMessageHandler_get_and_clear_pending_msg(this_arg: bigint): number {
6949 if(!isWasmInitialized) {
6950 throw new Error("initializeWasm() must be awaited first!");
6952 const nativeResponseValue = wasm.TS_CustomMessageHandler_get_and_clear_pending_msg(this_arg);
6953 return nativeResponseValue;
6956 export interface LDKSocketDescriptor {
6957 send_data (data: number, resume_read: boolean): number;
6958 disconnect_socket (): void;
6959 eq (other_arg: bigint): boolean;
6964 export function LDKSocketDescriptor_new(impl: LDKSocketDescriptor): [bigint, number] {
6965 if(!isWasmInitialized) {
6966 throw new Error("initializeWasm() must be awaited first!");
6968 var new_obj_idx = js_objs.length;
6969 for (var i = 0; i < js_objs.length; i++) {
6970 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6972 js_objs[i] = new WeakRef(impl);
6973 return [wasm.TS_LDKSocketDescriptor_new(i), i];
6975 // uintptr_t SocketDescriptor_send_data LDKSocketDescriptor *NONNULL_PTR this_arg, struct LDKu8slice data, bool resume_read
6977 export function SocketDescriptor_send_data(this_arg: bigint, data: number, resume_read: boolean): number {
6978 if(!isWasmInitialized) {
6979 throw new Error("initializeWasm() must be awaited first!");
6981 const nativeResponseValue = wasm.TS_SocketDescriptor_send_data(this_arg, data, resume_read);
6982 return nativeResponseValue;
6984 // void SocketDescriptor_disconnect_socket LDKSocketDescriptor *NONNULL_PTR this_arg
6986 export function SocketDescriptor_disconnect_socket(this_arg: bigint): void {
6987 if(!isWasmInitialized) {
6988 throw new Error("initializeWasm() must be awaited first!");
6990 const nativeResponseValue = wasm.TS_SocketDescriptor_disconnect_socket(this_arg);
6991 // debug statements here
6993 // uint64_t SocketDescriptor_hash LDKSocketDescriptor *NONNULL_PTR this_arg
6995 export function SocketDescriptor_hash(this_arg: bigint): bigint {
6996 if(!isWasmInitialized) {
6997 throw new Error("initializeWasm() must be awaited first!");
6999 const nativeResponseValue = wasm.TS_SocketDescriptor_hash(this_arg);
7000 return nativeResponseValue;
7003 export class LDKEffectiveCapacity {
7004 protected constructor() {}
7007 export function LDKEffectiveCapacity_ty_from_ptr(ptr: bigint): number {
7008 if(!isWasmInitialized) {
7009 throw new Error("initializeWasm() must be awaited first!");
7011 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ty_from_ptr(ptr);
7012 return nativeResponseValue;
7015 export function LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr: bigint): bigint {
7016 if(!isWasmInitialized) {
7017 throw new Error("initializeWasm() must be awaited first!");
7019 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr);
7020 return nativeResponseValue;
7023 export function LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr: bigint): bigint {
7024 if(!isWasmInitialized) {
7025 throw new Error("initializeWasm() must be awaited first!");
7027 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr);
7028 return nativeResponseValue;
7031 export function LDKEffectiveCapacity_Total_get_capacity_msat(ptr: bigint): bigint {
7032 if(!isWasmInitialized) {
7033 throw new Error("initializeWasm() must be awaited first!");
7035 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_capacity_msat(ptr);
7036 return nativeResponseValue;
7039 export function LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr: bigint): bigint {
7040 if(!isWasmInitialized) {
7041 throw new Error("initializeWasm() must be awaited first!");
7043 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr);
7044 return nativeResponseValue;
7047 export class LDKDestination {
7048 protected constructor() {}
7051 export function LDKDestination_ty_from_ptr(ptr: bigint): number {
7052 if(!isWasmInitialized) {
7053 throw new Error("initializeWasm() must be awaited first!");
7055 const nativeResponseValue = wasm.TS_LDKDestination_ty_from_ptr(ptr);
7056 return nativeResponseValue;
7059 export function LDKDestination_Node_get_node(ptr: bigint): number {
7060 if(!isWasmInitialized) {
7061 throw new Error("initializeWasm() must be awaited first!");
7063 const nativeResponseValue = wasm.TS_LDKDestination_Node_get_node(ptr);
7064 return nativeResponseValue;
7067 export function LDKDestination_BlindedRoute_get_blinded_route(ptr: bigint): bigint {
7068 if(!isWasmInitialized) {
7069 throw new Error("initializeWasm() must be awaited first!");
7071 const nativeResponseValue = wasm.TS_LDKDestination_BlindedRoute_get_blinded_route(ptr);
7072 return nativeResponseValue;
7075 export class LDKFallback {
7076 protected constructor() {}
7079 export function LDKFallback_ty_from_ptr(ptr: bigint): number {
7080 if(!isWasmInitialized) {
7081 throw new Error("initializeWasm() must be awaited first!");
7083 const nativeResponseValue = wasm.TS_LDKFallback_ty_from_ptr(ptr);
7084 return nativeResponseValue;
7087 export function LDKFallback_SegWitProgram_get_version(ptr: bigint): number {
7088 if(!isWasmInitialized) {
7089 throw new Error("initializeWasm() must be awaited first!");
7091 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_version(ptr);
7092 return nativeResponseValue;
7095 export function LDKFallback_SegWitProgram_get_program(ptr: bigint): number {
7096 if(!isWasmInitialized) {
7097 throw new Error("initializeWasm() must be awaited first!");
7099 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_program(ptr);
7100 return nativeResponseValue;
7103 export function LDKFallback_PubKeyHash_get_pub_key_hash(ptr: bigint): number {
7104 if(!isWasmInitialized) {
7105 throw new Error("initializeWasm() must be awaited first!");
7107 const nativeResponseValue = wasm.TS_LDKFallback_PubKeyHash_get_pub_key_hash(ptr);
7108 return nativeResponseValue;
7111 export function LDKFallback_ScriptHash_get_script_hash(ptr: bigint): number {
7112 if(!isWasmInitialized) {
7113 throw new Error("initializeWasm() must be awaited first!");
7115 const nativeResponseValue = wasm.TS_LDKFallback_ScriptHash_get_script_hash(ptr);
7116 return nativeResponseValue;
7119 export interface LDKPayer {
7121 first_hops (): number;
7122 send_payment (route: bigint, payment_hash: number, payment_secret: number): bigint;
7123 send_spontaneous_payment (route: bigint, payment_preimage: number): bigint;
7124 retry_payment (route: bigint, payment_id: number): bigint;
7125 abandon_payment (payment_id: number): void;
7129 export function LDKPayer_new(impl: LDKPayer): [bigint, number] {
7130 if(!isWasmInitialized) {
7131 throw new Error("initializeWasm() must be awaited first!");
7133 var new_obj_idx = js_objs.length;
7134 for (var i = 0; i < js_objs.length; i++) {
7135 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7137 js_objs[i] = new WeakRef(impl);
7138 return [wasm.TS_LDKPayer_new(i), i];
7140 // LDKPublicKey Payer_node_id LDKPayer *NONNULL_PTR this_arg
7142 export function Payer_node_id(this_arg: bigint): number {
7143 if(!isWasmInitialized) {
7144 throw new Error("initializeWasm() must be awaited first!");
7146 const nativeResponseValue = wasm.TS_Payer_node_id(this_arg);
7147 return nativeResponseValue;
7149 // LDKCVec_ChannelDetailsZ Payer_first_hops LDKPayer *NONNULL_PTR this_arg
7151 export function Payer_first_hops(this_arg: bigint): number {
7152 if(!isWasmInitialized) {
7153 throw new Error("initializeWasm() must be awaited first!");
7155 const nativeResponseValue = wasm.TS_Payer_first_hops(this_arg);
7156 return nativeResponseValue;
7158 // LDKCResult_PaymentIdPaymentSendFailureZ Payer_send_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret
7160 export function Payer_send_payment(this_arg: bigint, route: bigint, payment_hash: number, payment_secret: number): bigint {
7161 if(!isWasmInitialized) {
7162 throw new Error("initializeWasm() must be awaited first!");
7164 const nativeResponseValue = wasm.TS_Payer_send_payment(this_arg, route, payment_hash, payment_secret);
7165 return nativeResponseValue;
7167 // LDKCResult_PaymentIdPaymentSendFailureZ Payer_send_spontaneous_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage
7169 export function Payer_send_spontaneous_payment(this_arg: bigint, route: bigint, payment_preimage: number): bigint {
7170 if(!isWasmInitialized) {
7171 throw new Error("initializeWasm() must be awaited first!");
7173 const nativeResponseValue = wasm.TS_Payer_send_spontaneous_payment(this_arg, route, payment_preimage);
7174 return nativeResponseValue;
7176 // LDKCResult_NonePaymentSendFailureZ Payer_retry_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_id
7178 export function Payer_retry_payment(this_arg: bigint, route: bigint, payment_id: number): bigint {
7179 if(!isWasmInitialized) {
7180 throw new Error("initializeWasm() must be awaited first!");
7182 const nativeResponseValue = wasm.TS_Payer_retry_payment(this_arg, route, payment_id);
7183 return nativeResponseValue;
7185 // void Payer_abandon_payment LDKPayer *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id
7187 export function Payer_abandon_payment(this_arg: bigint, payment_id: number): void {
7188 if(!isWasmInitialized) {
7189 throw new Error("initializeWasm() must be awaited first!");
7191 const nativeResponseValue = wasm.TS_Payer_abandon_payment(this_arg, payment_id);
7192 // debug statements here
7195 export interface LDKRouter {
7196 find_route (payer: number, route_params: bigint, payment_hash: number, first_hops: number, inflight_htlcs: bigint): bigint;
7197 notify_payment_path_failed (path: number, short_channel_id: bigint): void;
7198 notify_payment_path_successful (path: number): void;
7199 notify_payment_probe_successful (path: number): void;
7200 notify_payment_probe_failed (path: number, short_channel_id: bigint): void;
7204 export function LDKRouter_new(impl: LDKRouter): [bigint, number] {
7205 if(!isWasmInitialized) {
7206 throw new Error("initializeWasm() must be awaited first!");
7208 var new_obj_idx = js_objs.length;
7209 for (var i = 0; i < js_objs.length; i++) {
7210 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7212 js_objs[i] = new WeakRef(impl);
7213 return [wasm.TS_LDKRouter_new(i), i];
7215 // 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, struct LDKInFlightHtlcs inflight_htlcs
7217 export function Router_find_route(this_arg: bigint, payer: number, route_params: bigint, payment_hash: number, first_hops: number, inflight_htlcs: bigint): bigint {
7218 if(!isWasmInitialized) {
7219 throw new Error("initializeWasm() must be awaited first!");
7221 const nativeResponseValue = wasm.TS_Router_find_route(this_arg, payer, route_params, payment_hash, first_hops, inflight_htlcs);
7222 return nativeResponseValue;
7224 // void Router_notify_payment_path_failed LDKRouter *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
7226 export function Router_notify_payment_path_failed(this_arg: bigint, path: number, short_channel_id: bigint): void {
7227 if(!isWasmInitialized) {
7228 throw new Error("initializeWasm() must be awaited first!");
7230 const nativeResponseValue = wasm.TS_Router_notify_payment_path_failed(this_arg, path, short_channel_id);
7231 // debug statements here
7233 // void Router_notify_payment_path_successful LDKRouter *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
7235 export function Router_notify_payment_path_successful(this_arg: bigint, path: number): void {
7236 if(!isWasmInitialized) {
7237 throw new Error("initializeWasm() must be awaited first!");
7239 const nativeResponseValue = wasm.TS_Router_notify_payment_path_successful(this_arg, path);
7240 // debug statements here
7242 // void Router_notify_payment_probe_successful LDKRouter *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
7244 export function Router_notify_payment_probe_successful(this_arg: bigint, path: number): void {
7245 if(!isWasmInitialized) {
7246 throw new Error("initializeWasm() must be awaited first!");
7248 const nativeResponseValue = wasm.TS_Router_notify_payment_probe_successful(this_arg, path);
7249 // debug statements here
7251 // void Router_notify_payment_probe_failed LDKRouter *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
7253 export function Router_notify_payment_probe_failed(this_arg: bigint, path: number, short_channel_id: bigint): void {
7254 if(!isWasmInitialized) {
7255 throw new Error("initializeWasm() must be awaited first!");
7257 const nativeResponseValue = wasm.TS_Router_notify_payment_probe_failed(this_arg, path, short_channel_id);
7258 // debug statements here
7261 export class LDKRetry {
7262 protected constructor() {}
7265 export function LDKRetry_ty_from_ptr(ptr: bigint): number {
7266 if(!isWasmInitialized) {
7267 throw new Error("initializeWasm() must be awaited first!");
7269 const nativeResponseValue = wasm.TS_LDKRetry_ty_from_ptr(ptr);
7270 return nativeResponseValue;
7273 export function LDKRetry_Attempts_get_attempts(ptr: bigint): number {
7274 if(!isWasmInitialized) {
7275 throw new Error("initializeWasm() must be awaited first!");
7277 const nativeResponseValue = wasm.TS_LDKRetry_Attempts_get_attempts(ptr);
7278 return nativeResponseValue;
7280 // struct LDKStr _ldk_get_compiled_version(void);
7282 export function _ldk_get_compiled_version(): number {
7283 if(!isWasmInitialized) {
7284 throw new Error("initializeWasm() must be awaited first!");
7286 const nativeResponseValue = wasm.TS__ldk_get_compiled_version();
7287 return nativeResponseValue;
7289 // struct LDKStr _ldk_c_bindings_get_compiled_version(void);
7291 export function _ldk_c_bindings_get_compiled_version(): number {
7292 if(!isWasmInitialized) {
7293 throw new Error("initializeWasm() must be awaited first!");
7295 const nativeResponseValue = wasm.TS__ldk_c_bindings_get_compiled_version();
7296 return nativeResponseValue;
7298 // struct LDKBigEndianScalar BigEndianScalar_new(struct LDKThirtyTwoBytes big_endian_bytes);
7300 export function BigEndianScalar_new(big_endian_bytes: number): bigint {
7301 if(!isWasmInitialized) {
7302 throw new Error("initializeWasm() must be awaited first!");
7304 const nativeResponseValue = wasm.TS_BigEndianScalar_new(big_endian_bytes);
7305 return nativeResponseValue;
7307 // uint64_t Bech32Error_clone_ptr(LDKBech32Error *NONNULL_PTR arg);
7309 export function Bech32Error_clone_ptr(arg: bigint): bigint {
7310 if(!isWasmInitialized) {
7311 throw new Error("initializeWasm() must be awaited first!");
7313 const nativeResponseValue = wasm.TS_Bech32Error_clone_ptr(arg);
7314 return nativeResponseValue;
7316 // struct LDKBech32Error Bech32Error_clone(const struct LDKBech32Error *NONNULL_PTR orig);
7318 export function Bech32Error_clone(orig: bigint): bigint {
7319 if(!isWasmInitialized) {
7320 throw new Error("initializeWasm() must be awaited first!");
7322 const nativeResponseValue = wasm.TS_Bech32Error_clone(orig);
7323 return nativeResponseValue;
7325 // void Bech32Error_free(struct LDKBech32Error o);
7327 export function Bech32Error_free(o: bigint): void {
7328 if(!isWasmInitialized) {
7329 throw new Error("initializeWasm() must be awaited first!");
7331 const nativeResponseValue = wasm.TS_Bech32Error_free(o);
7332 // debug statements here
7334 // void Transaction_free(struct LDKTransaction _res);
7336 export function Transaction_free(_res: number): void {
7337 if(!isWasmInitialized) {
7338 throw new Error("initializeWasm() must be awaited first!");
7340 const nativeResponseValue = wasm.TS_Transaction_free(_res);
7341 // debug statements here
7343 // struct LDKTxOut TxOut_new(struct LDKCVec_u8Z script_pubkey, uint64_t value);
7345 export function TxOut_new(script_pubkey: number, value: bigint): bigint {
7346 if(!isWasmInitialized) {
7347 throw new Error("initializeWasm() must be awaited first!");
7349 const nativeResponseValue = wasm.TS_TxOut_new(script_pubkey, value);
7350 return nativeResponseValue;
7352 // void TxOut_free(struct LDKTxOut _res);
7354 export function TxOut_free(_res: bigint): void {
7355 if(!isWasmInitialized) {
7356 throw new Error("initializeWasm() must be awaited first!");
7358 const nativeResponseValue = wasm.TS_TxOut_free(_res);
7359 // debug statements here
7361 // uint64_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg);
7363 export function TxOut_clone_ptr(arg: bigint): bigint {
7364 if(!isWasmInitialized) {
7365 throw new Error("initializeWasm() must be awaited first!");
7367 const nativeResponseValue = wasm.TS_TxOut_clone_ptr(arg);
7368 return nativeResponseValue;
7370 // struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
7372 export function TxOut_clone(orig: bigint): bigint {
7373 if(!isWasmInitialized) {
7374 throw new Error("initializeWasm() must be awaited first!");
7376 const nativeResponseValue = wasm.TS_TxOut_clone(orig);
7377 return nativeResponseValue;
7379 // void Str_free(struct LDKStr _res);
7381 export function Str_free(_res: number): void {
7382 if(!isWasmInitialized) {
7383 throw new Error("initializeWasm() must be awaited first!");
7385 const nativeResponseValue = wasm.TS_Str_free(_res);
7386 // debug statements here
7388 // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
7390 export function CVec_PublicKeyZ_free(_res: number): void {
7391 if(!isWasmInitialized) {
7392 throw new Error("initializeWasm() must be awaited first!");
7394 const nativeResponseValue = wasm.TS_CVec_PublicKeyZ_free(_res);
7395 // debug statements here
7397 // struct LDKCResult_BlindedRouteNoneZ CResult_BlindedRouteNoneZ_ok(struct LDKBlindedRoute o);
7399 export function CResult_BlindedRouteNoneZ_ok(o: bigint): bigint {
7400 if(!isWasmInitialized) {
7401 throw new Error("initializeWasm() must be awaited first!");
7403 const nativeResponseValue = wasm.TS_CResult_BlindedRouteNoneZ_ok(o);
7404 return nativeResponseValue;
7406 // struct LDKCResult_BlindedRouteNoneZ CResult_BlindedRouteNoneZ_err(void);
7408 export function CResult_BlindedRouteNoneZ_err(): bigint {
7409 if(!isWasmInitialized) {
7410 throw new Error("initializeWasm() must be awaited first!");
7412 const nativeResponseValue = wasm.TS_CResult_BlindedRouteNoneZ_err();
7413 return nativeResponseValue;
7415 // bool CResult_BlindedRouteNoneZ_is_ok(const struct LDKCResult_BlindedRouteNoneZ *NONNULL_PTR o);
7417 export function CResult_BlindedRouteNoneZ_is_ok(o: bigint): boolean {
7418 if(!isWasmInitialized) {
7419 throw new Error("initializeWasm() must be awaited first!");
7421 const nativeResponseValue = wasm.TS_CResult_BlindedRouteNoneZ_is_ok(o);
7422 return nativeResponseValue;
7424 // void CResult_BlindedRouteNoneZ_free(struct LDKCResult_BlindedRouteNoneZ _res);
7426 export function CResult_BlindedRouteNoneZ_free(_res: bigint): void {
7427 if(!isWasmInitialized) {
7428 throw new Error("initializeWasm() must be awaited first!");
7430 const nativeResponseValue = wasm.TS_CResult_BlindedRouteNoneZ_free(_res);
7431 // debug statements here
7433 // struct LDKCResult_BlindedRouteDecodeErrorZ CResult_BlindedRouteDecodeErrorZ_ok(struct LDKBlindedRoute o);
7435 export function CResult_BlindedRouteDecodeErrorZ_ok(o: bigint): bigint {
7436 if(!isWasmInitialized) {
7437 throw new Error("initializeWasm() must be awaited first!");
7439 const nativeResponseValue = wasm.TS_CResult_BlindedRouteDecodeErrorZ_ok(o);
7440 return nativeResponseValue;
7442 // struct LDKCResult_BlindedRouteDecodeErrorZ CResult_BlindedRouteDecodeErrorZ_err(struct LDKDecodeError e);
7444 export function CResult_BlindedRouteDecodeErrorZ_err(e: bigint): bigint {
7445 if(!isWasmInitialized) {
7446 throw new Error("initializeWasm() must be awaited first!");
7448 const nativeResponseValue = wasm.TS_CResult_BlindedRouteDecodeErrorZ_err(e);
7449 return nativeResponseValue;
7451 // bool CResult_BlindedRouteDecodeErrorZ_is_ok(const struct LDKCResult_BlindedRouteDecodeErrorZ *NONNULL_PTR o);
7453 export function CResult_BlindedRouteDecodeErrorZ_is_ok(o: bigint): boolean {
7454 if(!isWasmInitialized) {
7455 throw new Error("initializeWasm() must be awaited first!");
7457 const nativeResponseValue = wasm.TS_CResult_BlindedRouteDecodeErrorZ_is_ok(o);
7458 return nativeResponseValue;
7460 // void CResult_BlindedRouteDecodeErrorZ_free(struct LDKCResult_BlindedRouteDecodeErrorZ _res);
7462 export function CResult_BlindedRouteDecodeErrorZ_free(_res: bigint): void {
7463 if(!isWasmInitialized) {
7464 throw new Error("initializeWasm() must be awaited first!");
7466 const nativeResponseValue = wasm.TS_CResult_BlindedRouteDecodeErrorZ_free(_res);
7467 // debug statements here
7469 // struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_ok(struct LDKBlindedHop o);
7471 export function CResult_BlindedHopDecodeErrorZ_ok(o: bigint): bigint {
7472 if(!isWasmInitialized) {
7473 throw new Error("initializeWasm() must be awaited first!");
7475 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_ok(o);
7476 return nativeResponseValue;
7478 // struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_err(struct LDKDecodeError e);
7480 export function CResult_BlindedHopDecodeErrorZ_err(e: bigint): bigint {
7481 if(!isWasmInitialized) {
7482 throw new Error("initializeWasm() must be awaited first!");
7484 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_err(e);
7485 return nativeResponseValue;
7487 // bool CResult_BlindedHopDecodeErrorZ_is_ok(const struct LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR o);
7489 export function CResult_BlindedHopDecodeErrorZ_is_ok(o: bigint): boolean {
7490 if(!isWasmInitialized) {
7491 throw new Error("initializeWasm() must be awaited first!");
7493 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_is_ok(o);
7494 return nativeResponseValue;
7496 // void CResult_BlindedHopDecodeErrorZ_free(struct LDKCResult_BlindedHopDecodeErrorZ _res);
7498 export function CResult_BlindedHopDecodeErrorZ_free(_res: bigint): void {
7499 if(!isWasmInitialized) {
7500 throw new Error("initializeWasm() must be awaited first!");
7502 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_free(_res);
7503 // debug statements here
7505 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_ok(void);
7507 export function CResult_NoneNoneZ_ok(): bigint {
7508 if(!isWasmInitialized) {
7509 throw new Error("initializeWasm() must be awaited first!");
7511 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_ok();
7512 return nativeResponseValue;
7514 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_err(void);
7516 export function CResult_NoneNoneZ_err(): bigint {
7517 if(!isWasmInitialized) {
7518 throw new Error("initializeWasm() must be awaited first!");
7520 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_err();
7521 return nativeResponseValue;
7523 // bool CResult_NoneNoneZ_is_ok(const struct LDKCResult_NoneNoneZ *NONNULL_PTR o);
7525 export function CResult_NoneNoneZ_is_ok(o: bigint): boolean {
7526 if(!isWasmInitialized) {
7527 throw new Error("initializeWasm() must be awaited first!");
7529 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_is_ok(o);
7530 return nativeResponseValue;
7532 // void CResult_NoneNoneZ_free(struct LDKCResult_NoneNoneZ _res);
7534 export function CResult_NoneNoneZ_free(_res: bigint): void {
7535 if(!isWasmInitialized) {
7536 throw new Error("initializeWasm() must be awaited first!");
7538 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_free(_res);
7539 // debug statements here
7541 // uint64_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg);
7543 export function CResult_NoneNoneZ_clone_ptr(arg: bigint): bigint {
7544 if(!isWasmInitialized) {
7545 throw new Error("initializeWasm() must be awaited first!");
7547 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone_ptr(arg);
7548 return nativeResponseValue;
7550 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_clone(const struct LDKCResult_NoneNoneZ *NONNULL_PTR orig);
7552 export function CResult_NoneNoneZ_clone(orig: bigint): bigint {
7553 if(!isWasmInitialized) {
7554 throw new Error("initializeWasm() must be awaited first!");
7556 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone(orig);
7557 return nativeResponseValue;
7559 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(struct LDKCounterpartyCommitmentSecrets o);
7561 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o: bigint): bigint {
7562 if(!isWasmInitialized) {
7563 throw new Error("initializeWasm() must be awaited first!");
7565 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o);
7566 return nativeResponseValue;
7568 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(struct LDKDecodeError e);
7570 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e: bigint): bigint {
7571 if(!isWasmInitialized) {
7572 throw new Error("initializeWasm() must be awaited first!");
7574 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e);
7575 return nativeResponseValue;
7577 // bool CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR o);
7579 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o: bigint): boolean {
7580 if(!isWasmInitialized) {
7581 throw new Error("initializeWasm() must be awaited first!");
7583 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o);
7584 return nativeResponseValue;
7586 // void CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ _res);
7588 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res: bigint): void {
7589 if(!isWasmInitialized) {
7590 throw new Error("initializeWasm() must be awaited first!");
7592 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res);
7593 // debug statements here
7595 // uint64_t CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR arg);
7597 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
7598 if(!isWasmInitialized) {
7599 throw new Error("initializeWasm() must be awaited first!");
7601 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg);
7602 return nativeResponseValue;
7604 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR orig);
7606 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig: bigint): bigint {
7607 if(!isWasmInitialized) {
7608 throw new Error("initializeWasm() must be awaited first!");
7610 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig);
7611 return nativeResponseValue;
7613 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_ok(struct LDKSecretKey o);
7615 export function CResult_SecretKeyErrorZ_ok(o: number): bigint {
7616 if(!isWasmInitialized) {
7617 throw new Error("initializeWasm() must be awaited first!");
7619 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_ok(o);
7620 return nativeResponseValue;
7622 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_err(enum LDKSecp256k1Error e);
7624 export function CResult_SecretKeyErrorZ_err(e: Secp256k1Error): bigint {
7625 if(!isWasmInitialized) {
7626 throw new Error("initializeWasm() must be awaited first!");
7628 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_err(e);
7629 return nativeResponseValue;
7631 // bool CResult_SecretKeyErrorZ_is_ok(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR o);
7633 export function CResult_SecretKeyErrorZ_is_ok(o: bigint): boolean {
7634 if(!isWasmInitialized) {
7635 throw new Error("initializeWasm() must be awaited first!");
7637 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_is_ok(o);
7638 return nativeResponseValue;
7640 // void CResult_SecretKeyErrorZ_free(struct LDKCResult_SecretKeyErrorZ _res);
7642 export function CResult_SecretKeyErrorZ_free(_res: bigint): void {
7643 if(!isWasmInitialized) {
7644 throw new Error("initializeWasm() must be awaited first!");
7646 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_free(_res);
7647 // debug statements here
7649 // uint64_t CResult_SecretKeyErrorZ_clone_ptr(LDKCResult_SecretKeyErrorZ *NONNULL_PTR arg);
7651 export function CResult_SecretKeyErrorZ_clone_ptr(arg: bigint): bigint {
7652 if(!isWasmInitialized) {
7653 throw new Error("initializeWasm() must be awaited first!");
7655 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_clone_ptr(arg);
7656 return nativeResponseValue;
7658 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_clone(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR orig);
7660 export function CResult_SecretKeyErrorZ_clone(orig: bigint): bigint {
7661 if(!isWasmInitialized) {
7662 throw new Error("initializeWasm() must be awaited first!");
7664 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_clone(orig);
7665 return nativeResponseValue;
7667 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_ok(struct LDKPublicKey o);
7669 export function CResult_PublicKeyErrorZ_ok(o: number): bigint {
7670 if(!isWasmInitialized) {
7671 throw new Error("initializeWasm() must be awaited first!");
7673 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_ok(o);
7674 return nativeResponseValue;
7676 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_err(enum LDKSecp256k1Error e);
7678 export function CResult_PublicKeyErrorZ_err(e: Secp256k1Error): bigint {
7679 if(!isWasmInitialized) {
7680 throw new Error("initializeWasm() must be awaited first!");
7682 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_err(e);
7683 return nativeResponseValue;
7685 // bool CResult_PublicKeyErrorZ_is_ok(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR o);
7687 export function CResult_PublicKeyErrorZ_is_ok(o: bigint): boolean {
7688 if(!isWasmInitialized) {
7689 throw new Error("initializeWasm() must be awaited first!");
7691 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_is_ok(o);
7692 return nativeResponseValue;
7694 // void CResult_PublicKeyErrorZ_free(struct LDKCResult_PublicKeyErrorZ _res);
7696 export function CResult_PublicKeyErrorZ_free(_res: bigint): void {
7697 if(!isWasmInitialized) {
7698 throw new Error("initializeWasm() must be awaited first!");
7700 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_free(_res);
7701 // debug statements here
7703 // uint64_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg);
7705 export function CResult_PublicKeyErrorZ_clone_ptr(arg: bigint): bigint {
7706 if(!isWasmInitialized) {
7707 throw new Error("initializeWasm() must be awaited first!");
7709 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone_ptr(arg);
7710 return nativeResponseValue;
7712 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_clone(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR orig);
7714 export function CResult_PublicKeyErrorZ_clone(orig: bigint): bigint {
7715 if(!isWasmInitialized) {
7716 throw new Error("initializeWasm() must be awaited first!");
7718 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone(orig);
7719 return nativeResponseValue;
7721 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_ok(struct LDKTxCreationKeys o);
7723 export function CResult_TxCreationKeysDecodeErrorZ_ok(o: bigint): bigint {
7724 if(!isWasmInitialized) {
7725 throw new Error("initializeWasm() must be awaited first!");
7727 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_ok(o);
7728 return nativeResponseValue;
7730 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_err(struct LDKDecodeError e);
7732 export function CResult_TxCreationKeysDecodeErrorZ_err(e: bigint): bigint {
7733 if(!isWasmInitialized) {
7734 throw new Error("initializeWasm() must be awaited first!");
7736 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_err(e);
7737 return nativeResponseValue;
7739 // bool CResult_TxCreationKeysDecodeErrorZ_is_ok(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR o);
7741 export function CResult_TxCreationKeysDecodeErrorZ_is_ok(o: bigint): boolean {
7742 if(!isWasmInitialized) {
7743 throw new Error("initializeWasm() must be awaited first!");
7745 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(o);
7746 return nativeResponseValue;
7748 // void CResult_TxCreationKeysDecodeErrorZ_free(struct LDKCResult_TxCreationKeysDecodeErrorZ _res);
7750 export function CResult_TxCreationKeysDecodeErrorZ_free(_res: bigint): void {
7751 if(!isWasmInitialized) {
7752 throw new Error("initializeWasm() must be awaited first!");
7754 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_free(_res);
7755 // debug statements here
7757 // uint64_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg);
7759 export function CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg: bigint): bigint {
7760 if(!isWasmInitialized) {
7761 throw new Error("initializeWasm() must be awaited first!");
7763 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg);
7764 return nativeResponseValue;
7766 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_clone(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR orig);
7768 export function CResult_TxCreationKeysDecodeErrorZ_clone(orig: bigint): bigint {
7769 if(!isWasmInitialized) {
7770 throw new Error("initializeWasm() must be awaited first!");
7772 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone(orig);
7773 return nativeResponseValue;
7775 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_ok(struct LDKChannelPublicKeys o);
7777 export function CResult_ChannelPublicKeysDecodeErrorZ_ok(o: bigint): bigint {
7778 if(!isWasmInitialized) {
7779 throw new Error("initializeWasm() must be awaited first!");
7781 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_ok(o);
7782 return nativeResponseValue;
7784 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_err(struct LDKDecodeError e);
7786 export function CResult_ChannelPublicKeysDecodeErrorZ_err(e: bigint): bigint {
7787 if(!isWasmInitialized) {
7788 throw new Error("initializeWasm() must be awaited first!");
7790 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_err(e);
7791 return nativeResponseValue;
7793 // bool CResult_ChannelPublicKeysDecodeErrorZ_is_ok(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR o);
7795 export function CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o: bigint): boolean {
7796 if(!isWasmInitialized) {
7797 throw new Error("initializeWasm() must be awaited first!");
7799 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o);
7800 return nativeResponseValue;
7802 // void CResult_ChannelPublicKeysDecodeErrorZ_free(struct LDKCResult_ChannelPublicKeysDecodeErrorZ _res);
7804 export function CResult_ChannelPublicKeysDecodeErrorZ_free(_res: bigint): void {
7805 if(!isWasmInitialized) {
7806 throw new Error("initializeWasm() must be awaited first!");
7808 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_free(_res);
7809 // debug statements here
7811 // uint64_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg);
7813 export function CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg: bigint): bigint {
7814 if(!isWasmInitialized) {
7815 throw new Error("initializeWasm() must be awaited first!");
7817 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg);
7818 return nativeResponseValue;
7820 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_clone(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR orig);
7822 export function CResult_ChannelPublicKeysDecodeErrorZ_clone(orig: bigint): bigint {
7823 if(!isWasmInitialized) {
7824 throw new Error("initializeWasm() must be awaited first!");
7826 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(orig);
7827 return nativeResponseValue;
7829 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_ok(struct LDKTxCreationKeys o);
7831 export function CResult_TxCreationKeysErrorZ_ok(o: bigint): bigint {
7832 if(!isWasmInitialized) {
7833 throw new Error("initializeWasm() must be awaited first!");
7835 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_ok(o);
7836 return nativeResponseValue;
7838 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_err(enum LDKSecp256k1Error e);
7840 export function CResult_TxCreationKeysErrorZ_err(e: Secp256k1Error): bigint {
7841 if(!isWasmInitialized) {
7842 throw new Error("initializeWasm() must be awaited first!");
7844 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_err(e);
7845 return nativeResponseValue;
7847 // bool CResult_TxCreationKeysErrorZ_is_ok(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR o);
7849 export function CResult_TxCreationKeysErrorZ_is_ok(o: bigint): boolean {
7850 if(!isWasmInitialized) {
7851 throw new Error("initializeWasm() must be awaited first!");
7853 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_is_ok(o);
7854 return nativeResponseValue;
7856 // void CResult_TxCreationKeysErrorZ_free(struct LDKCResult_TxCreationKeysErrorZ _res);
7858 export function CResult_TxCreationKeysErrorZ_free(_res: bigint): void {
7859 if(!isWasmInitialized) {
7860 throw new Error("initializeWasm() must be awaited first!");
7862 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_free(_res);
7863 // debug statements here
7865 // uint64_t CResult_TxCreationKeysErrorZ_clone_ptr(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR arg);
7867 export function CResult_TxCreationKeysErrorZ_clone_ptr(arg: bigint): bigint {
7868 if(!isWasmInitialized) {
7869 throw new Error("initializeWasm() must be awaited first!");
7871 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone_ptr(arg);
7872 return nativeResponseValue;
7874 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_clone(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR orig);
7876 export function CResult_TxCreationKeysErrorZ_clone(orig: bigint): bigint {
7877 if(!isWasmInitialized) {
7878 throw new Error("initializeWasm() must be awaited first!");
7880 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone(orig);
7881 return nativeResponseValue;
7883 // struct LDKCOption_u32Z COption_u32Z_some(uint32_t o);
7885 export function COption_u32Z_some(o: number): bigint {
7886 if(!isWasmInitialized) {
7887 throw new Error("initializeWasm() must be awaited first!");
7889 const nativeResponseValue = wasm.TS_COption_u32Z_some(o);
7890 return nativeResponseValue;
7892 // struct LDKCOption_u32Z COption_u32Z_none(void);
7894 export function COption_u32Z_none(): bigint {
7895 if(!isWasmInitialized) {
7896 throw new Error("initializeWasm() must be awaited first!");
7898 const nativeResponseValue = wasm.TS_COption_u32Z_none();
7899 return nativeResponseValue;
7901 // void COption_u32Z_free(struct LDKCOption_u32Z _res);
7903 export function COption_u32Z_free(_res: bigint): void {
7904 if(!isWasmInitialized) {
7905 throw new Error("initializeWasm() must be awaited first!");
7907 const nativeResponseValue = wasm.TS_COption_u32Z_free(_res);
7908 // debug statements here
7910 // uint64_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg);
7912 export function COption_u32Z_clone_ptr(arg: bigint): bigint {
7913 if(!isWasmInitialized) {
7914 throw new Error("initializeWasm() must be awaited first!");
7916 const nativeResponseValue = wasm.TS_COption_u32Z_clone_ptr(arg);
7917 return nativeResponseValue;
7919 // struct LDKCOption_u32Z COption_u32Z_clone(const struct LDKCOption_u32Z *NONNULL_PTR orig);
7921 export function COption_u32Z_clone(orig: bigint): bigint {
7922 if(!isWasmInitialized) {
7923 throw new Error("initializeWasm() must be awaited first!");
7925 const nativeResponseValue = wasm.TS_COption_u32Z_clone(orig);
7926 return nativeResponseValue;
7928 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(struct LDKHTLCOutputInCommitment o);
7930 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o: bigint): bigint {
7931 if(!isWasmInitialized) {
7932 throw new Error("initializeWasm() must be awaited first!");
7934 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o);
7935 return nativeResponseValue;
7937 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_err(struct LDKDecodeError e);
7939 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e: bigint): bigint {
7940 if(!isWasmInitialized) {
7941 throw new Error("initializeWasm() must be awaited first!");
7943 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e);
7944 return nativeResponseValue;
7946 // bool CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR o);
7948 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o: bigint): boolean {
7949 if(!isWasmInitialized) {
7950 throw new Error("initializeWasm() must be awaited first!");
7952 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o);
7953 return nativeResponseValue;
7955 // void CResult_HTLCOutputInCommitmentDecodeErrorZ_free(struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res);
7957 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res: bigint): void {
7958 if(!isWasmInitialized) {
7959 throw new Error("initializeWasm() must be awaited first!");
7961 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res);
7962 // debug statements here
7964 // uint64_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg);
7966 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg: bigint): bigint {
7967 if(!isWasmInitialized) {
7968 throw new Error("initializeWasm() must be awaited first!");
7970 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg);
7971 return nativeResponseValue;
7973 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR orig);
7975 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig: bigint): bigint {
7976 if(!isWasmInitialized) {
7977 throw new Error("initializeWasm() must be awaited first!");
7979 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig);
7980 return nativeResponseValue;
7982 // enum LDKCOption_NoneZ COption_NoneZ_some(void);
7984 export function COption_NoneZ_some(): COption_NoneZ {
7985 if(!isWasmInitialized) {
7986 throw new Error("initializeWasm() must be awaited first!");
7988 const nativeResponseValue = wasm.TS_COption_NoneZ_some();
7989 return nativeResponseValue;
7991 // enum LDKCOption_NoneZ COption_NoneZ_none(void);
7993 export function COption_NoneZ_none(): COption_NoneZ {
7994 if(!isWasmInitialized) {
7995 throw new Error("initializeWasm() must be awaited first!");
7997 const nativeResponseValue = wasm.TS_COption_NoneZ_none();
7998 return nativeResponseValue;
8000 // void COption_NoneZ_free(enum LDKCOption_NoneZ _res);
8002 export function COption_NoneZ_free(_res: COption_NoneZ): void {
8003 if(!isWasmInitialized) {
8004 throw new Error("initializeWasm() must be awaited first!");
8006 const nativeResponseValue = wasm.TS_COption_NoneZ_free(_res);
8007 // debug statements here
8009 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(struct LDKCounterpartyChannelTransactionParameters o);
8011 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o: bigint): bigint {
8012 if(!isWasmInitialized) {
8013 throw new Error("initializeWasm() must be awaited first!");
8015 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o);
8016 return nativeResponseValue;
8018 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
8020 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e: bigint): bigint {
8021 if(!isWasmInitialized) {
8022 throw new Error("initializeWasm() must be awaited first!");
8024 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e);
8025 return nativeResponseValue;
8027 // bool CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
8029 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o: bigint): boolean {
8030 if(!isWasmInitialized) {
8031 throw new Error("initializeWasm() must be awaited first!");
8033 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o);
8034 return nativeResponseValue;
8036 // void CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res);
8038 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res: bigint): void {
8039 if(!isWasmInitialized) {
8040 throw new Error("initializeWasm() must be awaited first!");
8042 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res);
8043 // debug statements here
8045 // uint64_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
8047 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8048 if(!isWasmInitialized) {
8049 throw new Error("initializeWasm() must be awaited first!");
8051 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
8052 return nativeResponseValue;
8054 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
8056 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig: bigint): bigint {
8057 if(!isWasmInitialized) {
8058 throw new Error("initializeWasm() must be awaited first!");
8060 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig);
8061 return nativeResponseValue;
8063 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_ok(struct LDKChannelTransactionParameters o);
8065 export function CResult_ChannelTransactionParametersDecodeErrorZ_ok(o: bigint): bigint {
8066 if(!isWasmInitialized) {
8067 throw new Error("initializeWasm() must be awaited first!");
8069 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok(o);
8070 return nativeResponseValue;
8072 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
8074 export function CResult_ChannelTransactionParametersDecodeErrorZ_err(e: bigint): bigint {
8075 if(!isWasmInitialized) {
8076 throw new Error("initializeWasm() must be awaited first!");
8078 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_err(e);
8079 return nativeResponseValue;
8081 // bool CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
8083 export function CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o: bigint): boolean {
8084 if(!isWasmInitialized) {
8085 throw new Error("initializeWasm() must be awaited first!");
8087 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o);
8088 return nativeResponseValue;
8090 // void CResult_ChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_ChannelTransactionParametersDecodeErrorZ _res);
8092 export function CResult_ChannelTransactionParametersDecodeErrorZ_free(_res: bigint): void {
8093 if(!isWasmInitialized) {
8094 throw new Error("initializeWasm() must be awaited first!");
8096 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(_res);
8097 // debug statements here
8099 // uint64_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
8101 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8102 if(!isWasmInitialized) {
8103 throw new Error("initializeWasm() must be awaited first!");
8105 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
8106 return nativeResponseValue;
8108 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
8110 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig: bigint): bigint {
8111 if(!isWasmInitialized) {
8112 throw new Error("initializeWasm() must be awaited first!");
8114 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig);
8115 return nativeResponseValue;
8117 // void CVec_SignatureZ_free(struct LDKCVec_SignatureZ _res);
8119 export function CVec_SignatureZ_free(_res: number): void {
8120 if(!isWasmInitialized) {
8121 throw new Error("initializeWasm() must be awaited first!");
8123 const nativeResponseValue = wasm.TS_CVec_SignatureZ_free(_res);
8124 // debug statements here
8126 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_ok(struct LDKHolderCommitmentTransaction o);
8128 export function CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
8129 if(!isWasmInitialized) {
8130 throw new Error("initializeWasm() must be awaited first!");
8132 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o);
8133 return nativeResponseValue;
8135 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
8137 export function CResult_HolderCommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
8138 if(!isWasmInitialized) {
8139 throw new Error("initializeWasm() must be awaited first!");
8141 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err(e);
8142 return nativeResponseValue;
8144 // bool CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
8146 export function CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
8147 if(!isWasmInitialized) {
8148 throw new Error("initializeWasm() must be awaited first!");
8150 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o);
8151 return nativeResponseValue;
8153 // void CResult_HolderCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res);
8155 export function CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
8156 if(!isWasmInitialized) {
8157 throw new Error("initializeWasm() must be awaited first!");
8159 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res);
8160 // debug statements here
8162 // uint64_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
8164 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8165 if(!isWasmInitialized) {
8166 throw new Error("initializeWasm() must be awaited first!");
8168 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
8169 return nativeResponseValue;
8171 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
8173 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
8174 if(!isWasmInitialized) {
8175 throw new Error("initializeWasm() must be awaited first!");
8177 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig);
8178 return nativeResponseValue;
8180 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(struct LDKBuiltCommitmentTransaction o);
8182 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
8183 if(!isWasmInitialized) {
8184 throw new Error("initializeWasm() must be awaited first!");
8186 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o);
8187 return nativeResponseValue;
8189 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
8191 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
8192 if(!isWasmInitialized) {
8193 throw new Error("initializeWasm() must be awaited first!");
8195 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e);
8196 return nativeResponseValue;
8198 // bool CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
8200 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
8201 if(!isWasmInitialized) {
8202 throw new Error("initializeWasm() must be awaited first!");
8204 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o);
8205 return nativeResponseValue;
8207 // void CResult_BuiltCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res);
8209 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
8210 if(!isWasmInitialized) {
8211 throw new Error("initializeWasm() must be awaited first!");
8213 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res);
8214 // debug statements here
8216 // uint64_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
8218 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8219 if(!isWasmInitialized) {
8220 throw new Error("initializeWasm() must be awaited first!");
8222 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
8223 return nativeResponseValue;
8225 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
8227 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
8228 if(!isWasmInitialized) {
8229 throw new Error("initializeWasm() must be awaited first!");
8231 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig);
8232 return nativeResponseValue;
8234 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_ok(struct LDKTrustedClosingTransaction o);
8236 export function CResult_TrustedClosingTransactionNoneZ_ok(o: bigint): bigint {
8237 if(!isWasmInitialized) {
8238 throw new Error("initializeWasm() must be awaited first!");
8240 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_ok(o);
8241 return nativeResponseValue;
8243 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_err(void);
8245 export function CResult_TrustedClosingTransactionNoneZ_err(): bigint {
8246 if(!isWasmInitialized) {
8247 throw new Error("initializeWasm() must be awaited first!");
8249 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_err();
8250 return nativeResponseValue;
8252 // bool CResult_TrustedClosingTransactionNoneZ_is_ok(const struct LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR o);
8254 export function CResult_TrustedClosingTransactionNoneZ_is_ok(o: bigint): boolean {
8255 if(!isWasmInitialized) {
8256 throw new Error("initializeWasm() must be awaited first!");
8258 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_is_ok(o);
8259 return nativeResponseValue;
8261 // void CResult_TrustedClosingTransactionNoneZ_free(struct LDKCResult_TrustedClosingTransactionNoneZ _res);
8263 export function CResult_TrustedClosingTransactionNoneZ_free(_res: bigint): void {
8264 if(!isWasmInitialized) {
8265 throw new Error("initializeWasm() must be awaited first!");
8267 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_free(_res);
8268 // debug statements here
8270 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_ok(struct LDKCommitmentTransaction o);
8272 export function CResult_CommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
8273 if(!isWasmInitialized) {
8274 throw new Error("initializeWasm() must be awaited first!");
8276 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_ok(o);
8277 return nativeResponseValue;
8279 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
8281 export function CResult_CommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
8282 if(!isWasmInitialized) {
8283 throw new Error("initializeWasm() must be awaited first!");
8285 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_err(e);
8286 return nativeResponseValue;
8288 // bool CResult_CommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
8290 export function CResult_CommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
8291 if(!isWasmInitialized) {
8292 throw new Error("initializeWasm() must be awaited first!");
8294 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(o);
8295 return nativeResponseValue;
8297 // void CResult_CommitmentTransactionDecodeErrorZ_free(struct LDKCResult_CommitmentTransactionDecodeErrorZ _res);
8299 export function CResult_CommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
8300 if(!isWasmInitialized) {
8301 throw new Error("initializeWasm() must be awaited first!");
8303 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_free(_res);
8304 // debug statements here
8306 // uint64_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
8308 export function CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8309 if(!isWasmInitialized) {
8310 throw new Error("initializeWasm() must be awaited first!");
8312 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg);
8313 return nativeResponseValue;
8315 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
8317 export function CResult_CommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
8318 if(!isWasmInitialized) {
8319 throw new Error("initializeWasm() must be awaited first!");
8321 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone(orig);
8322 return nativeResponseValue;
8324 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_ok(struct LDKTrustedCommitmentTransaction o);
8326 export function CResult_TrustedCommitmentTransactionNoneZ_ok(o: bigint): bigint {
8327 if(!isWasmInitialized) {
8328 throw new Error("initializeWasm() must be awaited first!");
8330 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_ok(o);
8331 return nativeResponseValue;
8333 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_err(void);
8335 export function CResult_TrustedCommitmentTransactionNoneZ_err(): bigint {
8336 if(!isWasmInitialized) {
8337 throw new Error("initializeWasm() must be awaited first!");
8339 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_err();
8340 return nativeResponseValue;
8342 // bool CResult_TrustedCommitmentTransactionNoneZ_is_ok(const struct LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR o);
8344 export function CResult_TrustedCommitmentTransactionNoneZ_is_ok(o: bigint): boolean {
8345 if(!isWasmInitialized) {
8346 throw new Error("initializeWasm() must be awaited first!");
8348 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(o);
8349 return nativeResponseValue;
8351 // void CResult_TrustedCommitmentTransactionNoneZ_free(struct LDKCResult_TrustedCommitmentTransactionNoneZ _res);
8353 export function CResult_TrustedCommitmentTransactionNoneZ_free(_res: bigint): void {
8354 if(!isWasmInitialized) {
8355 throw new Error("initializeWasm() must be awaited first!");
8357 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_free(_res);
8358 // debug statements here
8360 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_ok(struct LDKCVec_SignatureZ o);
8362 export function CResult_CVec_SignatureZNoneZ_ok(o: number): bigint {
8363 if(!isWasmInitialized) {
8364 throw new Error("initializeWasm() must be awaited first!");
8366 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_ok(o);
8367 return nativeResponseValue;
8369 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_err(void);
8371 export function CResult_CVec_SignatureZNoneZ_err(): bigint {
8372 if(!isWasmInitialized) {
8373 throw new Error("initializeWasm() must be awaited first!");
8375 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_err();
8376 return nativeResponseValue;
8378 // bool CResult_CVec_SignatureZNoneZ_is_ok(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR o);
8380 export function CResult_CVec_SignatureZNoneZ_is_ok(o: bigint): boolean {
8381 if(!isWasmInitialized) {
8382 throw new Error("initializeWasm() must be awaited first!");
8384 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_is_ok(o);
8385 return nativeResponseValue;
8387 // void CResult_CVec_SignatureZNoneZ_free(struct LDKCResult_CVec_SignatureZNoneZ _res);
8389 export function CResult_CVec_SignatureZNoneZ_free(_res: bigint): void {
8390 if(!isWasmInitialized) {
8391 throw new Error("initializeWasm() must be awaited first!");
8393 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_free(_res);
8394 // debug statements here
8396 // uint64_t CResult_CVec_SignatureZNoneZ_clone_ptr(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR arg);
8398 export function CResult_CVec_SignatureZNoneZ_clone_ptr(arg: bigint): bigint {
8399 if(!isWasmInitialized) {
8400 throw new Error("initializeWasm() must be awaited first!");
8402 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone_ptr(arg);
8403 return nativeResponseValue;
8405 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_clone(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR orig);
8407 export function CResult_CVec_SignatureZNoneZ_clone(orig: bigint): bigint {
8408 if(!isWasmInitialized) {
8409 throw new Error("initializeWasm() must be awaited first!");
8411 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone(orig);
8412 return nativeResponseValue;
8414 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_ok(struct LDKShutdownScript o);
8416 export function CResult_ShutdownScriptDecodeErrorZ_ok(o: bigint): bigint {
8417 if(!isWasmInitialized) {
8418 throw new Error("initializeWasm() must be awaited first!");
8420 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_ok(o);
8421 return nativeResponseValue;
8423 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_err(struct LDKDecodeError e);
8425 export function CResult_ShutdownScriptDecodeErrorZ_err(e: bigint): bigint {
8426 if(!isWasmInitialized) {
8427 throw new Error("initializeWasm() must be awaited first!");
8429 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_err(e);
8430 return nativeResponseValue;
8432 // bool CResult_ShutdownScriptDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR o);
8434 export function CResult_ShutdownScriptDecodeErrorZ_is_ok(o: bigint): boolean {
8435 if(!isWasmInitialized) {
8436 throw new Error("initializeWasm() must be awaited first!");
8438 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(o);
8439 return nativeResponseValue;
8441 // void CResult_ShutdownScriptDecodeErrorZ_free(struct LDKCResult_ShutdownScriptDecodeErrorZ _res);
8443 export function CResult_ShutdownScriptDecodeErrorZ_free(_res: bigint): void {
8444 if(!isWasmInitialized) {
8445 throw new Error("initializeWasm() must be awaited first!");
8447 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_free(_res);
8448 // debug statements here
8450 // uint64_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg);
8452 export function CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8453 if(!isWasmInitialized) {
8454 throw new Error("initializeWasm() must be awaited first!");
8456 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg);
8457 return nativeResponseValue;
8459 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_clone(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR orig);
8461 export function CResult_ShutdownScriptDecodeErrorZ_clone(orig: bigint): bigint {
8462 if(!isWasmInitialized) {
8463 throw new Error("initializeWasm() must be awaited first!");
8465 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone(orig);
8466 return nativeResponseValue;
8468 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_ok(struct LDKShutdownScript o);
8470 export function CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o: bigint): bigint {
8471 if(!isWasmInitialized) {
8472 throw new Error("initializeWasm() must be awaited first!");
8474 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o);
8475 return nativeResponseValue;
8477 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_err(struct LDKInvalidShutdownScript e);
8479 export function CResult_ShutdownScriptInvalidShutdownScriptZ_err(e: bigint): bigint {
8480 if(!isWasmInitialized) {
8481 throw new Error("initializeWasm() must be awaited first!");
8483 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err(e);
8484 return nativeResponseValue;
8486 // bool CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR o);
8488 export function CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o: bigint): boolean {
8489 if(!isWasmInitialized) {
8490 throw new Error("initializeWasm() must be awaited first!");
8492 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o);
8493 return nativeResponseValue;
8495 // void CResult_ShutdownScriptInvalidShutdownScriptZ_free(struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res);
8497 export function CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res: bigint): void {
8498 if(!isWasmInitialized) {
8499 throw new Error("initializeWasm() must be awaited first!");
8501 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res);
8502 // debug statements here
8504 // uint64_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg);
8506 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg: bigint): bigint {
8507 if(!isWasmInitialized) {
8508 throw new Error("initializeWasm() must be awaited first!");
8510 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg);
8511 return nativeResponseValue;
8513 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_clone(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR orig);
8515 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig: bigint): bigint {
8516 if(!isWasmInitialized) {
8517 throw new Error("initializeWasm() must be awaited first!");
8519 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig);
8520 return nativeResponseValue;
8522 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_ok(struct LDKRouteHop o);
8524 export function CResult_RouteHopDecodeErrorZ_ok(o: bigint): bigint {
8525 if(!isWasmInitialized) {
8526 throw new Error("initializeWasm() must be awaited first!");
8528 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_ok(o);
8529 return nativeResponseValue;
8531 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_err(struct LDKDecodeError e);
8533 export function CResult_RouteHopDecodeErrorZ_err(e: bigint): bigint {
8534 if(!isWasmInitialized) {
8535 throw new Error("initializeWasm() must be awaited first!");
8537 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_err(e);
8538 return nativeResponseValue;
8540 // bool CResult_RouteHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR o);
8542 export function CResult_RouteHopDecodeErrorZ_is_ok(o: bigint): boolean {
8543 if(!isWasmInitialized) {
8544 throw new Error("initializeWasm() must be awaited first!");
8546 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_is_ok(o);
8547 return nativeResponseValue;
8549 // void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
8551 export function CResult_RouteHopDecodeErrorZ_free(_res: bigint): void {
8552 if(!isWasmInitialized) {
8553 throw new Error("initializeWasm() must be awaited first!");
8555 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_free(_res);
8556 // debug statements here
8558 // uint64_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg);
8560 export function CResult_RouteHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8561 if(!isWasmInitialized) {
8562 throw new Error("initializeWasm() must be awaited first!");
8564 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone_ptr(arg);
8565 return nativeResponseValue;
8567 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
8569 export function CResult_RouteHopDecodeErrorZ_clone(orig: bigint): bigint {
8570 if(!isWasmInitialized) {
8571 throw new Error("initializeWasm() must be awaited first!");
8573 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone(orig);
8574 return nativeResponseValue;
8576 // void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
8578 export function CVec_RouteHopZ_free(_res: number): void {
8579 if(!isWasmInitialized) {
8580 throw new Error("initializeWasm() must be awaited first!");
8582 const nativeResponseValue = wasm.TS_CVec_RouteHopZ_free(_res);
8583 // debug statements here
8585 // void CVec_CVec_RouteHopZZ_free(struct LDKCVec_CVec_RouteHopZZ _res);
8587 export function CVec_CVec_RouteHopZZ_free(_res: number): void {
8588 if(!isWasmInitialized) {
8589 throw new Error("initializeWasm() must be awaited first!");
8591 const nativeResponseValue = wasm.TS_CVec_CVec_RouteHopZZ_free(_res);
8592 // debug statements here
8594 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
8596 export function CResult_RouteDecodeErrorZ_ok(o: bigint): bigint {
8597 if(!isWasmInitialized) {
8598 throw new Error("initializeWasm() must be awaited first!");
8600 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_ok(o);
8601 return nativeResponseValue;
8603 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
8605 export function CResult_RouteDecodeErrorZ_err(e: bigint): bigint {
8606 if(!isWasmInitialized) {
8607 throw new Error("initializeWasm() must be awaited first!");
8609 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_err(e);
8610 return nativeResponseValue;
8612 // bool CResult_RouteDecodeErrorZ_is_ok(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR o);
8614 export function CResult_RouteDecodeErrorZ_is_ok(o: bigint): boolean {
8615 if(!isWasmInitialized) {
8616 throw new Error("initializeWasm() must be awaited first!");
8618 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_is_ok(o);
8619 return nativeResponseValue;
8621 // void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
8623 export function CResult_RouteDecodeErrorZ_free(_res: bigint): void {
8624 if(!isWasmInitialized) {
8625 throw new Error("initializeWasm() must be awaited first!");
8627 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_free(_res);
8628 // debug statements here
8630 // uint64_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg);
8632 export function CResult_RouteDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8633 if(!isWasmInitialized) {
8634 throw new Error("initializeWasm() must be awaited first!");
8636 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone_ptr(arg);
8637 return nativeResponseValue;
8639 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
8641 export function CResult_RouteDecodeErrorZ_clone(orig: bigint): bigint {
8642 if(!isWasmInitialized) {
8643 throw new Error("initializeWasm() must be awaited first!");
8645 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone(orig);
8646 return nativeResponseValue;
8648 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_ok(struct LDKRouteParameters o);
8650 export function CResult_RouteParametersDecodeErrorZ_ok(o: bigint): bigint {
8651 if(!isWasmInitialized) {
8652 throw new Error("initializeWasm() must be awaited first!");
8654 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_ok(o);
8655 return nativeResponseValue;
8657 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_err(struct LDKDecodeError e);
8659 export function CResult_RouteParametersDecodeErrorZ_err(e: bigint): bigint {
8660 if(!isWasmInitialized) {
8661 throw new Error("initializeWasm() must be awaited first!");
8663 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_err(e);
8664 return nativeResponseValue;
8666 // bool CResult_RouteParametersDecodeErrorZ_is_ok(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR o);
8668 export function CResult_RouteParametersDecodeErrorZ_is_ok(o: bigint): boolean {
8669 if(!isWasmInitialized) {
8670 throw new Error("initializeWasm() must be awaited first!");
8672 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_is_ok(o);
8673 return nativeResponseValue;
8675 // void CResult_RouteParametersDecodeErrorZ_free(struct LDKCResult_RouteParametersDecodeErrorZ _res);
8677 export function CResult_RouteParametersDecodeErrorZ_free(_res: bigint): void {
8678 if(!isWasmInitialized) {
8679 throw new Error("initializeWasm() must be awaited first!");
8681 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_free(_res);
8682 // debug statements here
8684 // uint64_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg);
8686 export function CResult_RouteParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8687 if(!isWasmInitialized) {
8688 throw new Error("initializeWasm() must be awaited first!");
8690 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(arg);
8691 return nativeResponseValue;
8693 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_clone(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR orig);
8695 export function CResult_RouteParametersDecodeErrorZ_clone(orig: bigint): bigint {
8696 if(!isWasmInitialized) {
8697 throw new Error("initializeWasm() must be awaited first!");
8699 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone(orig);
8700 return nativeResponseValue;
8702 // void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
8704 export function CVec_RouteHintZ_free(_res: number): void {
8705 if(!isWasmInitialized) {
8706 throw new Error("initializeWasm() must be awaited first!");
8708 const nativeResponseValue = wasm.TS_CVec_RouteHintZ_free(_res);
8709 // debug statements here
8711 // struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
8713 export function COption_u64Z_some(o: bigint): bigint {
8714 if(!isWasmInitialized) {
8715 throw new Error("initializeWasm() must be awaited first!");
8717 const nativeResponseValue = wasm.TS_COption_u64Z_some(o);
8718 return nativeResponseValue;
8720 // struct LDKCOption_u64Z COption_u64Z_none(void);
8722 export function COption_u64Z_none(): bigint {
8723 if(!isWasmInitialized) {
8724 throw new Error("initializeWasm() must be awaited first!");
8726 const nativeResponseValue = wasm.TS_COption_u64Z_none();
8727 return nativeResponseValue;
8729 // void COption_u64Z_free(struct LDKCOption_u64Z _res);
8731 export function COption_u64Z_free(_res: bigint): void {
8732 if(!isWasmInitialized) {
8733 throw new Error("initializeWasm() must be awaited first!");
8735 const nativeResponseValue = wasm.TS_COption_u64Z_free(_res);
8736 // debug statements here
8738 // uint64_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg);
8740 export function COption_u64Z_clone_ptr(arg: bigint): bigint {
8741 if(!isWasmInitialized) {
8742 throw new Error("initializeWasm() must be awaited first!");
8744 const nativeResponseValue = wasm.TS_COption_u64Z_clone_ptr(arg);
8745 return nativeResponseValue;
8747 // struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
8749 export function COption_u64Z_clone(orig: bigint): bigint {
8750 if(!isWasmInitialized) {
8751 throw new Error("initializeWasm() must be awaited first!");
8753 const nativeResponseValue = wasm.TS_COption_u64Z_clone(orig);
8754 return nativeResponseValue;
8756 // void CVec_u64Z_free(struct LDKCVec_u64Z _res);
8758 export function CVec_u64Z_free(_res: number): void {
8759 if(!isWasmInitialized) {
8760 throw new Error("initializeWasm() must be awaited first!");
8762 const nativeResponseValue = wasm.TS_CVec_u64Z_free(_res);
8763 // debug statements here
8765 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_ok(struct LDKPaymentParameters o);
8767 export function CResult_PaymentParametersDecodeErrorZ_ok(o: bigint): bigint {
8768 if(!isWasmInitialized) {
8769 throw new Error("initializeWasm() must be awaited first!");
8771 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_ok(o);
8772 return nativeResponseValue;
8774 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_err(struct LDKDecodeError e);
8776 export function CResult_PaymentParametersDecodeErrorZ_err(e: bigint): bigint {
8777 if(!isWasmInitialized) {
8778 throw new Error("initializeWasm() must be awaited first!");
8780 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_err(e);
8781 return nativeResponseValue;
8783 // bool CResult_PaymentParametersDecodeErrorZ_is_ok(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR o);
8785 export function CResult_PaymentParametersDecodeErrorZ_is_ok(o: bigint): boolean {
8786 if(!isWasmInitialized) {
8787 throw new Error("initializeWasm() must be awaited first!");
8789 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_is_ok(o);
8790 return nativeResponseValue;
8792 // void CResult_PaymentParametersDecodeErrorZ_free(struct LDKCResult_PaymentParametersDecodeErrorZ _res);
8794 export function CResult_PaymentParametersDecodeErrorZ_free(_res: bigint): void {
8795 if(!isWasmInitialized) {
8796 throw new Error("initializeWasm() must be awaited first!");
8798 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_free(_res);
8799 // debug statements here
8801 // uint64_t CResult_PaymentParametersDecodeErrorZ_clone_ptr(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR arg);
8803 export function CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8804 if(!isWasmInitialized) {
8805 throw new Error("initializeWasm() must be awaited first!");
8807 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg);
8808 return nativeResponseValue;
8810 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_clone(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR orig);
8812 export function CResult_PaymentParametersDecodeErrorZ_clone(orig: bigint): bigint {
8813 if(!isWasmInitialized) {
8814 throw new Error("initializeWasm() must be awaited first!");
8816 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone(orig);
8817 return nativeResponseValue;
8819 // void CVec_RouteHintHopZ_free(struct LDKCVec_RouteHintHopZ _res);
8821 export function CVec_RouteHintHopZ_free(_res: number): void {
8822 if(!isWasmInitialized) {
8823 throw new Error("initializeWasm() must be awaited first!");
8825 const nativeResponseValue = wasm.TS_CVec_RouteHintHopZ_free(_res);
8826 // debug statements here
8828 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_ok(struct LDKRouteHint o);
8830 export function CResult_RouteHintDecodeErrorZ_ok(o: bigint): bigint {
8831 if(!isWasmInitialized) {
8832 throw new Error("initializeWasm() must be awaited first!");
8834 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_ok(o);
8835 return nativeResponseValue;
8837 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_err(struct LDKDecodeError e);
8839 export function CResult_RouteHintDecodeErrorZ_err(e: bigint): bigint {
8840 if(!isWasmInitialized) {
8841 throw new Error("initializeWasm() must be awaited first!");
8843 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_err(e);
8844 return nativeResponseValue;
8846 // bool CResult_RouteHintDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR o);
8848 export function CResult_RouteHintDecodeErrorZ_is_ok(o: bigint): boolean {
8849 if(!isWasmInitialized) {
8850 throw new Error("initializeWasm() must be awaited first!");
8852 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_is_ok(o);
8853 return nativeResponseValue;
8855 // void CResult_RouteHintDecodeErrorZ_free(struct LDKCResult_RouteHintDecodeErrorZ _res);
8857 export function CResult_RouteHintDecodeErrorZ_free(_res: bigint): void {
8858 if(!isWasmInitialized) {
8859 throw new Error("initializeWasm() must be awaited first!");
8861 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_free(_res);
8862 // debug statements here
8864 // uint64_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg);
8866 export function CResult_RouteHintDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8867 if(!isWasmInitialized) {
8868 throw new Error("initializeWasm() must be awaited first!");
8870 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone_ptr(arg);
8871 return nativeResponseValue;
8873 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_clone(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR orig);
8875 export function CResult_RouteHintDecodeErrorZ_clone(orig: bigint): bigint {
8876 if(!isWasmInitialized) {
8877 throw new Error("initializeWasm() must be awaited first!");
8879 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone(orig);
8880 return nativeResponseValue;
8882 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_ok(struct LDKRouteHintHop o);
8884 export function CResult_RouteHintHopDecodeErrorZ_ok(o: bigint): bigint {
8885 if(!isWasmInitialized) {
8886 throw new Error("initializeWasm() must be awaited first!");
8888 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_ok(o);
8889 return nativeResponseValue;
8891 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_err(struct LDKDecodeError e);
8893 export function CResult_RouteHintHopDecodeErrorZ_err(e: bigint): bigint {
8894 if(!isWasmInitialized) {
8895 throw new Error("initializeWasm() must be awaited first!");
8897 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_err(e);
8898 return nativeResponseValue;
8900 // bool CResult_RouteHintHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR o);
8902 export function CResult_RouteHintHopDecodeErrorZ_is_ok(o: bigint): boolean {
8903 if(!isWasmInitialized) {
8904 throw new Error("initializeWasm() must be awaited first!");
8906 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_is_ok(o);
8907 return nativeResponseValue;
8909 // void CResult_RouteHintHopDecodeErrorZ_free(struct LDKCResult_RouteHintHopDecodeErrorZ _res);
8911 export function CResult_RouteHintHopDecodeErrorZ_free(_res: bigint): void {
8912 if(!isWasmInitialized) {
8913 throw new Error("initializeWasm() must be awaited first!");
8915 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_free(_res);
8916 // debug statements here
8918 // uint64_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg);
8920 export function CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8921 if(!isWasmInitialized) {
8922 throw new Error("initializeWasm() must be awaited first!");
8924 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg);
8925 return nativeResponseValue;
8927 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_clone(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR orig);
8929 export function CResult_RouteHintHopDecodeErrorZ_clone(orig: bigint): bigint {
8930 if(!isWasmInitialized) {
8931 throw new Error("initializeWasm() must be awaited first!");
8933 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone(orig);
8934 return nativeResponseValue;
8936 // void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
8938 export function CVec_ChannelDetailsZ_free(_res: number): void {
8939 if(!isWasmInitialized) {
8940 throw new Error("initializeWasm() must be awaited first!");
8942 const nativeResponseValue = wasm.TS_CVec_ChannelDetailsZ_free(_res);
8943 // debug statements here
8945 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
8947 export function CResult_RouteLightningErrorZ_ok(o: bigint): bigint {
8948 if(!isWasmInitialized) {
8949 throw new Error("initializeWasm() must be awaited first!");
8951 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_ok(o);
8952 return nativeResponseValue;
8954 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
8956 export function CResult_RouteLightningErrorZ_err(e: bigint): bigint {
8957 if(!isWasmInitialized) {
8958 throw new Error("initializeWasm() must be awaited first!");
8960 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_err(e);
8961 return nativeResponseValue;
8963 // bool CResult_RouteLightningErrorZ_is_ok(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR o);
8965 export function CResult_RouteLightningErrorZ_is_ok(o: bigint): boolean {
8966 if(!isWasmInitialized) {
8967 throw new Error("initializeWasm() must be awaited first!");
8969 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_is_ok(o);
8970 return nativeResponseValue;
8972 // void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
8974 export function CResult_RouteLightningErrorZ_free(_res: bigint): void {
8975 if(!isWasmInitialized) {
8976 throw new Error("initializeWasm() must be awaited first!");
8978 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_free(_res);
8979 // debug statements here
8981 // uint64_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg);
8983 export function CResult_RouteLightningErrorZ_clone_ptr(arg: bigint): bigint {
8984 if(!isWasmInitialized) {
8985 throw new Error("initializeWasm() must be awaited first!");
8987 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone_ptr(arg);
8988 return nativeResponseValue;
8990 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
8992 export function CResult_RouteLightningErrorZ_clone(orig: bigint): bigint {
8993 if(!isWasmInitialized) {
8994 throw new Error("initializeWasm() must be awaited first!");
8996 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone(orig);
8997 return nativeResponseValue;
8999 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_ok(struct LDKPaymentPurpose o);
9001 export function CResult_PaymentPurposeDecodeErrorZ_ok(o: bigint): bigint {
9002 if(!isWasmInitialized) {
9003 throw new Error("initializeWasm() must be awaited first!");
9005 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_ok(o);
9006 return nativeResponseValue;
9008 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_err(struct LDKDecodeError e);
9010 export function CResult_PaymentPurposeDecodeErrorZ_err(e: bigint): bigint {
9011 if(!isWasmInitialized) {
9012 throw new Error("initializeWasm() must be awaited first!");
9014 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_err(e);
9015 return nativeResponseValue;
9017 // bool CResult_PaymentPurposeDecodeErrorZ_is_ok(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR o);
9019 export function CResult_PaymentPurposeDecodeErrorZ_is_ok(o: bigint): boolean {
9020 if(!isWasmInitialized) {
9021 throw new Error("initializeWasm() must be awaited first!");
9023 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_is_ok(o);
9024 return nativeResponseValue;
9026 // void CResult_PaymentPurposeDecodeErrorZ_free(struct LDKCResult_PaymentPurposeDecodeErrorZ _res);
9028 export function CResult_PaymentPurposeDecodeErrorZ_free(_res: bigint): void {
9029 if(!isWasmInitialized) {
9030 throw new Error("initializeWasm() must be awaited first!");
9032 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_free(_res);
9033 // debug statements here
9035 // uint64_t CResult_PaymentPurposeDecodeErrorZ_clone_ptr(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR arg);
9037 export function CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9038 if(!isWasmInitialized) {
9039 throw new Error("initializeWasm() must be awaited first!");
9041 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg);
9042 return nativeResponseValue;
9044 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_clone(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR orig);
9046 export function CResult_PaymentPurposeDecodeErrorZ_clone(orig: bigint): bigint {
9047 if(!isWasmInitialized) {
9048 throw new Error("initializeWasm() must be awaited first!");
9050 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone(orig);
9051 return nativeResponseValue;
9053 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_some(struct LDKClosureReason o);
9055 export function COption_ClosureReasonZ_some(o: bigint): bigint {
9056 if(!isWasmInitialized) {
9057 throw new Error("initializeWasm() must be awaited first!");
9059 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_some(o);
9060 return nativeResponseValue;
9062 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_none(void);
9064 export function COption_ClosureReasonZ_none(): bigint {
9065 if(!isWasmInitialized) {
9066 throw new Error("initializeWasm() must be awaited first!");
9068 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_none();
9069 return nativeResponseValue;
9071 // void COption_ClosureReasonZ_free(struct LDKCOption_ClosureReasonZ _res);
9073 export function COption_ClosureReasonZ_free(_res: bigint): void {
9074 if(!isWasmInitialized) {
9075 throw new Error("initializeWasm() must be awaited first!");
9077 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_free(_res);
9078 // debug statements here
9080 // uint64_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg);
9082 export function COption_ClosureReasonZ_clone_ptr(arg: bigint): bigint {
9083 if(!isWasmInitialized) {
9084 throw new Error("initializeWasm() must be awaited first!");
9086 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone_ptr(arg);
9087 return nativeResponseValue;
9089 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_clone(const struct LDKCOption_ClosureReasonZ *NONNULL_PTR orig);
9091 export function COption_ClosureReasonZ_clone(orig: bigint): bigint {
9092 if(!isWasmInitialized) {
9093 throw new Error("initializeWasm() must be awaited first!");
9095 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone(orig);
9096 return nativeResponseValue;
9098 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_ok(struct LDKCOption_ClosureReasonZ o);
9100 export function CResult_COption_ClosureReasonZDecodeErrorZ_ok(o: bigint): bigint {
9101 if(!isWasmInitialized) {
9102 throw new Error("initializeWasm() must be awaited first!");
9104 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(o);
9105 return nativeResponseValue;
9107 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_err(struct LDKDecodeError e);
9109 export function CResult_COption_ClosureReasonZDecodeErrorZ_err(e: bigint): bigint {
9110 if(!isWasmInitialized) {
9111 throw new Error("initializeWasm() must be awaited first!");
9113 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(e);
9114 return nativeResponseValue;
9116 // bool CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR o);
9118 export function CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o: bigint): boolean {
9119 if(!isWasmInitialized) {
9120 throw new Error("initializeWasm() must be awaited first!");
9122 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o);
9123 return nativeResponseValue;
9125 // void CResult_COption_ClosureReasonZDecodeErrorZ_free(struct LDKCResult_COption_ClosureReasonZDecodeErrorZ _res);
9127 export function CResult_COption_ClosureReasonZDecodeErrorZ_free(_res: bigint): void {
9128 if(!isWasmInitialized) {
9129 throw new Error("initializeWasm() must be awaited first!");
9131 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(_res);
9132 // debug statements here
9134 // uint64_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg);
9136 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9137 if(!isWasmInitialized) {
9138 throw new Error("initializeWasm() must be awaited first!");
9140 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg);
9141 return nativeResponseValue;
9143 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_clone(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR orig);
9145 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig: bigint): bigint {
9146 if(!isWasmInitialized) {
9147 throw new Error("initializeWasm() must be awaited first!");
9149 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig);
9150 return nativeResponseValue;
9152 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_some(struct LDKHTLCDestination o);
9154 export function COption_HTLCDestinationZ_some(o: bigint): bigint {
9155 if(!isWasmInitialized) {
9156 throw new Error("initializeWasm() must be awaited first!");
9158 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_some(o);
9159 return nativeResponseValue;
9161 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_none(void);
9163 export function COption_HTLCDestinationZ_none(): bigint {
9164 if(!isWasmInitialized) {
9165 throw new Error("initializeWasm() must be awaited first!");
9167 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_none();
9168 return nativeResponseValue;
9170 // void COption_HTLCDestinationZ_free(struct LDKCOption_HTLCDestinationZ _res);
9172 export function COption_HTLCDestinationZ_free(_res: bigint): void {
9173 if(!isWasmInitialized) {
9174 throw new Error("initializeWasm() must be awaited first!");
9176 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_free(_res);
9177 // debug statements here
9179 // uint64_t COption_HTLCDestinationZ_clone_ptr(LDKCOption_HTLCDestinationZ *NONNULL_PTR arg);
9181 export function COption_HTLCDestinationZ_clone_ptr(arg: bigint): bigint {
9182 if(!isWasmInitialized) {
9183 throw new Error("initializeWasm() must be awaited first!");
9185 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone_ptr(arg);
9186 return nativeResponseValue;
9188 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_clone(const struct LDKCOption_HTLCDestinationZ *NONNULL_PTR orig);
9190 export function COption_HTLCDestinationZ_clone(orig: bigint): bigint {
9191 if(!isWasmInitialized) {
9192 throw new Error("initializeWasm() must be awaited first!");
9194 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone(orig);
9195 return nativeResponseValue;
9197 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_ok(struct LDKCOption_HTLCDestinationZ o);
9199 export function CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o: bigint): bigint {
9200 if(!isWasmInitialized) {
9201 throw new Error("initializeWasm() must be awaited first!");
9203 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o);
9204 return nativeResponseValue;
9206 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_err(struct LDKDecodeError e);
9208 export function CResult_COption_HTLCDestinationZDecodeErrorZ_err(e: bigint): bigint {
9209 if(!isWasmInitialized) {
9210 throw new Error("initializeWasm() must be awaited first!");
9212 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_err(e);
9213 return nativeResponseValue;
9215 // bool CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR o);
9217 export function CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o: bigint): boolean {
9218 if(!isWasmInitialized) {
9219 throw new Error("initializeWasm() must be awaited first!");
9221 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o);
9222 return nativeResponseValue;
9224 // void CResult_COption_HTLCDestinationZDecodeErrorZ_free(struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ _res);
9226 export function CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res: bigint): void {
9227 if(!isWasmInitialized) {
9228 throw new Error("initializeWasm() must be awaited first!");
9230 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res);
9231 // debug statements here
9233 // uint64_t CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR arg);
9235 export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9236 if(!isWasmInitialized) {
9237 throw new Error("initializeWasm() must be awaited first!");
9239 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg);
9240 return nativeResponseValue;
9242 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_clone(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR orig);
9244 export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig: bigint): bigint {
9245 if(!isWasmInitialized) {
9246 throw new Error("initializeWasm() must be awaited first!");
9248 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig);
9249 return nativeResponseValue;
9251 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_some(struct LDKNetworkUpdate o);
9253 export function COption_NetworkUpdateZ_some(o: bigint): bigint {
9254 if(!isWasmInitialized) {
9255 throw new Error("initializeWasm() must be awaited first!");
9257 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_some(o);
9258 return nativeResponseValue;
9260 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_none(void);
9262 export function COption_NetworkUpdateZ_none(): bigint {
9263 if(!isWasmInitialized) {
9264 throw new Error("initializeWasm() must be awaited first!");
9266 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_none();
9267 return nativeResponseValue;
9269 // void COption_NetworkUpdateZ_free(struct LDKCOption_NetworkUpdateZ _res);
9271 export function COption_NetworkUpdateZ_free(_res: bigint): void {
9272 if(!isWasmInitialized) {
9273 throw new Error("initializeWasm() must be awaited first!");
9275 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_free(_res);
9276 // debug statements here
9278 // uint64_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg);
9280 export function COption_NetworkUpdateZ_clone_ptr(arg: bigint): bigint {
9281 if(!isWasmInitialized) {
9282 throw new Error("initializeWasm() must be awaited first!");
9284 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone_ptr(arg);
9285 return nativeResponseValue;
9287 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_clone(const struct LDKCOption_NetworkUpdateZ *NONNULL_PTR orig);
9289 export function COption_NetworkUpdateZ_clone(orig: bigint): bigint {
9290 if(!isWasmInitialized) {
9291 throw new Error("initializeWasm() must be awaited first!");
9293 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone(orig);
9294 return nativeResponseValue;
9296 // void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
9298 export function CVec_SpendableOutputDescriptorZ_free(_res: number): void {
9299 if(!isWasmInitialized) {
9300 throw new Error("initializeWasm() must be awaited first!");
9302 const nativeResponseValue = wasm.TS_CVec_SpendableOutputDescriptorZ_free(_res);
9303 // debug statements here
9305 // struct LDKCOption_EventZ COption_EventZ_some(struct LDKEvent o);
9307 export function COption_EventZ_some(o: bigint): bigint {
9308 if(!isWasmInitialized) {
9309 throw new Error("initializeWasm() must be awaited first!");
9311 const nativeResponseValue = wasm.TS_COption_EventZ_some(o);
9312 return nativeResponseValue;
9314 // struct LDKCOption_EventZ COption_EventZ_none(void);
9316 export function COption_EventZ_none(): bigint {
9317 if(!isWasmInitialized) {
9318 throw new Error("initializeWasm() must be awaited first!");
9320 const nativeResponseValue = wasm.TS_COption_EventZ_none();
9321 return nativeResponseValue;
9323 // void COption_EventZ_free(struct LDKCOption_EventZ _res);
9325 export function COption_EventZ_free(_res: bigint): void {
9326 if(!isWasmInitialized) {
9327 throw new Error("initializeWasm() must be awaited first!");
9329 const nativeResponseValue = wasm.TS_COption_EventZ_free(_res);
9330 // debug statements here
9332 // uint64_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg);
9334 export function COption_EventZ_clone_ptr(arg: bigint): bigint {
9335 if(!isWasmInitialized) {
9336 throw new Error("initializeWasm() must be awaited first!");
9338 const nativeResponseValue = wasm.TS_COption_EventZ_clone_ptr(arg);
9339 return nativeResponseValue;
9341 // struct LDKCOption_EventZ COption_EventZ_clone(const struct LDKCOption_EventZ *NONNULL_PTR orig);
9343 export function COption_EventZ_clone(orig: bigint): bigint {
9344 if(!isWasmInitialized) {
9345 throw new Error("initializeWasm() must be awaited first!");
9347 const nativeResponseValue = wasm.TS_COption_EventZ_clone(orig);
9348 return nativeResponseValue;
9350 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_ok(struct LDKCOption_EventZ o);
9352 export function CResult_COption_EventZDecodeErrorZ_ok(o: bigint): bigint {
9353 if(!isWasmInitialized) {
9354 throw new Error("initializeWasm() must be awaited first!");
9356 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_ok(o);
9357 return nativeResponseValue;
9359 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_err(struct LDKDecodeError e);
9361 export function CResult_COption_EventZDecodeErrorZ_err(e: bigint): bigint {
9362 if(!isWasmInitialized) {
9363 throw new Error("initializeWasm() must be awaited first!");
9365 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_err(e);
9366 return nativeResponseValue;
9368 // bool CResult_COption_EventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR o);
9370 export function CResult_COption_EventZDecodeErrorZ_is_ok(o: bigint): boolean {
9371 if(!isWasmInitialized) {
9372 throw new Error("initializeWasm() must be awaited first!");
9374 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_is_ok(o);
9375 return nativeResponseValue;
9377 // void CResult_COption_EventZDecodeErrorZ_free(struct LDKCResult_COption_EventZDecodeErrorZ _res);
9379 export function CResult_COption_EventZDecodeErrorZ_free(_res: bigint): void {
9380 if(!isWasmInitialized) {
9381 throw new Error("initializeWasm() must be awaited first!");
9383 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_free(_res);
9384 // debug statements here
9386 // uint64_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg);
9388 export function CResult_COption_EventZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9389 if(!isWasmInitialized) {
9390 throw new Error("initializeWasm() must be awaited first!");
9392 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(arg);
9393 return nativeResponseValue;
9395 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_clone(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR orig);
9397 export function CResult_COption_EventZDecodeErrorZ_clone(orig: bigint): bigint {
9398 if(!isWasmInitialized) {
9399 throw new Error("initializeWasm() must be awaited first!");
9401 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone(orig);
9402 return nativeResponseValue;
9404 // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
9406 export function CVec_MessageSendEventZ_free(_res: number): void {
9407 if(!isWasmInitialized) {
9408 throw new Error("initializeWasm() must be awaited first!");
9410 const nativeResponseValue = wasm.TS_CVec_MessageSendEventZ_free(_res);
9411 // debug statements here
9413 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_ok(struct LDKTxOut o);
9415 export function CResult_TxOutAccessErrorZ_ok(o: bigint): bigint {
9416 if(!isWasmInitialized) {
9417 throw new Error("initializeWasm() must be awaited first!");
9419 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_ok(o);
9420 return nativeResponseValue;
9422 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_err(enum LDKAccessError e);
9424 export function CResult_TxOutAccessErrorZ_err(e: AccessError): bigint {
9425 if(!isWasmInitialized) {
9426 throw new Error("initializeWasm() must be awaited first!");
9428 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_err(e);
9429 return nativeResponseValue;
9431 // bool CResult_TxOutAccessErrorZ_is_ok(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR o);
9433 export function CResult_TxOutAccessErrorZ_is_ok(o: bigint): boolean {
9434 if(!isWasmInitialized) {
9435 throw new Error("initializeWasm() must be awaited first!");
9437 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_is_ok(o);
9438 return nativeResponseValue;
9440 // void CResult_TxOutAccessErrorZ_free(struct LDKCResult_TxOutAccessErrorZ _res);
9442 export function CResult_TxOutAccessErrorZ_free(_res: bigint): void {
9443 if(!isWasmInitialized) {
9444 throw new Error("initializeWasm() must be awaited first!");
9446 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_free(_res);
9447 // debug statements here
9449 // uint64_t CResult_TxOutAccessErrorZ_clone_ptr(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR arg);
9451 export function CResult_TxOutAccessErrorZ_clone_ptr(arg: bigint): bigint {
9452 if(!isWasmInitialized) {
9453 throw new Error("initializeWasm() must be awaited first!");
9455 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone_ptr(arg);
9456 return nativeResponseValue;
9458 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_clone(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR orig);
9460 export function CResult_TxOutAccessErrorZ_clone(orig: bigint): bigint {
9461 if(!isWasmInitialized) {
9462 throw new Error("initializeWasm() must be awaited first!");
9464 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone(orig);
9465 return nativeResponseValue;
9467 // uint64_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg);
9469 export function C2Tuple_usizeTransactionZ_clone_ptr(arg: bigint): bigint {
9470 if(!isWasmInitialized) {
9471 throw new Error("initializeWasm() must be awaited first!");
9473 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone_ptr(arg);
9474 return nativeResponseValue;
9476 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_clone(const struct LDKC2Tuple_usizeTransactionZ *NONNULL_PTR orig);
9478 export function C2Tuple_usizeTransactionZ_clone(orig: bigint): bigint {
9479 if(!isWasmInitialized) {
9480 throw new Error("initializeWasm() must be awaited first!");
9482 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone(orig);
9483 return nativeResponseValue;
9485 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
9487 export function C2Tuple_usizeTransactionZ_new(a: number, b: number): bigint {
9488 if(!isWasmInitialized) {
9489 throw new Error("initializeWasm() must be awaited first!");
9491 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_new(a, b);
9492 return nativeResponseValue;
9494 // void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
9496 export function C2Tuple_usizeTransactionZ_free(_res: bigint): void {
9497 if(!isWasmInitialized) {
9498 throw new Error("initializeWasm() must be awaited first!");
9500 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_free(_res);
9501 // debug statements here
9503 // void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
9505 export function CVec_C2Tuple_usizeTransactionZZ_free(_res: number): void {
9506 if(!isWasmInitialized) {
9507 throw new Error("initializeWasm() must be awaited first!");
9509 const nativeResponseValue = wasm.TS_CVec_C2Tuple_usizeTransactionZZ_free(_res);
9510 // debug statements here
9512 // void CVec_TxidZ_free(struct LDKCVec_TxidZ _res);
9514 export function CVec_TxidZ_free(_res: number): void {
9515 if(!isWasmInitialized) {
9516 throw new Error("initializeWasm() must be awaited first!");
9518 const nativeResponseValue = wasm.TS_CVec_TxidZ_free(_res);
9519 // debug statements here
9521 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_ok(void);
9523 export function CResult_NoneChannelMonitorUpdateErrZ_ok(): bigint {
9524 if(!isWasmInitialized) {
9525 throw new Error("initializeWasm() must be awaited first!");
9527 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_ok();
9528 return nativeResponseValue;
9530 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_err(enum LDKChannelMonitorUpdateErr e);
9532 export function CResult_NoneChannelMonitorUpdateErrZ_err(e: ChannelMonitorUpdateErr): bigint {
9533 if(!isWasmInitialized) {
9534 throw new Error("initializeWasm() must be awaited first!");
9536 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_err(e);
9537 return nativeResponseValue;
9539 // bool CResult_NoneChannelMonitorUpdateErrZ_is_ok(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR o);
9541 export function CResult_NoneChannelMonitorUpdateErrZ_is_ok(o: bigint): boolean {
9542 if(!isWasmInitialized) {
9543 throw new Error("initializeWasm() must be awaited first!");
9545 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_is_ok(o);
9546 return nativeResponseValue;
9548 // void CResult_NoneChannelMonitorUpdateErrZ_free(struct LDKCResult_NoneChannelMonitorUpdateErrZ _res);
9550 export function CResult_NoneChannelMonitorUpdateErrZ_free(_res: bigint): void {
9551 if(!isWasmInitialized) {
9552 throw new Error("initializeWasm() must be awaited first!");
9554 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_free(_res);
9555 // debug statements here
9557 // uint64_t CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR arg);
9559 export function CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg: bigint): bigint {
9560 if(!isWasmInitialized) {
9561 throw new Error("initializeWasm() must be awaited first!");
9563 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg);
9564 return nativeResponseValue;
9566 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_clone(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR orig);
9568 export function CResult_NoneChannelMonitorUpdateErrZ_clone(orig: bigint): bigint {
9569 if(!isWasmInitialized) {
9570 throw new Error("initializeWasm() must be awaited first!");
9572 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_clone(orig);
9573 return nativeResponseValue;
9575 // void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
9577 export function CVec_MonitorEventZ_free(_res: number): void {
9578 if(!isWasmInitialized) {
9579 throw new Error("initializeWasm() must be awaited first!");
9581 const nativeResponseValue = wasm.TS_CVec_MonitorEventZ_free(_res);
9582 // debug statements here
9584 // uint64_t C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR arg);
9586 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg: bigint): bigint {
9587 if(!isWasmInitialized) {
9588 throw new Error("initializeWasm() must be awaited first!");
9590 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg);
9591 return nativeResponseValue;
9593 // struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(const struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR orig);
9595 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig: bigint): bigint {
9596 if(!isWasmInitialized) {
9597 throw new Error("initializeWasm() must be awaited first!");
9599 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig);
9600 return nativeResponseValue;
9602 // struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(struct LDKOutPoint a, struct LDKCVec_MonitorEventZ b, struct LDKPublicKey c);
9604 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a: bigint, b: number, c: number): bigint {
9605 if(!isWasmInitialized) {
9606 throw new Error("initializeWasm() must be awaited first!");
9608 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a, b, c);
9609 return nativeResponseValue;
9611 // void C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ _res);
9613 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res: bigint): void {
9614 if(!isWasmInitialized) {
9615 throw new Error("initializeWasm() must be awaited first!");
9617 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res);
9618 // debug statements here
9620 // void CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(struct LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ _res);
9622 export function CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res: number): void {
9623 if(!isWasmInitialized) {
9624 throw new Error("initializeWasm() must be awaited first!");
9626 const nativeResponseValue = wasm.TS_CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res);
9627 // debug statements here
9629 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_ok(struct LDKFixedPenaltyScorer o);
9631 export function CResult_FixedPenaltyScorerDecodeErrorZ_ok(o: bigint): bigint {
9632 if(!isWasmInitialized) {
9633 throw new Error("initializeWasm() must be awaited first!");
9635 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok(o);
9636 return nativeResponseValue;
9638 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_err(struct LDKDecodeError e);
9640 export function CResult_FixedPenaltyScorerDecodeErrorZ_err(e: bigint): bigint {
9641 if(!isWasmInitialized) {
9642 throw new Error("initializeWasm() must be awaited first!");
9644 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_err(e);
9645 return nativeResponseValue;
9647 // bool CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR o);
9649 export function CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o: bigint): boolean {
9650 if(!isWasmInitialized) {
9651 throw new Error("initializeWasm() must be awaited first!");
9653 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o);
9654 return nativeResponseValue;
9656 // void CResult_FixedPenaltyScorerDecodeErrorZ_free(struct LDKCResult_FixedPenaltyScorerDecodeErrorZ _res);
9658 export function CResult_FixedPenaltyScorerDecodeErrorZ_free(_res: bigint): void {
9659 if(!isWasmInitialized) {
9660 throw new Error("initializeWasm() must be awaited first!");
9662 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_free(_res);
9663 // debug statements here
9665 // uint64_t CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR arg);
9667 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9668 if(!isWasmInitialized) {
9669 throw new Error("initializeWasm() must be awaited first!");
9671 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg);
9672 return nativeResponseValue;
9674 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_clone(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR orig);
9676 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig: bigint): bigint {
9677 if(!isWasmInitialized) {
9678 throw new Error("initializeWasm() must be awaited first!");
9680 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig);
9681 return nativeResponseValue;
9683 // uint64_t C2Tuple_u64u64Z_clone_ptr(LDKC2Tuple_u64u64Z *NONNULL_PTR arg);
9685 export function C2Tuple_u64u64Z_clone_ptr(arg: bigint): bigint {
9686 if(!isWasmInitialized) {
9687 throw new Error("initializeWasm() must be awaited first!");
9689 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone_ptr(arg);
9690 return nativeResponseValue;
9692 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_clone(const struct LDKC2Tuple_u64u64Z *NONNULL_PTR orig);
9694 export function C2Tuple_u64u64Z_clone(orig: bigint): bigint {
9695 if(!isWasmInitialized) {
9696 throw new Error("initializeWasm() must be awaited first!");
9698 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone(orig);
9699 return nativeResponseValue;
9701 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_new(uint64_t a, uint64_t b);
9703 export function C2Tuple_u64u64Z_new(a: bigint, b: bigint): bigint {
9704 if(!isWasmInitialized) {
9705 throw new Error("initializeWasm() must be awaited first!");
9707 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_new(a, b);
9708 return nativeResponseValue;
9710 // void C2Tuple_u64u64Z_free(struct LDKC2Tuple_u64u64Z _res);
9712 export function C2Tuple_u64u64Z_free(_res: bigint): void {
9713 if(!isWasmInitialized) {
9714 throw new Error("initializeWasm() must be awaited first!");
9716 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_free(_res);
9717 // debug statements here
9719 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_some(struct LDKC2Tuple_u64u64Z o);
9721 export function COption_C2Tuple_u64u64ZZ_some(o: bigint): bigint {
9722 if(!isWasmInitialized) {
9723 throw new Error("initializeWasm() must be awaited first!");
9725 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_some(o);
9726 return nativeResponseValue;
9728 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_none(void);
9730 export function COption_C2Tuple_u64u64ZZ_none(): bigint {
9731 if(!isWasmInitialized) {
9732 throw new Error("initializeWasm() must be awaited first!");
9734 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_none();
9735 return nativeResponseValue;
9737 // void COption_C2Tuple_u64u64ZZ_free(struct LDKCOption_C2Tuple_u64u64ZZ _res);
9739 export function COption_C2Tuple_u64u64ZZ_free(_res: bigint): void {
9740 if(!isWasmInitialized) {
9741 throw new Error("initializeWasm() must be awaited first!");
9743 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_free(_res);
9744 // debug statements here
9746 // uint64_t COption_C2Tuple_u64u64ZZ_clone_ptr(LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR arg);
9748 export function COption_C2Tuple_u64u64ZZ_clone_ptr(arg: bigint): bigint {
9749 if(!isWasmInitialized) {
9750 throw new Error("initializeWasm() must be awaited first!");
9752 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone_ptr(arg);
9753 return nativeResponseValue;
9755 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_clone(const struct LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR orig);
9757 export function COption_C2Tuple_u64u64ZZ_clone(orig: bigint): bigint {
9758 if(!isWasmInitialized) {
9759 throw new Error("initializeWasm() must be awaited first!");
9761 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone(orig);
9762 return nativeResponseValue;
9764 // void CVec_NodeIdZ_free(struct LDKCVec_NodeIdZ _res);
9766 export function CVec_NodeIdZ_free(_res: number): void {
9767 if(!isWasmInitialized) {
9768 throw new Error("initializeWasm() must be awaited first!");
9770 const nativeResponseValue = wasm.TS_CVec_NodeIdZ_free(_res);
9771 // debug statements here
9773 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_ok(struct LDKProbabilisticScorer o);
9775 export function CResult_ProbabilisticScorerDecodeErrorZ_ok(o: bigint): bigint {
9776 if(!isWasmInitialized) {
9777 throw new Error("initializeWasm() must be awaited first!");
9779 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_ok(o);
9780 return nativeResponseValue;
9782 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_err(struct LDKDecodeError e);
9784 export function CResult_ProbabilisticScorerDecodeErrorZ_err(e: bigint): bigint {
9785 if(!isWasmInitialized) {
9786 throw new Error("initializeWasm() must be awaited first!");
9788 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_err(e);
9789 return nativeResponseValue;
9791 // bool CResult_ProbabilisticScorerDecodeErrorZ_is_ok(const struct LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR o);
9793 export function CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o: bigint): boolean {
9794 if(!isWasmInitialized) {
9795 throw new Error("initializeWasm() must be awaited first!");
9797 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o);
9798 return nativeResponseValue;
9800 // void CResult_ProbabilisticScorerDecodeErrorZ_free(struct LDKCResult_ProbabilisticScorerDecodeErrorZ _res);
9802 export function CResult_ProbabilisticScorerDecodeErrorZ_free(_res: bigint): void {
9803 if(!isWasmInitialized) {
9804 throw new Error("initializeWasm() must be awaited first!");
9806 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_free(_res);
9807 // debug statements here
9809 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
9811 export function CResult_InitFeaturesDecodeErrorZ_ok(o: bigint): bigint {
9812 if(!isWasmInitialized) {
9813 throw new Error("initializeWasm() must be awaited first!");
9815 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_ok(o);
9816 return nativeResponseValue;
9818 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
9820 export function CResult_InitFeaturesDecodeErrorZ_err(e: bigint): bigint {
9821 if(!isWasmInitialized) {
9822 throw new Error("initializeWasm() must be awaited first!");
9824 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_err(e);
9825 return nativeResponseValue;
9827 // bool CResult_InitFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR o);
9829 export function CResult_InitFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
9830 if(!isWasmInitialized) {
9831 throw new Error("initializeWasm() must be awaited first!");
9833 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_is_ok(o);
9834 return nativeResponseValue;
9836 // void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
9838 export function CResult_InitFeaturesDecodeErrorZ_free(_res: bigint): void {
9839 if(!isWasmInitialized) {
9840 throw new Error("initializeWasm() must be awaited first!");
9842 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_free(_res);
9843 // debug statements here
9845 // uint64_t CResult_InitFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR arg);
9847 export function CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9848 if(!isWasmInitialized) {
9849 throw new Error("initializeWasm() must be awaited first!");
9851 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg);
9852 return nativeResponseValue;
9854 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_clone(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR orig);
9856 export function CResult_InitFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
9857 if(!isWasmInitialized) {
9858 throw new Error("initializeWasm() must be awaited first!");
9860 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone(orig);
9861 return nativeResponseValue;
9863 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
9865 export function CResult_ChannelFeaturesDecodeErrorZ_ok(o: bigint): bigint {
9866 if(!isWasmInitialized) {
9867 throw new Error("initializeWasm() must be awaited first!");
9869 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_ok(o);
9870 return nativeResponseValue;
9872 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
9874 export function CResult_ChannelFeaturesDecodeErrorZ_err(e: bigint): bigint {
9875 if(!isWasmInitialized) {
9876 throw new Error("initializeWasm() must be awaited first!");
9878 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_err(e);
9879 return nativeResponseValue;
9881 // bool CResult_ChannelFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR o);
9883 export function CResult_ChannelFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
9884 if(!isWasmInitialized) {
9885 throw new Error("initializeWasm() must be awaited first!");
9887 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(o);
9888 return nativeResponseValue;
9890 // void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
9892 export function CResult_ChannelFeaturesDecodeErrorZ_free(_res: bigint): void {
9893 if(!isWasmInitialized) {
9894 throw new Error("initializeWasm() must be awaited first!");
9896 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_free(_res);
9897 // debug statements here
9899 // uint64_t CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR arg);
9901 export function CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9902 if(!isWasmInitialized) {
9903 throw new Error("initializeWasm() must be awaited first!");
9905 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg);
9906 return nativeResponseValue;
9908 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR orig);
9910 export function CResult_ChannelFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
9911 if(!isWasmInitialized) {
9912 throw new Error("initializeWasm() must be awaited first!");
9914 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone(orig);
9915 return nativeResponseValue;
9917 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
9919 export function CResult_NodeFeaturesDecodeErrorZ_ok(o: bigint): bigint {
9920 if(!isWasmInitialized) {
9921 throw new Error("initializeWasm() must be awaited first!");
9923 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_ok(o);
9924 return nativeResponseValue;
9926 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
9928 export function CResult_NodeFeaturesDecodeErrorZ_err(e: bigint): bigint {
9929 if(!isWasmInitialized) {
9930 throw new Error("initializeWasm() must be awaited first!");
9932 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_err(e);
9933 return nativeResponseValue;
9935 // bool CResult_NodeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR o);
9937 export function CResult_NodeFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
9938 if(!isWasmInitialized) {
9939 throw new Error("initializeWasm() must be awaited first!");
9941 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(o);
9942 return nativeResponseValue;
9944 // void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
9946 export function CResult_NodeFeaturesDecodeErrorZ_free(_res: bigint): void {
9947 if(!isWasmInitialized) {
9948 throw new Error("initializeWasm() must be awaited first!");
9950 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_free(_res);
9951 // debug statements here
9953 // uint64_t CResult_NodeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR arg);
9955 export function CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9956 if(!isWasmInitialized) {
9957 throw new Error("initializeWasm() must be awaited first!");
9959 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg);
9960 return nativeResponseValue;
9962 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_clone(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR orig);
9964 export function CResult_NodeFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
9965 if(!isWasmInitialized) {
9966 throw new Error("initializeWasm() must be awaited first!");
9968 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone(orig);
9969 return nativeResponseValue;
9971 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_ok(struct LDKInvoiceFeatures o);
9973 export function CResult_InvoiceFeaturesDecodeErrorZ_ok(o: bigint): bigint {
9974 if(!isWasmInitialized) {
9975 throw new Error("initializeWasm() must be awaited first!");
9977 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_ok(o);
9978 return nativeResponseValue;
9980 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
9982 export function CResult_InvoiceFeaturesDecodeErrorZ_err(e: bigint): bigint {
9983 if(!isWasmInitialized) {
9984 throw new Error("initializeWasm() must be awaited first!");
9986 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_err(e);
9987 return nativeResponseValue;
9989 // bool CResult_InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
9991 export function CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
9992 if(!isWasmInitialized) {
9993 throw new Error("initializeWasm() must be awaited first!");
9995 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o);
9996 return nativeResponseValue;
9998 // void CResult_InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_InvoiceFeaturesDecodeErrorZ _res);
10000 export function CResult_InvoiceFeaturesDecodeErrorZ_free(_res: bigint): void {
10001 if(!isWasmInitialized) {
10002 throw new Error("initializeWasm() must be awaited first!");
10004 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_free(_res);
10005 // debug statements here
10007 // uint64_t CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg);
10009 export function CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10010 if(!isWasmInitialized) {
10011 throw new Error("initializeWasm() must be awaited first!");
10013 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg);
10014 return nativeResponseValue;
10016 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_clone(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR orig);
10018 export function CResult_InvoiceFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
10019 if(!isWasmInitialized) {
10020 throw new Error("initializeWasm() must be awaited first!");
10022 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_clone(orig);
10023 return nativeResponseValue;
10025 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_ok(struct LDKChannelTypeFeatures o);
10027 export function CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o: bigint): bigint {
10028 if(!isWasmInitialized) {
10029 throw new Error("initializeWasm() must be awaited first!");
10031 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o);
10032 return nativeResponseValue;
10034 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
10036 export function CResult_ChannelTypeFeaturesDecodeErrorZ_err(e: bigint): bigint {
10037 if(!isWasmInitialized) {
10038 throw new Error("initializeWasm() must be awaited first!");
10040 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(e);
10041 return nativeResponseValue;
10043 // bool CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR o);
10045 export function CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
10046 if(!isWasmInitialized) {
10047 throw new Error("initializeWasm() must be awaited first!");
10049 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o);
10050 return nativeResponseValue;
10052 // void CResult_ChannelTypeFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res);
10054 export function CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res: bigint): void {
10055 if(!isWasmInitialized) {
10056 throw new Error("initializeWasm() must be awaited first!");
10058 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res);
10059 // debug statements here
10061 // uint64_t CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR arg);
10063 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10064 if(!isWasmInitialized) {
10065 throw new Error("initializeWasm() must be awaited first!");
10067 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg);
10068 return nativeResponseValue;
10070 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR orig);
10072 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
10073 if(!isWasmInitialized) {
10074 throw new Error("initializeWasm() must be awaited first!");
10076 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig);
10077 return nativeResponseValue;
10079 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_ok(struct LDKNodeId o);
10081 export function CResult_NodeIdDecodeErrorZ_ok(o: bigint): bigint {
10082 if(!isWasmInitialized) {
10083 throw new Error("initializeWasm() must be awaited first!");
10085 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_ok(o);
10086 return nativeResponseValue;
10088 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_err(struct LDKDecodeError e);
10090 export function CResult_NodeIdDecodeErrorZ_err(e: bigint): bigint {
10091 if(!isWasmInitialized) {
10092 throw new Error("initializeWasm() must be awaited first!");
10094 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_err(e);
10095 return nativeResponseValue;
10097 // bool CResult_NodeIdDecodeErrorZ_is_ok(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR o);
10099 export function CResult_NodeIdDecodeErrorZ_is_ok(o: bigint): boolean {
10100 if(!isWasmInitialized) {
10101 throw new Error("initializeWasm() must be awaited first!");
10103 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_is_ok(o);
10104 return nativeResponseValue;
10106 // void CResult_NodeIdDecodeErrorZ_free(struct LDKCResult_NodeIdDecodeErrorZ _res);
10108 export function CResult_NodeIdDecodeErrorZ_free(_res: bigint): void {
10109 if(!isWasmInitialized) {
10110 throw new Error("initializeWasm() must be awaited first!");
10112 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_free(_res);
10113 // debug statements here
10115 // uint64_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg);
10117 export function CResult_NodeIdDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10118 if(!isWasmInitialized) {
10119 throw new Error("initializeWasm() must be awaited first!");
10121 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone_ptr(arg);
10122 return nativeResponseValue;
10124 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_clone(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR orig);
10126 export function CResult_NodeIdDecodeErrorZ_clone(orig: bigint): bigint {
10127 if(!isWasmInitialized) {
10128 throw new Error("initializeWasm() must be awaited first!");
10130 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone(orig);
10131 return nativeResponseValue;
10133 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_ok(struct LDKCOption_NetworkUpdateZ o);
10135 export function CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o: bigint): bigint {
10136 if(!isWasmInitialized) {
10137 throw new Error("initializeWasm() must be awaited first!");
10139 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o);
10140 return nativeResponseValue;
10142 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_err(struct LDKDecodeError e);
10144 export function CResult_COption_NetworkUpdateZDecodeErrorZ_err(e: bigint): bigint {
10145 if(!isWasmInitialized) {
10146 throw new Error("initializeWasm() must be awaited first!");
10148 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(e);
10149 return nativeResponseValue;
10151 // bool CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR o);
10153 export function CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o: bigint): boolean {
10154 if(!isWasmInitialized) {
10155 throw new Error("initializeWasm() must be awaited first!");
10157 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o);
10158 return nativeResponseValue;
10160 // void CResult_COption_NetworkUpdateZDecodeErrorZ_free(struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res);
10162 export function CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res: bigint): void {
10163 if(!isWasmInitialized) {
10164 throw new Error("initializeWasm() must be awaited first!");
10166 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res);
10167 // debug statements here
10169 // uint64_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg);
10171 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10172 if(!isWasmInitialized) {
10173 throw new Error("initializeWasm() must be awaited first!");
10175 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg);
10176 return nativeResponseValue;
10178 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_clone(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR orig);
10180 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig: bigint): bigint {
10181 if(!isWasmInitialized) {
10182 throw new Error("initializeWasm() must be awaited first!");
10184 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig);
10185 return nativeResponseValue;
10187 // struct LDKCOption_AccessZ COption_AccessZ_some(struct LDKAccess o);
10189 export function COption_AccessZ_some(o: bigint): bigint {
10190 if(!isWasmInitialized) {
10191 throw new Error("initializeWasm() must be awaited first!");
10193 const nativeResponseValue = wasm.TS_COption_AccessZ_some(o);
10194 return nativeResponseValue;
10196 // struct LDKCOption_AccessZ COption_AccessZ_none(void);
10198 export function COption_AccessZ_none(): bigint {
10199 if(!isWasmInitialized) {
10200 throw new Error("initializeWasm() must be awaited first!");
10202 const nativeResponseValue = wasm.TS_COption_AccessZ_none();
10203 return nativeResponseValue;
10205 // void COption_AccessZ_free(struct LDKCOption_AccessZ _res);
10207 export function COption_AccessZ_free(_res: bigint): void {
10208 if(!isWasmInitialized) {
10209 throw new Error("initializeWasm() must be awaited first!");
10211 const nativeResponseValue = wasm.TS_COption_AccessZ_free(_res);
10212 // debug statements here
10214 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
10216 export function CResult_boolLightningErrorZ_ok(o: boolean): bigint {
10217 if(!isWasmInitialized) {
10218 throw new Error("initializeWasm() must be awaited first!");
10220 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_ok(o);
10221 return nativeResponseValue;
10223 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
10225 export function CResult_boolLightningErrorZ_err(e: bigint): bigint {
10226 if(!isWasmInitialized) {
10227 throw new Error("initializeWasm() must be awaited first!");
10229 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_err(e);
10230 return nativeResponseValue;
10232 // bool CResult_boolLightningErrorZ_is_ok(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR o);
10234 export function CResult_boolLightningErrorZ_is_ok(o: bigint): boolean {
10235 if(!isWasmInitialized) {
10236 throw new Error("initializeWasm() must be awaited first!");
10238 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_is_ok(o);
10239 return nativeResponseValue;
10241 // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
10243 export function CResult_boolLightningErrorZ_free(_res: bigint): void {
10244 if(!isWasmInitialized) {
10245 throw new Error("initializeWasm() must be awaited first!");
10247 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_free(_res);
10248 // debug statements here
10250 // uint64_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg);
10252 export function CResult_boolLightningErrorZ_clone_ptr(arg: bigint): bigint {
10253 if(!isWasmInitialized) {
10254 throw new Error("initializeWasm() must be awaited first!");
10256 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone_ptr(arg);
10257 return nativeResponseValue;
10259 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
10261 export function CResult_boolLightningErrorZ_clone(orig: bigint): bigint {
10262 if(!isWasmInitialized) {
10263 throw new Error("initializeWasm() must be awaited first!");
10265 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone(orig);
10266 return nativeResponseValue;
10268 // uint64_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg);
10270 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg: bigint): bigint {
10271 if(!isWasmInitialized) {
10272 throw new Error("initializeWasm() must be awaited first!");
10274 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg);
10275 return nativeResponseValue;
10277 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
10279 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: bigint): bigint {
10280 if(!isWasmInitialized) {
10281 throw new Error("initializeWasm() must be awaited first!");
10283 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig);
10284 return nativeResponseValue;
10286 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
10288 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: bigint, b: bigint, c: bigint): bigint {
10289 if(!isWasmInitialized) {
10290 throw new Error("initializeWasm() must be awaited first!");
10292 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c);
10293 return nativeResponseValue;
10295 // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
10297 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: bigint): void {
10298 if(!isWasmInitialized) {
10299 throw new Error("initializeWasm() must be awaited first!");
10301 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res);
10302 // debug statements here
10304 // struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ o);
10306 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(o: bigint): bigint {
10307 if(!isWasmInitialized) {
10308 throw new Error("initializeWasm() must be awaited first!");
10310 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(o);
10311 return nativeResponseValue;
10313 // struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none(void);
10315 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none(): bigint {
10316 if(!isWasmInitialized) {
10317 throw new Error("initializeWasm() must be awaited first!");
10319 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none();
10320 return nativeResponseValue;
10322 // void COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
10324 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: bigint): void {
10325 if(!isWasmInitialized) {
10326 throw new Error("initializeWasm() must be awaited first!");
10328 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res);
10329 // debug statements here
10331 // uint64_t COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *NONNULL_PTR arg);
10333 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(arg: bigint): bigint {
10334 if(!isWasmInitialized) {
10335 throw new Error("initializeWasm() must be awaited first!");
10337 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(arg);
10338 return nativeResponseValue;
10340 // struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(const struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *NONNULL_PTR orig);
10342 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(orig: bigint): bigint {
10343 if(!isWasmInitialized) {
10344 throw new Error("initializeWasm() must be awaited first!");
10346 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(orig);
10347 return nativeResponseValue;
10349 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
10351 export function CResult_NoneLightningErrorZ_ok(): bigint {
10352 if(!isWasmInitialized) {
10353 throw new Error("initializeWasm() must be awaited first!");
10355 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_ok();
10356 return nativeResponseValue;
10358 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
10360 export function CResult_NoneLightningErrorZ_err(e: bigint): bigint {
10361 if(!isWasmInitialized) {
10362 throw new Error("initializeWasm() must be awaited first!");
10364 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_err(e);
10365 return nativeResponseValue;
10367 // bool CResult_NoneLightningErrorZ_is_ok(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR o);
10369 export function CResult_NoneLightningErrorZ_is_ok(o: bigint): boolean {
10370 if(!isWasmInitialized) {
10371 throw new Error("initializeWasm() must be awaited first!");
10373 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_is_ok(o);
10374 return nativeResponseValue;
10376 // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
10378 export function CResult_NoneLightningErrorZ_free(_res: bigint): void {
10379 if(!isWasmInitialized) {
10380 throw new Error("initializeWasm() must be awaited first!");
10382 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_free(_res);
10383 // debug statements here
10385 // uint64_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg);
10387 export function CResult_NoneLightningErrorZ_clone_ptr(arg: bigint): bigint {
10388 if(!isWasmInitialized) {
10389 throw new Error("initializeWasm() must be awaited first!");
10391 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone_ptr(arg);
10392 return nativeResponseValue;
10394 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
10396 export function CResult_NoneLightningErrorZ_clone(orig: bigint): bigint {
10397 if(!isWasmInitialized) {
10398 throw new Error("initializeWasm() must be awaited first!");
10400 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone(orig);
10401 return nativeResponseValue;
10403 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_ok(struct LDKChannelUpdateInfo o);
10405 export function CResult_ChannelUpdateInfoDecodeErrorZ_ok(o: bigint): bigint {
10406 if(!isWasmInitialized) {
10407 throw new Error("initializeWasm() must be awaited first!");
10409 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok(o);
10410 return nativeResponseValue;
10412 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_err(struct LDKDecodeError e);
10414 export function CResult_ChannelUpdateInfoDecodeErrorZ_err(e: bigint): bigint {
10415 if(!isWasmInitialized) {
10416 throw new Error("initializeWasm() must be awaited first!");
10418 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_err(e);
10419 return nativeResponseValue;
10421 // bool CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR o);
10423 export function CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o: bigint): boolean {
10424 if(!isWasmInitialized) {
10425 throw new Error("initializeWasm() must be awaited first!");
10427 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o);
10428 return nativeResponseValue;
10430 // void CResult_ChannelUpdateInfoDecodeErrorZ_free(struct LDKCResult_ChannelUpdateInfoDecodeErrorZ _res);
10432 export function CResult_ChannelUpdateInfoDecodeErrorZ_free(_res: bigint): void {
10433 if(!isWasmInitialized) {
10434 throw new Error("initializeWasm() must be awaited first!");
10436 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_free(_res);
10437 // debug statements here
10439 // uint64_t CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR arg);
10441 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10442 if(!isWasmInitialized) {
10443 throw new Error("initializeWasm() must be awaited first!");
10445 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg);
10446 return nativeResponseValue;
10448 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR orig);
10450 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig: bigint): bigint {
10451 if(!isWasmInitialized) {
10452 throw new Error("initializeWasm() must be awaited first!");
10454 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig);
10455 return nativeResponseValue;
10457 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
10459 export function CResult_ChannelInfoDecodeErrorZ_ok(o: bigint): bigint {
10460 if(!isWasmInitialized) {
10461 throw new Error("initializeWasm() must be awaited first!");
10463 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_ok(o);
10464 return nativeResponseValue;
10466 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
10468 export function CResult_ChannelInfoDecodeErrorZ_err(e: bigint): bigint {
10469 if(!isWasmInitialized) {
10470 throw new Error("initializeWasm() must be awaited first!");
10472 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_err(e);
10473 return nativeResponseValue;
10475 // bool CResult_ChannelInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR o);
10477 export function CResult_ChannelInfoDecodeErrorZ_is_ok(o: bigint): boolean {
10478 if(!isWasmInitialized) {
10479 throw new Error("initializeWasm() must be awaited first!");
10481 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_is_ok(o);
10482 return nativeResponseValue;
10484 // void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
10486 export function CResult_ChannelInfoDecodeErrorZ_free(_res: bigint): void {
10487 if(!isWasmInitialized) {
10488 throw new Error("initializeWasm() must be awaited first!");
10490 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_free(_res);
10491 // debug statements here
10493 // uint64_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg);
10495 export function CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10496 if(!isWasmInitialized) {
10497 throw new Error("initializeWasm() must be awaited first!");
10499 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg);
10500 return nativeResponseValue;
10502 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
10504 export function CResult_ChannelInfoDecodeErrorZ_clone(orig: bigint): bigint {
10505 if(!isWasmInitialized) {
10506 throw new Error("initializeWasm() must be awaited first!");
10508 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone(orig);
10509 return nativeResponseValue;
10511 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
10513 export function CResult_RoutingFeesDecodeErrorZ_ok(o: bigint): bigint {
10514 if(!isWasmInitialized) {
10515 throw new Error("initializeWasm() must be awaited first!");
10517 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_ok(o);
10518 return nativeResponseValue;
10520 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
10522 export function CResult_RoutingFeesDecodeErrorZ_err(e: bigint): bigint {
10523 if(!isWasmInitialized) {
10524 throw new Error("initializeWasm() must be awaited first!");
10526 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_err(e);
10527 return nativeResponseValue;
10529 // bool CResult_RoutingFeesDecodeErrorZ_is_ok(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR o);
10531 export function CResult_RoutingFeesDecodeErrorZ_is_ok(o: bigint): boolean {
10532 if(!isWasmInitialized) {
10533 throw new Error("initializeWasm() must be awaited first!");
10535 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_is_ok(o);
10536 return nativeResponseValue;
10538 // void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
10540 export function CResult_RoutingFeesDecodeErrorZ_free(_res: bigint): void {
10541 if(!isWasmInitialized) {
10542 throw new Error("initializeWasm() must be awaited first!");
10544 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_free(_res);
10545 // debug statements here
10547 // uint64_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg);
10549 export function CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10550 if(!isWasmInitialized) {
10551 throw new Error("initializeWasm() must be awaited first!");
10553 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg);
10554 return nativeResponseValue;
10556 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
10558 export function CResult_RoutingFeesDecodeErrorZ_clone(orig: bigint): bigint {
10559 if(!isWasmInitialized) {
10560 throw new Error("initializeWasm() must be awaited first!");
10562 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone(orig);
10563 return nativeResponseValue;
10565 // void CVec_NetAddressZ_free(struct LDKCVec_NetAddressZ _res);
10567 export function CVec_NetAddressZ_free(_res: number): void {
10568 if(!isWasmInitialized) {
10569 throw new Error("initializeWasm() must be awaited first!");
10571 const nativeResponseValue = wasm.TS_CVec_NetAddressZ_free(_res);
10572 // debug statements here
10574 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
10576 export function CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o: bigint): bigint {
10577 if(!isWasmInitialized) {
10578 throw new Error("initializeWasm() must be awaited first!");
10580 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o);
10581 return nativeResponseValue;
10583 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
10585 export function CResult_NodeAnnouncementInfoDecodeErrorZ_err(e: bigint): bigint {
10586 if(!isWasmInitialized) {
10587 throw new Error("initializeWasm() must be awaited first!");
10589 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(e);
10590 return nativeResponseValue;
10592 // bool CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR o);
10594 export function CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o: bigint): boolean {
10595 if(!isWasmInitialized) {
10596 throw new Error("initializeWasm() must be awaited first!");
10598 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o);
10599 return nativeResponseValue;
10601 // void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
10603 export function CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res: bigint): void {
10604 if(!isWasmInitialized) {
10605 throw new Error("initializeWasm() must be awaited first!");
10607 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res);
10608 // debug statements here
10610 // uint64_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg);
10612 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10613 if(!isWasmInitialized) {
10614 throw new Error("initializeWasm() must be awaited first!");
10616 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg);
10617 return nativeResponseValue;
10619 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
10621 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: bigint): bigint {
10622 if(!isWasmInitialized) {
10623 throw new Error("initializeWasm() must be awaited first!");
10625 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig);
10626 return nativeResponseValue;
10628 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_ok(struct LDKNodeAlias o);
10630 export function CResult_NodeAliasDecodeErrorZ_ok(o: bigint): bigint {
10631 if(!isWasmInitialized) {
10632 throw new Error("initializeWasm() must be awaited first!");
10634 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_ok(o);
10635 return nativeResponseValue;
10637 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_err(struct LDKDecodeError e);
10639 export function CResult_NodeAliasDecodeErrorZ_err(e: bigint): bigint {
10640 if(!isWasmInitialized) {
10641 throw new Error("initializeWasm() must be awaited first!");
10643 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_err(e);
10644 return nativeResponseValue;
10646 // bool CResult_NodeAliasDecodeErrorZ_is_ok(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR o);
10648 export function CResult_NodeAliasDecodeErrorZ_is_ok(o: bigint): boolean {
10649 if(!isWasmInitialized) {
10650 throw new Error("initializeWasm() must be awaited first!");
10652 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_is_ok(o);
10653 return nativeResponseValue;
10655 // void CResult_NodeAliasDecodeErrorZ_free(struct LDKCResult_NodeAliasDecodeErrorZ _res);
10657 export function CResult_NodeAliasDecodeErrorZ_free(_res: bigint): void {
10658 if(!isWasmInitialized) {
10659 throw new Error("initializeWasm() must be awaited first!");
10661 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_free(_res);
10662 // debug statements here
10664 // uint64_t CResult_NodeAliasDecodeErrorZ_clone_ptr(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR arg);
10666 export function CResult_NodeAliasDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10667 if(!isWasmInitialized) {
10668 throw new Error("initializeWasm() must be awaited first!");
10670 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone_ptr(arg);
10671 return nativeResponseValue;
10673 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_clone(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR orig);
10675 export function CResult_NodeAliasDecodeErrorZ_clone(orig: bigint): bigint {
10676 if(!isWasmInitialized) {
10677 throw new Error("initializeWasm() must be awaited first!");
10679 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone(orig);
10680 return nativeResponseValue;
10682 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_ok(struct LDKNodeInfo o);
10684 export function CResult_NodeInfoDecodeErrorZ_ok(o: bigint): bigint {
10685 if(!isWasmInitialized) {
10686 throw new Error("initializeWasm() must be awaited first!");
10688 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_ok(o);
10689 return nativeResponseValue;
10691 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
10693 export function CResult_NodeInfoDecodeErrorZ_err(e: bigint): bigint {
10694 if(!isWasmInitialized) {
10695 throw new Error("initializeWasm() must be awaited first!");
10697 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_err(e);
10698 return nativeResponseValue;
10700 // bool CResult_NodeInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR o);
10702 export function CResult_NodeInfoDecodeErrorZ_is_ok(o: bigint): boolean {
10703 if(!isWasmInitialized) {
10704 throw new Error("initializeWasm() must be awaited first!");
10706 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_is_ok(o);
10707 return nativeResponseValue;
10709 // void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
10711 export function CResult_NodeInfoDecodeErrorZ_free(_res: bigint): void {
10712 if(!isWasmInitialized) {
10713 throw new Error("initializeWasm() must be awaited first!");
10715 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_free(_res);
10716 // debug statements here
10718 // uint64_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg);
10720 export function CResult_NodeInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10721 if(!isWasmInitialized) {
10722 throw new Error("initializeWasm() must be awaited first!");
10724 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(arg);
10725 return nativeResponseValue;
10727 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
10729 export function CResult_NodeInfoDecodeErrorZ_clone(orig: bigint): bigint {
10730 if(!isWasmInitialized) {
10731 throw new Error("initializeWasm() must be awaited first!");
10733 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone(orig);
10734 return nativeResponseValue;
10736 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
10738 export function CResult_NetworkGraphDecodeErrorZ_ok(o: bigint): bigint {
10739 if(!isWasmInitialized) {
10740 throw new Error("initializeWasm() must be awaited first!");
10742 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_ok(o);
10743 return nativeResponseValue;
10745 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
10747 export function CResult_NetworkGraphDecodeErrorZ_err(e: bigint): bigint {
10748 if(!isWasmInitialized) {
10749 throw new Error("initializeWasm() must be awaited first!");
10751 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_err(e);
10752 return nativeResponseValue;
10754 // bool CResult_NetworkGraphDecodeErrorZ_is_ok(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR o);
10756 export function CResult_NetworkGraphDecodeErrorZ_is_ok(o: bigint): boolean {
10757 if(!isWasmInitialized) {
10758 throw new Error("initializeWasm() must be awaited first!");
10760 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_is_ok(o);
10761 return nativeResponseValue;
10763 // void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
10765 export function CResult_NetworkGraphDecodeErrorZ_free(_res: bigint): void {
10766 if(!isWasmInitialized) {
10767 throw new Error("initializeWasm() must be awaited first!");
10769 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_free(_res);
10770 // debug statements here
10772 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_some(struct LDKCVec_NetAddressZ o);
10774 export function COption_CVec_NetAddressZZ_some(o: number): bigint {
10775 if(!isWasmInitialized) {
10776 throw new Error("initializeWasm() must be awaited first!");
10778 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_some(o);
10779 return nativeResponseValue;
10781 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_none(void);
10783 export function COption_CVec_NetAddressZZ_none(): bigint {
10784 if(!isWasmInitialized) {
10785 throw new Error("initializeWasm() must be awaited first!");
10787 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_none();
10788 return nativeResponseValue;
10790 // void COption_CVec_NetAddressZZ_free(struct LDKCOption_CVec_NetAddressZZ _res);
10792 export function COption_CVec_NetAddressZZ_free(_res: bigint): void {
10793 if(!isWasmInitialized) {
10794 throw new Error("initializeWasm() must be awaited first!");
10796 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_free(_res);
10797 // debug statements here
10799 // uint64_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg);
10801 export function COption_CVec_NetAddressZZ_clone_ptr(arg: bigint): bigint {
10802 if(!isWasmInitialized) {
10803 throw new Error("initializeWasm() must be awaited first!");
10805 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone_ptr(arg);
10806 return nativeResponseValue;
10808 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_clone(const struct LDKCOption_CVec_NetAddressZZ *NONNULL_PTR orig);
10810 export function COption_CVec_NetAddressZZ_clone(orig: bigint): bigint {
10811 if(!isWasmInitialized) {
10812 throw new Error("initializeWasm() must be awaited first!");
10814 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone(orig);
10815 return nativeResponseValue;
10817 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKDelayedPaymentOutputDescriptor o);
10819 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
10820 if(!isWasmInitialized) {
10821 throw new Error("initializeWasm() must be awaited first!");
10823 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o);
10824 return nativeResponseValue;
10826 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
10828 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
10829 if(!isWasmInitialized) {
10830 throw new Error("initializeWasm() must be awaited first!");
10832 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e);
10833 return nativeResponseValue;
10835 // bool CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
10837 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
10838 if(!isWasmInitialized) {
10839 throw new Error("initializeWasm() must be awaited first!");
10841 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
10842 return nativeResponseValue;
10844 // void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res);
10846 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
10847 if(!isWasmInitialized) {
10848 throw new Error("initializeWasm() must be awaited first!");
10850 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res);
10851 // debug statements here
10853 // uint64_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
10855 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10856 if(!isWasmInitialized) {
10857 throw new Error("initializeWasm() must be awaited first!");
10859 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
10860 return nativeResponseValue;
10862 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
10864 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
10865 if(!isWasmInitialized) {
10866 throw new Error("initializeWasm() must be awaited first!");
10868 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig);
10869 return nativeResponseValue;
10871 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKStaticPaymentOutputDescriptor o);
10873 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
10874 if(!isWasmInitialized) {
10875 throw new Error("initializeWasm() must be awaited first!");
10877 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o);
10878 return nativeResponseValue;
10880 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
10882 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
10883 if(!isWasmInitialized) {
10884 throw new Error("initializeWasm() must be awaited first!");
10886 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e);
10887 return nativeResponseValue;
10889 // bool CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
10891 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
10892 if(!isWasmInitialized) {
10893 throw new Error("initializeWasm() must be awaited first!");
10895 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
10896 return nativeResponseValue;
10898 // void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res);
10900 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
10901 if(!isWasmInitialized) {
10902 throw new Error("initializeWasm() must be awaited first!");
10904 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res);
10905 // debug statements here
10907 // uint64_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
10909 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10910 if(!isWasmInitialized) {
10911 throw new Error("initializeWasm() must be awaited first!");
10913 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
10914 return nativeResponseValue;
10916 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
10918 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
10919 if(!isWasmInitialized) {
10920 throw new Error("initializeWasm() must be awaited first!");
10922 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig);
10923 return nativeResponseValue;
10925 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
10927 export function CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
10928 if(!isWasmInitialized) {
10929 throw new Error("initializeWasm() must be awaited first!");
10931 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o);
10932 return nativeResponseValue;
10934 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
10936 export function CResult_SpendableOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
10937 if(!isWasmInitialized) {
10938 throw new Error("initializeWasm() must be awaited first!");
10940 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(e);
10941 return nativeResponseValue;
10943 // bool CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
10945 export function CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
10946 if(!isWasmInitialized) {
10947 throw new Error("initializeWasm() must be awaited first!");
10949 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o);
10950 return nativeResponseValue;
10952 // void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
10954 export function CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
10955 if(!isWasmInitialized) {
10956 throw new Error("initializeWasm() must be awaited first!");
10958 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res);
10959 // debug statements here
10961 // uint64_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
10963 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10964 if(!isWasmInitialized) {
10965 throw new Error("initializeWasm() must be awaited first!");
10967 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg);
10968 return nativeResponseValue;
10970 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
10972 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
10973 if(!isWasmInitialized) {
10974 throw new Error("initializeWasm() must be awaited first!");
10976 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig);
10977 return nativeResponseValue;
10979 // void CVec_PaymentPreimageZ_free(struct LDKCVec_PaymentPreimageZ _res);
10981 export function CVec_PaymentPreimageZ_free(_res: number): void {
10982 if(!isWasmInitialized) {
10983 throw new Error("initializeWasm() must be awaited first!");
10985 const nativeResponseValue = wasm.TS_CVec_PaymentPreimageZ_free(_res);
10986 // debug statements here
10988 // uint64_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg);
10990 export function C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg: bigint): bigint {
10991 if(!isWasmInitialized) {
10992 throw new Error("initializeWasm() must be awaited first!");
10994 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg);
10995 return nativeResponseValue;
10997 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_clone(const struct LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR orig);
10999 export function C2Tuple_SignatureCVec_SignatureZZ_clone(orig: bigint): bigint {
11000 if(!isWasmInitialized) {
11001 throw new Error("initializeWasm() must be awaited first!");
11003 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone(orig);
11004 return nativeResponseValue;
11006 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_new(struct LDKSignature a, struct LDKCVec_SignatureZ b);
11008 export function C2Tuple_SignatureCVec_SignatureZZ_new(a: number, b: number): bigint {
11009 if(!isWasmInitialized) {
11010 throw new Error("initializeWasm() must be awaited first!");
11012 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_new(a, b);
11013 return nativeResponseValue;
11015 // void C2Tuple_SignatureCVec_SignatureZZ_free(struct LDKC2Tuple_SignatureCVec_SignatureZZ _res);
11017 export function C2Tuple_SignatureCVec_SignatureZZ_free(_res: bigint): void {
11018 if(!isWasmInitialized) {
11019 throw new Error("initializeWasm() must be awaited first!");
11021 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_free(_res);
11022 // debug statements here
11024 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(struct LDKC2Tuple_SignatureCVec_SignatureZZ o);
11026 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o: bigint): bigint {
11027 if(!isWasmInitialized) {
11028 throw new Error("initializeWasm() must be awaited first!");
11030 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o);
11031 return nativeResponseValue;
11033 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(void);
11035 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(): bigint {
11036 if(!isWasmInitialized) {
11037 throw new Error("initializeWasm() must be awaited first!");
11039 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
11040 return nativeResponseValue;
11042 // bool CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR o);
11044 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o: bigint): boolean {
11045 if(!isWasmInitialized) {
11046 throw new Error("initializeWasm() must be awaited first!");
11048 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o);
11049 return nativeResponseValue;
11051 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res);
11053 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res: bigint): void {
11054 if(!isWasmInitialized) {
11055 throw new Error("initializeWasm() must be awaited first!");
11057 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res);
11058 // debug statements here
11060 // uint64_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg);
11062 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg: bigint): bigint {
11063 if(!isWasmInitialized) {
11064 throw new Error("initializeWasm() must be awaited first!");
11066 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg);
11067 return nativeResponseValue;
11069 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR orig);
11071 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig: bigint): bigint {
11072 if(!isWasmInitialized) {
11073 throw new Error("initializeWasm() must be awaited first!");
11075 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig);
11076 return nativeResponseValue;
11078 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_ok(struct LDKSignature o);
11080 export function CResult_SignatureNoneZ_ok(o: number): bigint {
11081 if(!isWasmInitialized) {
11082 throw new Error("initializeWasm() must be awaited first!");
11084 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_ok(o);
11085 return nativeResponseValue;
11087 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_err(void);
11089 export function CResult_SignatureNoneZ_err(): bigint {
11090 if(!isWasmInitialized) {
11091 throw new Error("initializeWasm() must be awaited first!");
11093 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_err();
11094 return nativeResponseValue;
11096 // bool CResult_SignatureNoneZ_is_ok(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR o);
11098 export function CResult_SignatureNoneZ_is_ok(o: bigint): boolean {
11099 if(!isWasmInitialized) {
11100 throw new Error("initializeWasm() must be awaited first!");
11102 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_is_ok(o);
11103 return nativeResponseValue;
11105 // void CResult_SignatureNoneZ_free(struct LDKCResult_SignatureNoneZ _res);
11107 export function CResult_SignatureNoneZ_free(_res: bigint): void {
11108 if(!isWasmInitialized) {
11109 throw new Error("initializeWasm() must be awaited first!");
11111 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_free(_res);
11112 // debug statements here
11114 // uint64_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg);
11116 export function CResult_SignatureNoneZ_clone_ptr(arg: bigint): bigint {
11117 if(!isWasmInitialized) {
11118 throw new Error("initializeWasm() must be awaited first!");
11120 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone_ptr(arg);
11121 return nativeResponseValue;
11123 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_clone(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR orig);
11125 export function CResult_SignatureNoneZ_clone(orig: bigint): bigint {
11126 if(!isWasmInitialized) {
11127 throw new Error("initializeWasm() must be awaited first!");
11129 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone(orig);
11130 return nativeResponseValue;
11132 // uint64_t C2Tuple_SignatureSignatureZ_clone_ptr(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR arg);
11134 export function C2Tuple_SignatureSignatureZ_clone_ptr(arg: bigint): bigint {
11135 if(!isWasmInitialized) {
11136 throw new Error("initializeWasm() must be awaited first!");
11138 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_clone_ptr(arg);
11139 return nativeResponseValue;
11141 // struct LDKC2Tuple_SignatureSignatureZ C2Tuple_SignatureSignatureZ_clone(const struct LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR orig);
11143 export function C2Tuple_SignatureSignatureZ_clone(orig: bigint): bigint {
11144 if(!isWasmInitialized) {
11145 throw new Error("initializeWasm() must be awaited first!");
11147 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_clone(orig);
11148 return nativeResponseValue;
11150 // struct LDKC2Tuple_SignatureSignatureZ C2Tuple_SignatureSignatureZ_new(struct LDKSignature a, struct LDKSignature b);
11152 export function C2Tuple_SignatureSignatureZ_new(a: number, b: number): bigint {
11153 if(!isWasmInitialized) {
11154 throw new Error("initializeWasm() must be awaited first!");
11156 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_new(a, b);
11157 return nativeResponseValue;
11159 // void C2Tuple_SignatureSignatureZ_free(struct LDKC2Tuple_SignatureSignatureZ _res);
11161 export function C2Tuple_SignatureSignatureZ_free(_res: bigint): void {
11162 if(!isWasmInitialized) {
11163 throw new Error("initializeWasm() must be awaited first!");
11165 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_free(_res);
11166 // debug statements here
11168 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_ok(struct LDKC2Tuple_SignatureSignatureZ o);
11170 export function CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o: bigint): bigint {
11171 if(!isWasmInitialized) {
11172 throw new Error("initializeWasm() must be awaited first!");
11174 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o);
11175 return nativeResponseValue;
11177 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_err(void);
11179 export function CResult_C2Tuple_SignatureSignatureZNoneZ_err(): bigint {
11180 if(!isWasmInitialized) {
11181 throw new Error("initializeWasm() must be awaited first!");
11183 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_err();
11184 return nativeResponseValue;
11186 // bool CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR o);
11188 export function CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o: bigint): boolean {
11189 if(!isWasmInitialized) {
11190 throw new Error("initializeWasm() must be awaited first!");
11192 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o);
11193 return nativeResponseValue;
11195 // void CResult_C2Tuple_SignatureSignatureZNoneZ_free(struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ _res);
11197 export function CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res: bigint): void {
11198 if(!isWasmInitialized) {
11199 throw new Error("initializeWasm() must be awaited first!");
11201 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res);
11202 // debug statements here
11204 // uint64_t CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR arg);
11206 export function CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg: bigint): bigint {
11207 if(!isWasmInitialized) {
11208 throw new Error("initializeWasm() must be awaited first!");
11210 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg);
11211 return nativeResponseValue;
11213 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR orig);
11215 export function CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig: bigint): bigint {
11216 if(!isWasmInitialized) {
11217 throw new Error("initializeWasm() must be awaited first!");
11219 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig);
11220 return nativeResponseValue;
11222 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_ok(struct LDKSecretKey o);
11224 export function CResult_SecretKeyNoneZ_ok(o: number): bigint {
11225 if(!isWasmInitialized) {
11226 throw new Error("initializeWasm() must be awaited first!");
11228 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_ok(o);
11229 return nativeResponseValue;
11231 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_err(void);
11233 export function CResult_SecretKeyNoneZ_err(): bigint {
11234 if(!isWasmInitialized) {
11235 throw new Error("initializeWasm() must be awaited first!");
11237 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_err();
11238 return nativeResponseValue;
11240 // bool CResult_SecretKeyNoneZ_is_ok(const struct LDKCResult_SecretKeyNoneZ *NONNULL_PTR o);
11242 export function CResult_SecretKeyNoneZ_is_ok(o: bigint): boolean {
11243 if(!isWasmInitialized) {
11244 throw new Error("initializeWasm() must be awaited first!");
11246 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_is_ok(o);
11247 return nativeResponseValue;
11249 // void CResult_SecretKeyNoneZ_free(struct LDKCResult_SecretKeyNoneZ _res);
11251 export function CResult_SecretKeyNoneZ_free(_res: bigint): void {
11252 if(!isWasmInitialized) {
11253 throw new Error("initializeWasm() must be awaited first!");
11255 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_free(_res);
11256 // debug statements here
11258 // uint64_t CResult_SecretKeyNoneZ_clone_ptr(LDKCResult_SecretKeyNoneZ *NONNULL_PTR arg);
11260 export function CResult_SecretKeyNoneZ_clone_ptr(arg: bigint): bigint {
11261 if(!isWasmInitialized) {
11262 throw new Error("initializeWasm() must be awaited first!");
11264 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_clone_ptr(arg);
11265 return nativeResponseValue;
11267 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_clone(const struct LDKCResult_SecretKeyNoneZ *NONNULL_PTR orig);
11269 export function CResult_SecretKeyNoneZ_clone(orig: bigint): bigint {
11270 if(!isWasmInitialized) {
11271 throw new Error("initializeWasm() must be awaited first!");
11273 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_clone(orig);
11274 return nativeResponseValue;
11276 // struct LDKCOption_ScalarZ COption_ScalarZ_some(struct LDKBigEndianScalar o);
11278 export function COption_ScalarZ_some(o: bigint): bigint {
11279 if(!isWasmInitialized) {
11280 throw new Error("initializeWasm() must be awaited first!");
11282 const nativeResponseValue = wasm.TS_COption_ScalarZ_some(o);
11283 return nativeResponseValue;
11285 // struct LDKCOption_ScalarZ COption_ScalarZ_none(void);
11287 export function COption_ScalarZ_none(): bigint {
11288 if(!isWasmInitialized) {
11289 throw new Error("initializeWasm() must be awaited first!");
11291 const nativeResponseValue = wasm.TS_COption_ScalarZ_none();
11292 return nativeResponseValue;
11294 // void COption_ScalarZ_free(struct LDKCOption_ScalarZ _res);
11296 export function COption_ScalarZ_free(_res: bigint): void {
11297 if(!isWasmInitialized) {
11298 throw new Error("initializeWasm() must be awaited first!");
11300 const nativeResponseValue = wasm.TS_COption_ScalarZ_free(_res);
11301 // debug statements here
11303 // struct LDKCResult_SharedSecretNoneZ CResult_SharedSecretNoneZ_ok(struct LDKThirtyTwoBytes o);
11305 export function CResult_SharedSecretNoneZ_ok(o: number): bigint {
11306 if(!isWasmInitialized) {
11307 throw new Error("initializeWasm() must be awaited first!");
11309 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_ok(o);
11310 return nativeResponseValue;
11312 // struct LDKCResult_SharedSecretNoneZ CResult_SharedSecretNoneZ_err(void);
11314 export function CResult_SharedSecretNoneZ_err(): bigint {
11315 if(!isWasmInitialized) {
11316 throw new Error("initializeWasm() must be awaited first!");
11318 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_err();
11319 return nativeResponseValue;
11321 // bool CResult_SharedSecretNoneZ_is_ok(const struct LDKCResult_SharedSecretNoneZ *NONNULL_PTR o);
11323 export function CResult_SharedSecretNoneZ_is_ok(o: bigint): boolean {
11324 if(!isWasmInitialized) {
11325 throw new Error("initializeWasm() must be awaited first!");
11327 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_is_ok(o);
11328 return nativeResponseValue;
11330 // void CResult_SharedSecretNoneZ_free(struct LDKCResult_SharedSecretNoneZ _res);
11332 export function CResult_SharedSecretNoneZ_free(_res: bigint): void {
11333 if(!isWasmInitialized) {
11334 throw new Error("initializeWasm() must be awaited first!");
11336 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_free(_res);
11337 // debug statements here
11339 // uint64_t CResult_SharedSecretNoneZ_clone_ptr(LDKCResult_SharedSecretNoneZ *NONNULL_PTR arg);
11341 export function CResult_SharedSecretNoneZ_clone_ptr(arg: bigint): bigint {
11342 if(!isWasmInitialized) {
11343 throw new Error("initializeWasm() must be awaited first!");
11345 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_clone_ptr(arg);
11346 return nativeResponseValue;
11348 // struct LDKCResult_SharedSecretNoneZ CResult_SharedSecretNoneZ_clone(const struct LDKCResult_SharedSecretNoneZ *NONNULL_PTR orig);
11350 export function CResult_SharedSecretNoneZ_clone(orig: bigint): bigint {
11351 if(!isWasmInitialized) {
11352 throw new Error("initializeWasm() must be awaited first!");
11354 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_clone(orig);
11355 return nativeResponseValue;
11357 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_ok(struct LDKSign o);
11359 export function CResult_SignDecodeErrorZ_ok(o: bigint): bigint {
11360 if(!isWasmInitialized) {
11361 throw new Error("initializeWasm() must be awaited first!");
11363 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_ok(o);
11364 return nativeResponseValue;
11366 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_err(struct LDKDecodeError e);
11368 export function CResult_SignDecodeErrorZ_err(e: bigint): bigint {
11369 if(!isWasmInitialized) {
11370 throw new Error("initializeWasm() must be awaited first!");
11372 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_err(e);
11373 return nativeResponseValue;
11375 // bool CResult_SignDecodeErrorZ_is_ok(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR o);
11377 export function CResult_SignDecodeErrorZ_is_ok(o: bigint): boolean {
11378 if(!isWasmInitialized) {
11379 throw new Error("initializeWasm() must be awaited first!");
11381 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_is_ok(o);
11382 return nativeResponseValue;
11384 // void CResult_SignDecodeErrorZ_free(struct LDKCResult_SignDecodeErrorZ _res);
11386 export function CResult_SignDecodeErrorZ_free(_res: bigint): void {
11387 if(!isWasmInitialized) {
11388 throw new Error("initializeWasm() must be awaited first!");
11390 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_free(_res);
11391 // debug statements here
11393 // uint64_t CResult_SignDecodeErrorZ_clone_ptr(LDKCResult_SignDecodeErrorZ *NONNULL_PTR arg);
11395 export function CResult_SignDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11396 if(!isWasmInitialized) {
11397 throw new Error("initializeWasm() must be awaited first!");
11399 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone_ptr(arg);
11400 return nativeResponseValue;
11402 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_clone(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR orig);
11404 export function CResult_SignDecodeErrorZ_clone(orig: bigint): bigint {
11405 if(!isWasmInitialized) {
11406 throw new Error("initializeWasm() must be awaited first!");
11408 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone(orig);
11409 return nativeResponseValue;
11411 // void CVec_u5Z_free(struct LDKCVec_u5Z _res);
11413 export function CVec_u5Z_free(_res: number): void {
11414 if(!isWasmInitialized) {
11415 throw new Error("initializeWasm() must be awaited first!");
11417 const nativeResponseValue = wasm.TS_CVec_u5Z_free(_res);
11418 // debug statements here
11420 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_ok(struct LDKRecoverableSignature o);
11422 export function CResult_RecoverableSignatureNoneZ_ok(o: number): bigint {
11423 if(!isWasmInitialized) {
11424 throw new Error("initializeWasm() must be awaited first!");
11426 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_ok(o);
11427 return nativeResponseValue;
11429 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_err(void);
11431 export function CResult_RecoverableSignatureNoneZ_err(): bigint {
11432 if(!isWasmInitialized) {
11433 throw new Error("initializeWasm() must be awaited first!");
11435 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_err();
11436 return nativeResponseValue;
11438 // bool CResult_RecoverableSignatureNoneZ_is_ok(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR o);
11440 export function CResult_RecoverableSignatureNoneZ_is_ok(o: bigint): boolean {
11441 if(!isWasmInitialized) {
11442 throw new Error("initializeWasm() must be awaited first!");
11444 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_is_ok(o);
11445 return nativeResponseValue;
11447 // void CResult_RecoverableSignatureNoneZ_free(struct LDKCResult_RecoverableSignatureNoneZ _res);
11449 export function CResult_RecoverableSignatureNoneZ_free(_res: bigint): void {
11450 if(!isWasmInitialized) {
11451 throw new Error("initializeWasm() must be awaited first!");
11453 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_free(_res);
11454 // debug statements here
11456 // uint64_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg);
11458 export function CResult_RecoverableSignatureNoneZ_clone_ptr(arg: bigint): bigint {
11459 if(!isWasmInitialized) {
11460 throw new Error("initializeWasm() must be awaited first!");
11462 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone_ptr(arg);
11463 return nativeResponseValue;
11465 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_clone(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR orig);
11467 export function CResult_RecoverableSignatureNoneZ_clone(orig: bigint): bigint {
11468 if(!isWasmInitialized) {
11469 throw new Error("initializeWasm() must be awaited first!");
11471 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone(orig);
11472 return nativeResponseValue;
11474 // void CVec_u8Z_free(struct LDKCVec_u8Z _res);
11476 export function CVec_u8Z_free(_res: number): void {
11477 if(!isWasmInitialized) {
11478 throw new Error("initializeWasm() must be awaited first!");
11480 const nativeResponseValue = wasm.TS_CVec_u8Z_free(_res);
11481 // debug statements here
11483 // void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
11485 export function CVec_CVec_u8ZZ_free(_res: number): void {
11486 if(!isWasmInitialized) {
11487 throw new Error("initializeWasm() must be awaited first!");
11489 const nativeResponseValue = wasm.TS_CVec_CVec_u8ZZ_free(_res);
11490 // debug statements here
11492 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_ok(struct LDKCVec_CVec_u8ZZ o);
11494 export function CResult_CVec_CVec_u8ZZNoneZ_ok(o: number): bigint {
11495 if(!isWasmInitialized) {
11496 throw new Error("initializeWasm() must be awaited first!");
11498 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_ok(o);
11499 return nativeResponseValue;
11501 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
11503 export function CResult_CVec_CVec_u8ZZNoneZ_err(): bigint {
11504 if(!isWasmInitialized) {
11505 throw new Error("initializeWasm() must be awaited first!");
11507 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_err();
11508 return nativeResponseValue;
11510 // bool CResult_CVec_CVec_u8ZZNoneZ_is_ok(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR o);
11512 export function CResult_CVec_CVec_u8ZZNoneZ_is_ok(o: bigint): boolean {
11513 if(!isWasmInitialized) {
11514 throw new Error("initializeWasm() must be awaited first!");
11516 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(o);
11517 return nativeResponseValue;
11519 // void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
11521 export function CResult_CVec_CVec_u8ZZNoneZ_free(_res: bigint): void {
11522 if(!isWasmInitialized) {
11523 throw new Error("initializeWasm() must be awaited first!");
11525 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_free(_res);
11526 // debug statements here
11528 // uint64_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg);
11530 export function CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg: bigint): bigint {
11531 if(!isWasmInitialized) {
11532 throw new Error("initializeWasm() must be awaited first!");
11534 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg);
11535 return nativeResponseValue;
11537 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
11539 export function CResult_CVec_CVec_u8ZZNoneZ_clone(orig: bigint): bigint {
11540 if(!isWasmInitialized) {
11541 throw new Error("initializeWasm() must be awaited first!");
11543 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone(orig);
11544 return nativeResponseValue;
11546 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
11548 export function CResult_InMemorySignerDecodeErrorZ_ok(o: bigint): bigint {
11549 if(!isWasmInitialized) {
11550 throw new Error("initializeWasm() must be awaited first!");
11552 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_ok(o);
11553 return nativeResponseValue;
11555 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
11557 export function CResult_InMemorySignerDecodeErrorZ_err(e: bigint): bigint {
11558 if(!isWasmInitialized) {
11559 throw new Error("initializeWasm() must be awaited first!");
11561 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_err(e);
11562 return nativeResponseValue;
11564 // bool CResult_InMemorySignerDecodeErrorZ_is_ok(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR o);
11566 export function CResult_InMemorySignerDecodeErrorZ_is_ok(o: bigint): boolean {
11567 if(!isWasmInitialized) {
11568 throw new Error("initializeWasm() must be awaited first!");
11570 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_is_ok(o);
11571 return nativeResponseValue;
11573 // void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
11575 export function CResult_InMemorySignerDecodeErrorZ_free(_res: bigint): void {
11576 if(!isWasmInitialized) {
11577 throw new Error("initializeWasm() must be awaited first!");
11579 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_free(_res);
11580 // debug statements here
11582 // uint64_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg);
11584 export function CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11585 if(!isWasmInitialized) {
11586 throw new Error("initializeWasm() must be awaited first!");
11588 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg);
11589 return nativeResponseValue;
11591 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
11593 export function CResult_InMemorySignerDecodeErrorZ_clone(orig: bigint): bigint {
11594 if(!isWasmInitialized) {
11595 throw new Error("initializeWasm() must be awaited first!");
11597 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone(orig);
11598 return nativeResponseValue;
11600 // void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
11602 export function CVec_TxOutZ_free(_res: number): void {
11603 if(!isWasmInitialized) {
11604 throw new Error("initializeWasm() must be awaited first!");
11606 const nativeResponseValue = wasm.TS_CVec_TxOutZ_free(_res);
11607 // debug statements here
11609 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
11611 export function CResult_TransactionNoneZ_ok(o: number): bigint {
11612 if(!isWasmInitialized) {
11613 throw new Error("initializeWasm() must be awaited first!");
11615 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_ok(o);
11616 return nativeResponseValue;
11618 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
11620 export function CResult_TransactionNoneZ_err(): bigint {
11621 if(!isWasmInitialized) {
11622 throw new Error("initializeWasm() must be awaited first!");
11624 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_err();
11625 return nativeResponseValue;
11627 // bool CResult_TransactionNoneZ_is_ok(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR o);
11629 export function CResult_TransactionNoneZ_is_ok(o: bigint): boolean {
11630 if(!isWasmInitialized) {
11631 throw new Error("initializeWasm() must be awaited first!");
11633 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_is_ok(o);
11634 return nativeResponseValue;
11636 // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
11638 export function CResult_TransactionNoneZ_free(_res: bigint): void {
11639 if(!isWasmInitialized) {
11640 throw new Error("initializeWasm() must be awaited first!");
11642 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_free(_res);
11643 // debug statements here
11645 // uint64_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg);
11647 export function CResult_TransactionNoneZ_clone_ptr(arg: bigint): bigint {
11648 if(!isWasmInitialized) {
11649 throw new Error("initializeWasm() must be awaited first!");
11651 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone_ptr(arg);
11652 return nativeResponseValue;
11654 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_clone(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR orig);
11656 export function CResult_TransactionNoneZ_clone(orig: bigint): bigint {
11657 if(!isWasmInitialized) {
11658 throw new Error("initializeWasm() must be awaited first!");
11660 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone(orig);
11661 return nativeResponseValue;
11663 // struct LDKCOption_u16Z COption_u16Z_some(uint16_t o);
11665 export function COption_u16Z_some(o: number): bigint {
11666 if(!isWasmInitialized) {
11667 throw new Error("initializeWasm() must be awaited first!");
11669 const nativeResponseValue = wasm.TS_COption_u16Z_some(o);
11670 return nativeResponseValue;
11672 // struct LDKCOption_u16Z COption_u16Z_none(void);
11674 export function COption_u16Z_none(): bigint {
11675 if(!isWasmInitialized) {
11676 throw new Error("initializeWasm() must be awaited first!");
11678 const nativeResponseValue = wasm.TS_COption_u16Z_none();
11679 return nativeResponseValue;
11681 // void COption_u16Z_free(struct LDKCOption_u16Z _res);
11683 export function COption_u16Z_free(_res: bigint): void {
11684 if(!isWasmInitialized) {
11685 throw new Error("initializeWasm() must be awaited first!");
11687 const nativeResponseValue = wasm.TS_COption_u16Z_free(_res);
11688 // debug statements here
11690 // uint64_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg);
11692 export function COption_u16Z_clone_ptr(arg: bigint): bigint {
11693 if(!isWasmInitialized) {
11694 throw new Error("initializeWasm() must be awaited first!");
11696 const nativeResponseValue = wasm.TS_COption_u16Z_clone_ptr(arg);
11697 return nativeResponseValue;
11699 // struct LDKCOption_u16Z COption_u16Z_clone(const struct LDKCOption_u16Z *NONNULL_PTR orig);
11701 export function COption_u16Z_clone(orig: bigint): bigint {
11702 if(!isWasmInitialized) {
11703 throw new Error("initializeWasm() must be awaited first!");
11705 const nativeResponseValue = wasm.TS_COption_u16Z_clone(orig);
11706 return nativeResponseValue;
11708 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
11710 export function CResult_NoneAPIErrorZ_ok(): bigint {
11711 if(!isWasmInitialized) {
11712 throw new Error("initializeWasm() must be awaited first!");
11714 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_ok();
11715 return nativeResponseValue;
11717 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
11719 export function CResult_NoneAPIErrorZ_err(e: bigint): bigint {
11720 if(!isWasmInitialized) {
11721 throw new Error("initializeWasm() must be awaited first!");
11723 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_err(e);
11724 return nativeResponseValue;
11726 // bool CResult_NoneAPIErrorZ_is_ok(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR o);
11728 export function CResult_NoneAPIErrorZ_is_ok(o: bigint): boolean {
11729 if(!isWasmInitialized) {
11730 throw new Error("initializeWasm() must be awaited first!");
11732 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_is_ok(o);
11733 return nativeResponseValue;
11735 // void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
11737 export function CResult_NoneAPIErrorZ_free(_res: bigint): void {
11738 if(!isWasmInitialized) {
11739 throw new Error("initializeWasm() must be awaited first!");
11741 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_free(_res);
11742 // debug statements here
11744 // uint64_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg);
11746 export function CResult_NoneAPIErrorZ_clone_ptr(arg: bigint): bigint {
11747 if(!isWasmInitialized) {
11748 throw new Error("initializeWasm() must be awaited first!");
11750 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone_ptr(arg);
11751 return nativeResponseValue;
11753 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
11755 export function CResult_NoneAPIErrorZ_clone(orig: bigint): bigint {
11756 if(!isWasmInitialized) {
11757 throw new Error("initializeWasm() must be awaited first!");
11759 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone(orig);
11760 return nativeResponseValue;
11762 // void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
11764 export function CVec_CResult_NoneAPIErrorZZ_free(_res: number): void {
11765 if(!isWasmInitialized) {
11766 throw new Error("initializeWasm() must be awaited first!");
11768 const nativeResponseValue = wasm.TS_CVec_CResult_NoneAPIErrorZZ_free(_res);
11769 // debug statements here
11771 // void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
11773 export function CVec_APIErrorZ_free(_res: number): void {
11774 if(!isWasmInitialized) {
11775 throw new Error("initializeWasm() must be awaited first!");
11777 const nativeResponseValue = wasm.TS_CVec_APIErrorZ_free(_res);
11778 // debug statements here
11780 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_ok(struct LDKThirtyTwoBytes o);
11782 export function CResult__u832APIErrorZ_ok(o: number): bigint {
11783 if(!isWasmInitialized) {
11784 throw new Error("initializeWasm() must be awaited first!");
11786 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_ok(o);
11787 return nativeResponseValue;
11789 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_err(struct LDKAPIError e);
11791 export function CResult__u832APIErrorZ_err(e: bigint): bigint {
11792 if(!isWasmInitialized) {
11793 throw new Error("initializeWasm() must be awaited first!");
11795 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_err(e);
11796 return nativeResponseValue;
11798 // bool CResult__u832APIErrorZ_is_ok(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR o);
11800 export function CResult__u832APIErrorZ_is_ok(o: bigint): boolean {
11801 if(!isWasmInitialized) {
11802 throw new Error("initializeWasm() must be awaited first!");
11804 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_is_ok(o);
11805 return nativeResponseValue;
11807 // void CResult__u832APIErrorZ_free(struct LDKCResult__u832APIErrorZ _res);
11809 export function CResult__u832APIErrorZ_free(_res: bigint): void {
11810 if(!isWasmInitialized) {
11811 throw new Error("initializeWasm() must be awaited first!");
11813 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_free(_res);
11814 // debug statements here
11816 // uint64_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg);
11818 export function CResult__u832APIErrorZ_clone_ptr(arg: bigint): bigint {
11819 if(!isWasmInitialized) {
11820 throw new Error("initializeWasm() must be awaited first!");
11822 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone_ptr(arg);
11823 return nativeResponseValue;
11825 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_clone(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR orig);
11827 export function CResult__u832APIErrorZ_clone(orig: bigint): bigint {
11828 if(!isWasmInitialized) {
11829 throw new Error("initializeWasm() must be awaited first!");
11831 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone(orig);
11832 return nativeResponseValue;
11834 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_ok(struct LDKThirtyTwoBytes o);
11836 export function CResult_PaymentIdPaymentSendFailureZ_ok(o: number): bigint {
11837 if(!isWasmInitialized) {
11838 throw new Error("initializeWasm() must be awaited first!");
11840 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_ok(o);
11841 return nativeResponseValue;
11843 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
11845 export function CResult_PaymentIdPaymentSendFailureZ_err(e: bigint): bigint {
11846 if(!isWasmInitialized) {
11847 throw new Error("initializeWasm() must be awaited first!");
11849 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_err(e);
11850 return nativeResponseValue;
11852 // bool CResult_PaymentIdPaymentSendFailureZ_is_ok(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR o);
11854 export function CResult_PaymentIdPaymentSendFailureZ_is_ok(o: bigint): boolean {
11855 if(!isWasmInitialized) {
11856 throw new Error("initializeWasm() must be awaited first!");
11858 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_is_ok(o);
11859 return nativeResponseValue;
11861 // void CResult_PaymentIdPaymentSendFailureZ_free(struct LDKCResult_PaymentIdPaymentSendFailureZ _res);
11863 export function CResult_PaymentIdPaymentSendFailureZ_free(_res: bigint): void {
11864 if(!isWasmInitialized) {
11865 throw new Error("initializeWasm() must be awaited first!");
11867 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_free(_res);
11868 // debug statements here
11870 // uint64_t CResult_PaymentIdPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR arg);
11872 export function CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
11873 if(!isWasmInitialized) {
11874 throw new Error("initializeWasm() must be awaited first!");
11876 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg);
11877 return nativeResponseValue;
11879 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_clone(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR orig);
11881 export function CResult_PaymentIdPaymentSendFailureZ_clone(orig: bigint): bigint {
11882 if(!isWasmInitialized) {
11883 throw new Error("initializeWasm() must be awaited first!");
11885 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone(orig);
11886 return nativeResponseValue;
11888 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
11890 export function CResult_NonePaymentSendFailureZ_ok(): bigint {
11891 if(!isWasmInitialized) {
11892 throw new Error("initializeWasm() must be awaited first!");
11894 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_ok();
11895 return nativeResponseValue;
11897 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
11899 export function CResult_NonePaymentSendFailureZ_err(e: bigint): bigint {
11900 if(!isWasmInitialized) {
11901 throw new Error("initializeWasm() must be awaited first!");
11903 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_err(e);
11904 return nativeResponseValue;
11906 // bool CResult_NonePaymentSendFailureZ_is_ok(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR o);
11908 export function CResult_NonePaymentSendFailureZ_is_ok(o: bigint): boolean {
11909 if(!isWasmInitialized) {
11910 throw new Error("initializeWasm() must be awaited first!");
11912 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_is_ok(o);
11913 return nativeResponseValue;
11915 // void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
11917 export function CResult_NonePaymentSendFailureZ_free(_res: bigint): void {
11918 if(!isWasmInitialized) {
11919 throw new Error("initializeWasm() must be awaited first!");
11921 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_free(_res);
11922 // debug statements here
11924 // uint64_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg);
11926 export function CResult_NonePaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
11927 if(!isWasmInitialized) {
11928 throw new Error("initializeWasm() must be awaited first!");
11930 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone_ptr(arg);
11931 return nativeResponseValue;
11933 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
11935 export function CResult_NonePaymentSendFailureZ_clone(orig: bigint): bigint {
11936 if(!isWasmInitialized) {
11937 throw new Error("initializeWasm() must be awaited first!");
11939 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone(orig);
11940 return nativeResponseValue;
11942 // uint64_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg);
11944 export function C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg: bigint): bigint {
11945 if(!isWasmInitialized) {
11946 throw new Error("initializeWasm() must be awaited first!");
11948 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg);
11949 return nativeResponseValue;
11951 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_clone(const struct LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR orig);
11953 export function C2Tuple_PaymentHashPaymentIdZ_clone(orig: bigint): bigint {
11954 if(!isWasmInitialized) {
11955 throw new Error("initializeWasm() must be awaited first!");
11957 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone(orig);
11958 return nativeResponseValue;
11960 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
11962 export function C2Tuple_PaymentHashPaymentIdZ_new(a: number, b: number): bigint {
11963 if(!isWasmInitialized) {
11964 throw new Error("initializeWasm() must be awaited first!");
11966 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_new(a, b);
11967 return nativeResponseValue;
11969 // void C2Tuple_PaymentHashPaymentIdZ_free(struct LDKC2Tuple_PaymentHashPaymentIdZ _res);
11971 export function C2Tuple_PaymentHashPaymentIdZ_free(_res: bigint): void {
11972 if(!isWasmInitialized) {
11973 throw new Error("initializeWasm() must be awaited first!");
11975 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_free(_res);
11976 // debug statements here
11978 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(struct LDKC2Tuple_PaymentHashPaymentIdZ o);
11980 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o: bigint): bigint {
11981 if(!isWasmInitialized) {
11982 throw new Error("initializeWasm() must be awaited first!");
11984 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o);
11985 return nativeResponseValue;
11987 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
11989 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e: bigint): bigint {
11990 if(!isWasmInitialized) {
11991 throw new Error("initializeWasm() must be awaited first!");
11993 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e);
11994 return nativeResponseValue;
11996 // bool CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR o);
11998 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o: bigint): boolean {
11999 if(!isWasmInitialized) {
12000 throw new Error("initializeWasm() must be awaited first!");
12002 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o);
12003 return nativeResponseValue;
12005 // void CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ _res);
12007 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res: bigint): void {
12008 if(!isWasmInitialized) {
12009 throw new Error("initializeWasm() must be awaited first!");
12011 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res);
12012 // debug statements here
12014 // uint64_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg);
12016 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
12017 if(!isWasmInitialized) {
12018 throw new Error("initializeWasm() must be awaited first!");
12020 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg);
12021 return nativeResponseValue;
12023 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR orig);
12025 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig: bigint): bigint {
12026 if(!isWasmInitialized) {
12027 throw new Error("initializeWasm() must be awaited first!");
12029 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig);
12030 return nativeResponseValue;
12032 // void CVec_ThirtyTwoBytesZ_free(struct LDKCVec_ThirtyTwoBytesZ _res);
12034 export function CVec_ThirtyTwoBytesZ_free(_res: number): void {
12035 if(!isWasmInitialized) {
12036 throw new Error("initializeWasm() must be awaited first!");
12038 const nativeResponseValue = wasm.TS_CVec_ThirtyTwoBytesZ_free(_res);
12039 // debug statements here
12041 // uint64_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg);
12043 export function C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg: bigint): bigint {
12044 if(!isWasmInitialized) {
12045 throw new Error("initializeWasm() must be awaited first!");
12047 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg);
12048 return nativeResponseValue;
12050 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_clone(const struct LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR orig);
12052 export function C2Tuple_PaymentHashPaymentSecretZ_clone(orig: bigint): bigint {
12053 if(!isWasmInitialized) {
12054 throw new Error("initializeWasm() must be awaited first!");
12056 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone(orig);
12057 return nativeResponseValue;
12059 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
12061 export function C2Tuple_PaymentHashPaymentSecretZ_new(a: number, b: number): bigint {
12062 if(!isWasmInitialized) {
12063 throw new Error("initializeWasm() must be awaited first!");
12065 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_new(a, b);
12066 return nativeResponseValue;
12068 // void C2Tuple_PaymentHashPaymentSecretZ_free(struct LDKC2Tuple_PaymentHashPaymentSecretZ _res);
12070 export function C2Tuple_PaymentHashPaymentSecretZ_free(_res: bigint): void {
12071 if(!isWasmInitialized) {
12072 throw new Error("initializeWasm() must be awaited first!");
12074 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_free(_res);
12075 // debug statements here
12077 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
12079 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o: bigint): bigint {
12080 if(!isWasmInitialized) {
12081 throw new Error("initializeWasm() must be awaited first!");
12083 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o);
12084 return nativeResponseValue;
12086 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(void);
12088 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(): bigint {
12089 if(!isWasmInitialized) {
12090 throw new Error("initializeWasm() must be awaited first!");
12092 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err();
12093 return nativeResponseValue;
12095 // bool CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR o);
12097 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o: bigint): boolean {
12098 if(!isWasmInitialized) {
12099 throw new Error("initializeWasm() must be awaited first!");
12101 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o);
12102 return nativeResponseValue;
12104 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ _res);
12106 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res: bigint): void {
12107 if(!isWasmInitialized) {
12108 throw new Error("initializeWasm() must be awaited first!");
12110 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res);
12111 // debug statements here
12113 // uint64_t CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR arg);
12115 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg: bigint): bigint {
12116 if(!isWasmInitialized) {
12117 throw new Error("initializeWasm() must be awaited first!");
12119 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg);
12120 return nativeResponseValue;
12122 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR orig);
12124 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig: bigint): bigint {
12125 if(!isWasmInitialized) {
12126 throw new Error("initializeWasm() must be awaited first!");
12128 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig);
12129 return nativeResponseValue;
12131 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
12133 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o: bigint): bigint {
12134 if(!isWasmInitialized) {
12135 throw new Error("initializeWasm() must be awaited first!");
12137 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o);
12138 return nativeResponseValue;
12140 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(struct LDKAPIError e);
12142 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e: bigint): bigint {
12143 if(!isWasmInitialized) {
12144 throw new Error("initializeWasm() must be awaited first!");
12146 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e);
12147 return nativeResponseValue;
12149 // bool CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR o);
12151 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o: bigint): boolean {
12152 if(!isWasmInitialized) {
12153 throw new Error("initializeWasm() must be awaited first!");
12155 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o);
12156 return nativeResponseValue;
12158 // void CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ _res);
12160 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res: bigint): void {
12161 if(!isWasmInitialized) {
12162 throw new Error("initializeWasm() must be awaited first!");
12164 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res);
12165 // debug statements here
12167 // uint64_t CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR arg);
12169 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg: bigint): bigint {
12170 if(!isWasmInitialized) {
12171 throw new Error("initializeWasm() must be awaited first!");
12173 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg);
12174 return nativeResponseValue;
12176 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR orig);
12178 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig: bigint): bigint {
12179 if(!isWasmInitialized) {
12180 throw new Error("initializeWasm() must be awaited first!");
12182 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig);
12183 return nativeResponseValue;
12185 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_ok(struct LDKThirtyTwoBytes o);
12187 export function CResult_PaymentSecretNoneZ_ok(o: number): bigint {
12188 if(!isWasmInitialized) {
12189 throw new Error("initializeWasm() must be awaited first!");
12191 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_ok(o);
12192 return nativeResponseValue;
12194 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_err(void);
12196 export function CResult_PaymentSecretNoneZ_err(): bigint {
12197 if(!isWasmInitialized) {
12198 throw new Error("initializeWasm() must be awaited first!");
12200 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_err();
12201 return nativeResponseValue;
12203 // bool CResult_PaymentSecretNoneZ_is_ok(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR o);
12205 export function CResult_PaymentSecretNoneZ_is_ok(o: bigint): boolean {
12206 if(!isWasmInitialized) {
12207 throw new Error("initializeWasm() must be awaited first!");
12209 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_is_ok(o);
12210 return nativeResponseValue;
12212 // void CResult_PaymentSecretNoneZ_free(struct LDKCResult_PaymentSecretNoneZ _res);
12214 export function CResult_PaymentSecretNoneZ_free(_res: bigint): void {
12215 if(!isWasmInitialized) {
12216 throw new Error("initializeWasm() must be awaited first!");
12218 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_free(_res);
12219 // debug statements here
12221 // uint64_t CResult_PaymentSecretNoneZ_clone_ptr(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR arg);
12223 export function CResult_PaymentSecretNoneZ_clone_ptr(arg: bigint): bigint {
12224 if(!isWasmInitialized) {
12225 throw new Error("initializeWasm() must be awaited first!");
12227 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone_ptr(arg);
12228 return nativeResponseValue;
12230 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_clone(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR orig);
12232 export function CResult_PaymentSecretNoneZ_clone(orig: bigint): bigint {
12233 if(!isWasmInitialized) {
12234 throw new Error("initializeWasm() must be awaited first!");
12236 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone(orig);
12237 return nativeResponseValue;
12239 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
12241 export function CResult_PaymentSecretAPIErrorZ_ok(o: number): bigint {
12242 if(!isWasmInitialized) {
12243 throw new Error("initializeWasm() must be awaited first!");
12245 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_ok(o);
12246 return nativeResponseValue;
12248 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_err(struct LDKAPIError e);
12250 export function CResult_PaymentSecretAPIErrorZ_err(e: bigint): bigint {
12251 if(!isWasmInitialized) {
12252 throw new Error("initializeWasm() must be awaited first!");
12254 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_err(e);
12255 return nativeResponseValue;
12257 // bool CResult_PaymentSecretAPIErrorZ_is_ok(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR o);
12259 export function CResult_PaymentSecretAPIErrorZ_is_ok(o: bigint): boolean {
12260 if(!isWasmInitialized) {
12261 throw new Error("initializeWasm() must be awaited first!");
12263 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_is_ok(o);
12264 return nativeResponseValue;
12266 // void CResult_PaymentSecretAPIErrorZ_free(struct LDKCResult_PaymentSecretAPIErrorZ _res);
12268 export function CResult_PaymentSecretAPIErrorZ_free(_res: bigint): void {
12269 if(!isWasmInitialized) {
12270 throw new Error("initializeWasm() must be awaited first!");
12272 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_free(_res);
12273 // debug statements here
12275 // uint64_t CResult_PaymentSecretAPIErrorZ_clone_ptr(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR arg);
12277 export function CResult_PaymentSecretAPIErrorZ_clone_ptr(arg: bigint): bigint {
12278 if(!isWasmInitialized) {
12279 throw new Error("initializeWasm() must be awaited first!");
12281 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone_ptr(arg);
12282 return nativeResponseValue;
12284 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_clone(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR orig);
12286 export function CResult_PaymentSecretAPIErrorZ_clone(orig: bigint): bigint {
12287 if(!isWasmInitialized) {
12288 throw new Error("initializeWasm() must be awaited first!");
12290 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone(orig);
12291 return nativeResponseValue;
12293 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
12295 export function CResult_PaymentPreimageAPIErrorZ_ok(o: number): bigint {
12296 if(!isWasmInitialized) {
12297 throw new Error("initializeWasm() must be awaited first!");
12299 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_ok(o);
12300 return nativeResponseValue;
12302 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_err(struct LDKAPIError e);
12304 export function CResult_PaymentPreimageAPIErrorZ_err(e: bigint): bigint {
12305 if(!isWasmInitialized) {
12306 throw new Error("initializeWasm() must be awaited first!");
12308 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_err(e);
12309 return nativeResponseValue;
12311 // bool CResult_PaymentPreimageAPIErrorZ_is_ok(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR o);
12313 export function CResult_PaymentPreimageAPIErrorZ_is_ok(o: bigint): boolean {
12314 if(!isWasmInitialized) {
12315 throw new Error("initializeWasm() must be awaited first!");
12317 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_is_ok(o);
12318 return nativeResponseValue;
12320 // void CResult_PaymentPreimageAPIErrorZ_free(struct LDKCResult_PaymentPreimageAPIErrorZ _res);
12322 export function CResult_PaymentPreimageAPIErrorZ_free(_res: bigint): void {
12323 if(!isWasmInitialized) {
12324 throw new Error("initializeWasm() must be awaited first!");
12326 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_free(_res);
12327 // debug statements here
12329 // uint64_t CResult_PaymentPreimageAPIErrorZ_clone_ptr(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR arg);
12331 export function CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg: bigint): bigint {
12332 if(!isWasmInitialized) {
12333 throw new Error("initializeWasm() must be awaited first!");
12335 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg);
12336 return nativeResponseValue;
12338 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_clone(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR orig);
12340 export function CResult_PaymentPreimageAPIErrorZ_clone(orig: bigint): bigint {
12341 if(!isWasmInitialized) {
12342 throw new Error("initializeWasm() must be awaited first!");
12344 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone(orig);
12345 return nativeResponseValue;
12347 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(struct LDKCounterpartyForwardingInfo o);
12349 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o: bigint): bigint {
12350 if(!isWasmInitialized) {
12351 throw new Error("initializeWasm() must be awaited first!");
12353 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o);
12354 return nativeResponseValue;
12356 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_err(struct LDKDecodeError e);
12358 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e: bigint): bigint {
12359 if(!isWasmInitialized) {
12360 throw new Error("initializeWasm() must be awaited first!");
12362 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e);
12363 return nativeResponseValue;
12365 // bool CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR o);
12367 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o: bigint): boolean {
12368 if(!isWasmInitialized) {
12369 throw new Error("initializeWasm() must be awaited first!");
12371 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o);
12372 return nativeResponseValue;
12374 // void CResult_CounterpartyForwardingInfoDecodeErrorZ_free(struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ _res);
12376 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res: bigint): void {
12377 if(!isWasmInitialized) {
12378 throw new Error("initializeWasm() must be awaited first!");
12380 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res);
12381 // debug statements here
12383 // uint64_t CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR arg);
12385 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12386 if(!isWasmInitialized) {
12387 throw new Error("initializeWasm() must be awaited first!");
12389 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg);
12390 return nativeResponseValue;
12392 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR orig);
12394 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig: bigint): bigint {
12395 if(!isWasmInitialized) {
12396 throw new Error("initializeWasm() must be awaited first!");
12398 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig);
12399 return nativeResponseValue;
12401 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_ok(struct LDKChannelCounterparty o);
12403 export function CResult_ChannelCounterpartyDecodeErrorZ_ok(o: bigint): bigint {
12404 if(!isWasmInitialized) {
12405 throw new Error("initializeWasm() must be awaited first!");
12407 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_ok(o);
12408 return nativeResponseValue;
12410 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_err(struct LDKDecodeError e);
12412 export function CResult_ChannelCounterpartyDecodeErrorZ_err(e: bigint): bigint {
12413 if(!isWasmInitialized) {
12414 throw new Error("initializeWasm() must be awaited first!");
12416 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_err(e);
12417 return nativeResponseValue;
12419 // bool CResult_ChannelCounterpartyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR o);
12421 export function CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o: bigint): boolean {
12422 if(!isWasmInitialized) {
12423 throw new Error("initializeWasm() must be awaited first!");
12425 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o);
12426 return nativeResponseValue;
12428 // void CResult_ChannelCounterpartyDecodeErrorZ_free(struct LDKCResult_ChannelCounterpartyDecodeErrorZ _res);
12430 export function CResult_ChannelCounterpartyDecodeErrorZ_free(_res: bigint): void {
12431 if(!isWasmInitialized) {
12432 throw new Error("initializeWasm() must be awaited first!");
12434 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_free(_res);
12435 // debug statements here
12437 // uint64_t CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR arg);
12439 export function CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12440 if(!isWasmInitialized) {
12441 throw new Error("initializeWasm() must be awaited first!");
12443 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg);
12444 return nativeResponseValue;
12446 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_clone(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR orig);
12448 export function CResult_ChannelCounterpartyDecodeErrorZ_clone(orig: bigint): bigint {
12449 if(!isWasmInitialized) {
12450 throw new Error("initializeWasm() must be awaited first!");
12452 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone(orig);
12453 return nativeResponseValue;
12455 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_ok(struct LDKChannelDetails o);
12457 export function CResult_ChannelDetailsDecodeErrorZ_ok(o: bigint): bigint {
12458 if(!isWasmInitialized) {
12459 throw new Error("initializeWasm() must be awaited first!");
12461 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_ok(o);
12462 return nativeResponseValue;
12464 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_err(struct LDKDecodeError e);
12466 export function CResult_ChannelDetailsDecodeErrorZ_err(e: bigint): bigint {
12467 if(!isWasmInitialized) {
12468 throw new Error("initializeWasm() must be awaited first!");
12470 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_err(e);
12471 return nativeResponseValue;
12473 // bool CResult_ChannelDetailsDecodeErrorZ_is_ok(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR o);
12475 export function CResult_ChannelDetailsDecodeErrorZ_is_ok(o: bigint): boolean {
12476 if(!isWasmInitialized) {
12477 throw new Error("initializeWasm() must be awaited first!");
12479 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_is_ok(o);
12480 return nativeResponseValue;
12482 // void CResult_ChannelDetailsDecodeErrorZ_free(struct LDKCResult_ChannelDetailsDecodeErrorZ _res);
12484 export function CResult_ChannelDetailsDecodeErrorZ_free(_res: bigint): void {
12485 if(!isWasmInitialized) {
12486 throw new Error("initializeWasm() must be awaited first!");
12488 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_free(_res);
12489 // debug statements here
12491 // uint64_t CResult_ChannelDetailsDecodeErrorZ_clone_ptr(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR arg);
12493 export function CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12494 if(!isWasmInitialized) {
12495 throw new Error("initializeWasm() must be awaited first!");
12497 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg);
12498 return nativeResponseValue;
12500 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_clone(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR orig);
12502 export function CResult_ChannelDetailsDecodeErrorZ_clone(orig: bigint): bigint {
12503 if(!isWasmInitialized) {
12504 throw new Error("initializeWasm() must be awaited first!");
12506 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone(orig);
12507 return nativeResponseValue;
12509 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_ok(struct LDKPhantomRouteHints o);
12511 export function CResult_PhantomRouteHintsDecodeErrorZ_ok(o: bigint): bigint {
12512 if(!isWasmInitialized) {
12513 throw new Error("initializeWasm() must be awaited first!");
12515 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_ok(o);
12516 return nativeResponseValue;
12518 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_err(struct LDKDecodeError e);
12520 export function CResult_PhantomRouteHintsDecodeErrorZ_err(e: bigint): bigint {
12521 if(!isWasmInitialized) {
12522 throw new Error("initializeWasm() must be awaited first!");
12524 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_err(e);
12525 return nativeResponseValue;
12527 // bool CResult_PhantomRouteHintsDecodeErrorZ_is_ok(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR o);
12529 export function CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o: bigint): boolean {
12530 if(!isWasmInitialized) {
12531 throw new Error("initializeWasm() must be awaited first!");
12533 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o);
12534 return nativeResponseValue;
12536 // void CResult_PhantomRouteHintsDecodeErrorZ_free(struct LDKCResult_PhantomRouteHintsDecodeErrorZ _res);
12538 export function CResult_PhantomRouteHintsDecodeErrorZ_free(_res: bigint): void {
12539 if(!isWasmInitialized) {
12540 throw new Error("initializeWasm() must be awaited first!");
12542 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_free(_res);
12543 // debug statements here
12545 // uint64_t CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR arg);
12547 export function CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12548 if(!isWasmInitialized) {
12549 throw new Error("initializeWasm() must be awaited first!");
12551 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg);
12552 return nativeResponseValue;
12554 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_clone(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR orig);
12556 export function CResult_PhantomRouteHintsDecodeErrorZ_clone(orig: bigint): bigint {
12557 if(!isWasmInitialized) {
12558 throw new Error("initializeWasm() must be awaited first!");
12560 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone(orig);
12561 return nativeResponseValue;
12563 // void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
12565 export function CVec_ChannelMonitorZ_free(_res: number): void {
12566 if(!isWasmInitialized) {
12567 throw new Error("initializeWasm() must be awaited first!");
12569 const nativeResponseValue = wasm.TS_CVec_ChannelMonitorZ_free(_res);
12570 // debug statements here
12572 // struct LDKC2Tuple_BlockHashChannelManagerZ C2Tuple_BlockHashChannelManagerZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelManager b);
12574 export function C2Tuple_BlockHashChannelManagerZ_new(a: number, b: bigint): bigint {
12575 if(!isWasmInitialized) {
12576 throw new Error("initializeWasm() must be awaited first!");
12578 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_new(a, b);
12579 return nativeResponseValue;
12581 // void C2Tuple_BlockHashChannelManagerZ_free(struct LDKC2Tuple_BlockHashChannelManagerZ _res);
12583 export function C2Tuple_BlockHashChannelManagerZ_free(_res: bigint): void {
12584 if(!isWasmInitialized) {
12585 throw new Error("initializeWasm() must be awaited first!");
12587 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_free(_res);
12588 // debug statements here
12590 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelManagerZ o);
12592 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o: bigint): bigint {
12593 if(!isWasmInitialized) {
12594 throw new Error("initializeWasm() must be awaited first!");
12596 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o);
12597 return nativeResponseValue;
12599 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
12601 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e: bigint): bigint {
12602 if(!isWasmInitialized) {
12603 throw new Error("initializeWasm() must be awaited first!");
12605 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e);
12606 return nativeResponseValue;
12608 // bool CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR o);
12610 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o: bigint): boolean {
12611 if(!isWasmInitialized) {
12612 throw new Error("initializeWasm() must be awaited first!");
12614 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o);
12615 return nativeResponseValue;
12617 // void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res);
12619 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res: bigint): void {
12620 if(!isWasmInitialized) {
12621 throw new Error("initializeWasm() must be awaited first!");
12623 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res);
12624 // debug statements here
12626 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
12628 export function CResult_ChannelConfigDecodeErrorZ_ok(o: bigint): bigint {
12629 if(!isWasmInitialized) {
12630 throw new Error("initializeWasm() must be awaited first!");
12632 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_ok(o);
12633 return nativeResponseValue;
12635 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
12637 export function CResult_ChannelConfigDecodeErrorZ_err(e: bigint): bigint {
12638 if(!isWasmInitialized) {
12639 throw new Error("initializeWasm() must be awaited first!");
12641 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_err(e);
12642 return nativeResponseValue;
12644 // bool CResult_ChannelConfigDecodeErrorZ_is_ok(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR o);
12646 export function CResult_ChannelConfigDecodeErrorZ_is_ok(o: bigint): boolean {
12647 if(!isWasmInitialized) {
12648 throw new Error("initializeWasm() must be awaited first!");
12650 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_is_ok(o);
12651 return nativeResponseValue;
12653 // void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
12655 export function CResult_ChannelConfigDecodeErrorZ_free(_res: bigint): void {
12656 if(!isWasmInitialized) {
12657 throw new Error("initializeWasm() must be awaited first!");
12659 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_free(_res);
12660 // debug statements here
12662 // uint64_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg);
12664 export function CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12665 if(!isWasmInitialized) {
12666 throw new Error("initializeWasm() must be awaited first!");
12668 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg);
12669 return nativeResponseValue;
12671 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
12673 export function CResult_ChannelConfigDecodeErrorZ_clone(orig: bigint): bigint {
12674 if(!isWasmInitialized) {
12675 throw new Error("initializeWasm() must be awaited first!");
12677 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone(orig);
12678 return nativeResponseValue;
12680 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
12682 export function CResult_OutPointDecodeErrorZ_ok(o: bigint): bigint {
12683 if(!isWasmInitialized) {
12684 throw new Error("initializeWasm() must be awaited first!");
12686 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_ok(o);
12687 return nativeResponseValue;
12689 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
12691 export function CResult_OutPointDecodeErrorZ_err(e: bigint): bigint {
12692 if(!isWasmInitialized) {
12693 throw new Error("initializeWasm() must be awaited first!");
12695 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_err(e);
12696 return nativeResponseValue;
12698 // bool CResult_OutPointDecodeErrorZ_is_ok(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR o);
12700 export function CResult_OutPointDecodeErrorZ_is_ok(o: bigint): boolean {
12701 if(!isWasmInitialized) {
12702 throw new Error("initializeWasm() must be awaited first!");
12704 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_is_ok(o);
12705 return nativeResponseValue;
12707 // void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
12709 export function CResult_OutPointDecodeErrorZ_free(_res: bigint): void {
12710 if(!isWasmInitialized) {
12711 throw new Error("initializeWasm() must be awaited first!");
12713 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_free(_res);
12714 // debug statements here
12716 // uint64_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg);
12718 export function CResult_OutPointDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12719 if(!isWasmInitialized) {
12720 throw new Error("initializeWasm() must be awaited first!");
12722 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone_ptr(arg);
12723 return nativeResponseValue;
12725 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
12727 export function CResult_OutPointDecodeErrorZ_clone(orig: bigint): bigint {
12728 if(!isWasmInitialized) {
12729 throw new Error("initializeWasm() must be awaited first!");
12731 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone(orig);
12732 return nativeResponseValue;
12734 // struct LDKCOption_TypeZ COption_TypeZ_some(struct LDKType o);
12736 export function COption_TypeZ_some(o: bigint): bigint {
12737 if(!isWasmInitialized) {
12738 throw new Error("initializeWasm() must be awaited first!");
12740 const nativeResponseValue = wasm.TS_COption_TypeZ_some(o);
12741 return nativeResponseValue;
12743 // struct LDKCOption_TypeZ COption_TypeZ_none(void);
12745 export function COption_TypeZ_none(): bigint {
12746 if(!isWasmInitialized) {
12747 throw new Error("initializeWasm() must be awaited first!");
12749 const nativeResponseValue = wasm.TS_COption_TypeZ_none();
12750 return nativeResponseValue;
12752 // void COption_TypeZ_free(struct LDKCOption_TypeZ _res);
12754 export function COption_TypeZ_free(_res: bigint): void {
12755 if(!isWasmInitialized) {
12756 throw new Error("initializeWasm() must be awaited first!");
12758 const nativeResponseValue = wasm.TS_COption_TypeZ_free(_res);
12759 // debug statements here
12761 // uint64_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg);
12763 export function COption_TypeZ_clone_ptr(arg: bigint): bigint {
12764 if(!isWasmInitialized) {
12765 throw new Error("initializeWasm() must be awaited first!");
12767 const nativeResponseValue = wasm.TS_COption_TypeZ_clone_ptr(arg);
12768 return nativeResponseValue;
12770 // struct LDKCOption_TypeZ COption_TypeZ_clone(const struct LDKCOption_TypeZ *NONNULL_PTR orig);
12772 export function COption_TypeZ_clone(orig: bigint): bigint {
12773 if(!isWasmInitialized) {
12774 throw new Error("initializeWasm() must be awaited first!");
12776 const nativeResponseValue = wasm.TS_COption_TypeZ_clone(orig);
12777 return nativeResponseValue;
12779 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_ok(struct LDKCOption_TypeZ o);
12781 export function CResult_COption_TypeZDecodeErrorZ_ok(o: bigint): bigint {
12782 if(!isWasmInitialized) {
12783 throw new Error("initializeWasm() must be awaited first!");
12785 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_ok(o);
12786 return nativeResponseValue;
12788 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_err(struct LDKDecodeError e);
12790 export function CResult_COption_TypeZDecodeErrorZ_err(e: bigint): bigint {
12791 if(!isWasmInitialized) {
12792 throw new Error("initializeWasm() must be awaited first!");
12794 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_err(e);
12795 return nativeResponseValue;
12797 // bool CResult_COption_TypeZDecodeErrorZ_is_ok(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR o);
12799 export function CResult_COption_TypeZDecodeErrorZ_is_ok(o: bigint): boolean {
12800 if(!isWasmInitialized) {
12801 throw new Error("initializeWasm() must be awaited first!");
12803 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_is_ok(o);
12804 return nativeResponseValue;
12806 // void CResult_COption_TypeZDecodeErrorZ_free(struct LDKCResult_COption_TypeZDecodeErrorZ _res);
12808 export function CResult_COption_TypeZDecodeErrorZ_free(_res: bigint): void {
12809 if(!isWasmInitialized) {
12810 throw new Error("initializeWasm() must be awaited first!");
12812 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_free(_res);
12813 // debug statements here
12815 // uint64_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg);
12817 export function CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12818 if(!isWasmInitialized) {
12819 throw new Error("initializeWasm() must be awaited first!");
12821 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg);
12822 return nativeResponseValue;
12824 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_clone(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR orig);
12826 export function CResult_COption_TypeZDecodeErrorZ_clone(orig: bigint): bigint {
12827 if(!isWasmInitialized) {
12828 throw new Error("initializeWasm() must be awaited first!");
12830 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone(orig);
12831 return nativeResponseValue;
12833 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_ok(struct LDKThirtyTwoBytes o);
12835 export function CResult_PaymentIdPaymentErrorZ_ok(o: number): bigint {
12836 if(!isWasmInitialized) {
12837 throw new Error("initializeWasm() must be awaited first!");
12839 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_ok(o);
12840 return nativeResponseValue;
12842 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_err(struct LDKPaymentError e);
12844 export function CResult_PaymentIdPaymentErrorZ_err(e: bigint): bigint {
12845 if(!isWasmInitialized) {
12846 throw new Error("initializeWasm() must be awaited first!");
12848 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_err(e);
12849 return nativeResponseValue;
12851 // bool CResult_PaymentIdPaymentErrorZ_is_ok(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR o);
12853 export function CResult_PaymentIdPaymentErrorZ_is_ok(o: bigint): boolean {
12854 if(!isWasmInitialized) {
12855 throw new Error("initializeWasm() must be awaited first!");
12857 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_is_ok(o);
12858 return nativeResponseValue;
12860 // void CResult_PaymentIdPaymentErrorZ_free(struct LDKCResult_PaymentIdPaymentErrorZ _res);
12862 export function CResult_PaymentIdPaymentErrorZ_free(_res: bigint): void {
12863 if(!isWasmInitialized) {
12864 throw new Error("initializeWasm() must be awaited first!");
12866 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_free(_res);
12867 // debug statements here
12869 // uint64_t CResult_PaymentIdPaymentErrorZ_clone_ptr(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR arg);
12871 export function CResult_PaymentIdPaymentErrorZ_clone_ptr(arg: bigint): bigint {
12872 if(!isWasmInitialized) {
12873 throw new Error("initializeWasm() must be awaited first!");
12875 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone_ptr(arg);
12876 return nativeResponseValue;
12878 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_clone(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR orig);
12880 export function CResult_PaymentIdPaymentErrorZ_clone(orig: bigint): bigint {
12881 if(!isWasmInitialized) {
12882 throw new Error("initializeWasm() must be awaited first!");
12884 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone(orig);
12885 return nativeResponseValue;
12887 // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_ok(struct LDKInFlightHtlcs o);
12889 export function CResult_InFlightHtlcsDecodeErrorZ_ok(o: bigint): bigint {
12890 if(!isWasmInitialized) {
12891 throw new Error("initializeWasm() must be awaited first!");
12893 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_ok(o);
12894 return nativeResponseValue;
12896 // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_err(struct LDKDecodeError e);
12898 export function CResult_InFlightHtlcsDecodeErrorZ_err(e: bigint): bigint {
12899 if(!isWasmInitialized) {
12900 throw new Error("initializeWasm() must be awaited first!");
12902 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_err(e);
12903 return nativeResponseValue;
12905 // bool CResult_InFlightHtlcsDecodeErrorZ_is_ok(const struct LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR o);
12907 export function CResult_InFlightHtlcsDecodeErrorZ_is_ok(o: bigint): boolean {
12908 if(!isWasmInitialized) {
12909 throw new Error("initializeWasm() must be awaited first!");
12911 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_is_ok(o);
12912 return nativeResponseValue;
12914 // void CResult_InFlightHtlcsDecodeErrorZ_free(struct LDKCResult_InFlightHtlcsDecodeErrorZ _res);
12916 export function CResult_InFlightHtlcsDecodeErrorZ_free(_res: bigint): void {
12917 if(!isWasmInitialized) {
12918 throw new Error("initializeWasm() must be awaited first!");
12920 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_free(_res);
12921 // debug statements here
12923 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_ok(enum LDKSiPrefix o);
12925 export function CResult_SiPrefixParseErrorZ_ok(o: SiPrefix): bigint {
12926 if(!isWasmInitialized) {
12927 throw new Error("initializeWasm() must be awaited first!");
12929 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_ok(o);
12930 return nativeResponseValue;
12932 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_err(struct LDKParseError e);
12934 export function CResult_SiPrefixParseErrorZ_err(e: bigint): bigint {
12935 if(!isWasmInitialized) {
12936 throw new Error("initializeWasm() must be awaited first!");
12938 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_err(e);
12939 return nativeResponseValue;
12941 // bool CResult_SiPrefixParseErrorZ_is_ok(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR o);
12943 export function CResult_SiPrefixParseErrorZ_is_ok(o: bigint): boolean {
12944 if(!isWasmInitialized) {
12945 throw new Error("initializeWasm() must be awaited first!");
12947 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_is_ok(o);
12948 return nativeResponseValue;
12950 // void CResult_SiPrefixParseErrorZ_free(struct LDKCResult_SiPrefixParseErrorZ _res);
12952 export function CResult_SiPrefixParseErrorZ_free(_res: bigint): void {
12953 if(!isWasmInitialized) {
12954 throw new Error("initializeWasm() must be awaited first!");
12956 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_free(_res);
12957 // debug statements here
12959 // uint64_t CResult_SiPrefixParseErrorZ_clone_ptr(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR arg);
12961 export function CResult_SiPrefixParseErrorZ_clone_ptr(arg: bigint): bigint {
12962 if(!isWasmInitialized) {
12963 throw new Error("initializeWasm() must be awaited first!");
12965 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone_ptr(arg);
12966 return nativeResponseValue;
12968 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_clone(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR orig);
12970 export function CResult_SiPrefixParseErrorZ_clone(orig: bigint): bigint {
12971 if(!isWasmInitialized) {
12972 throw new Error("initializeWasm() must be awaited first!");
12974 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone(orig);
12975 return nativeResponseValue;
12977 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_ok(struct LDKInvoice o);
12979 export function CResult_InvoiceParseOrSemanticErrorZ_ok(o: bigint): bigint {
12980 if(!isWasmInitialized) {
12981 throw new Error("initializeWasm() must be awaited first!");
12983 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_ok(o);
12984 return nativeResponseValue;
12986 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_err(struct LDKParseOrSemanticError e);
12988 export function CResult_InvoiceParseOrSemanticErrorZ_err(e: bigint): bigint {
12989 if(!isWasmInitialized) {
12990 throw new Error("initializeWasm() must be awaited first!");
12992 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_err(e);
12993 return nativeResponseValue;
12995 // bool CResult_InvoiceParseOrSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR o);
12997 export function CResult_InvoiceParseOrSemanticErrorZ_is_ok(o: bigint): boolean {
12998 if(!isWasmInitialized) {
12999 throw new Error("initializeWasm() must be awaited first!");
13001 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_is_ok(o);
13002 return nativeResponseValue;
13004 // void CResult_InvoiceParseOrSemanticErrorZ_free(struct LDKCResult_InvoiceParseOrSemanticErrorZ _res);
13006 export function CResult_InvoiceParseOrSemanticErrorZ_free(_res: bigint): void {
13007 if(!isWasmInitialized) {
13008 throw new Error("initializeWasm() must be awaited first!");
13010 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_free(_res);
13011 // debug statements here
13013 // uint64_t CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR arg);
13015 export function CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg: bigint): bigint {
13016 if(!isWasmInitialized) {
13017 throw new Error("initializeWasm() must be awaited first!");
13019 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg);
13020 return nativeResponseValue;
13022 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_clone(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR orig);
13024 export function CResult_InvoiceParseOrSemanticErrorZ_clone(orig: bigint): bigint {
13025 if(!isWasmInitialized) {
13026 throw new Error("initializeWasm() must be awaited first!");
13028 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone(orig);
13029 return nativeResponseValue;
13031 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_ok(struct LDKSignedRawInvoice o);
13033 export function CResult_SignedRawInvoiceParseErrorZ_ok(o: bigint): bigint {
13034 if(!isWasmInitialized) {
13035 throw new Error("initializeWasm() must be awaited first!");
13037 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_ok(o);
13038 return nativeResponseValue;
13040 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_err(struct LDKParseError e);
13042 export function CResult_SignedRawInvoiceParseErrorZ_err(e: bigint): bigint {
13043 if(!isWasmInitialized) {
13044 throw new Error("initializeWasm() must be awaited first!");
13046 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_err(e);
13047 return nativeResponseValue;
13049 // bool CResult_SignedRawInvoiceParseErrorZ_is_ok(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR o);
13051 export function CResult_SignedRawInvoiceParseErrorZ_is_ok(o: bigint): boolean {
13052 if(!isWasmInitialized) {
13053 throw new Error("initializeWasm() must be awaited first!");
13055 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_is_ok(o);
13056 return nativeResponseValue;
13058 // void CResult_SignedRawInvoiceParseErrorZ_free(struct LDKCResult_SignedRawInvoiceParseErrorZ _res);
13060 export function CResult_SignedRawInvoiceParseErrorZ_free(_res: bigint): void {
13061 if(!isWasmInitialized) {
13062 throw new Error("initializeWasm() must be awaited first!");
13064 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_free(_res);
13065 // debug statements here
13067 // uint64_t CResult_SignedRawInvoiceParseErrorZ_clone_ptr(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR arg);
13069 export function CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg: bigint): bigint {
13070 if(!isWasmInitialized) {
13071 throw new Error("initializeWasm() must be awaited first!");
13073 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg);
13074 return nativeResponseValue;
13076 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_clone(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR orig);
13078 export function CResult_SignedRawInvoiceParseErrorZ_clone(orig: bigint): bigint {
13079 if(!isWasmInitialized) {
13080 throw new Error("initializeWasm() must be awaited first!");
13082 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone(orig);
13083 return nativeResponseValue;
13085 // uint64_t C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR arg);
13087 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg: bigint): bigint {
13088 if(!isWasmInitialized) {
13089 throw new Error("initializeWasm() must be awaited first!");
13091 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg);
13092 return nativeResponseValue;
13094 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(const struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR orig);
13096 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig: bigint): bigint {
13097 if(!isWasmInitialized) {
13098 throw new Error("initializeWasm() must be awaited first!");
13100 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig);
13101 return nativeResponseValue;
13103 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(struct LDKRawInvoice a, struct LDKThirtyTwoBytes b, struct LDKInvoiceSignature c);
13105 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a: bigint, b: number, c: bigint): bigint {
13106 if(!isWasmInitialized) {
13107 throw new Error("initializeWasm() must be awaited first!");
13109 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a, b, c);
13110 return nativeResponseValue;
13112 // void C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ _res);
13114 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res: bigint): void {
13115 if(!isWasmInitialized) {
13116 throw new Error("initializeWasm() must be awaited first!");
13118 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res);
13119 // debug statements here
13121 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_ok(struct LDKPayeePubKey o);
13123 export function CResult_PayeePubKeyErrorZ_ok(o: bigint): bigint {
13124 if(!isWasmInitialized) {
13125 throw new Error("initializeWasm() must be awaited first!");
13127 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_ok(o);
13128 return nativeResponseValue;
13130 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_err(enum LDKSecp256k1Error e);
13132 export function CResult_PayeePubKeyErrorZ_err(e: Secp256k1Error): bigint {
13133 if(!isWasmInitialized) {
13134 throw new Error("initializeWasm() must be awaited first!");
13136 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_err(e);
13137 return nativeResponseValue;
13139 // bool CResult_PayeePubKeyErrorZ_is_ok(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR o);
13141 export function CResult_PayeePubKeyErrorZ_is_ok(o: bigint): boolean {
13142 if(!isWasmInitialized) {
13143 throw new Error("initializeWasm() must be awaited first!");
13145 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_is_ok(o);
13146 return nativeResponseValue;
13148 // void CResult_PayeePubKeyErrorZ_free(struct LDKCResult_PayeePubKeyErrorZ _res);
13150 export function CResult_PayeePubKeyErrorZ_free(_res: bigint): void {
13151 if(!isWasmInitialized) {
13152 throw new Error("initializeWasm() must be awaited first!");
13154 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_free(_res);
13155 // debug statements here
13157 // uint64_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg);
13159 export function CResult_PayeePubKeyErrorZ_clone_ptr(arg: bigint): bigint {
13160 if(!isWasmInitialized) {
13161 throw new Error("initializeWasm() must be awaited first!");
13163 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone_ptr(arg);
13164 return nativeResponseValue;
13166 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_clone(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR orig);
13168 export function CResult_PayeePubKeyErrorZ_clone(orig: bigint): bigint {
13169 if(!isWasmInitialized) {
13170 throw new Error("initializeWasm() must be awaited first!");
13172 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone(orig);
13173 return nativeResponseValue;
13175 // void CVec_PrivateRouteZ_free(struct LDKCVec_PrivateRouteZ _res);
13177 export function CVec_PrivateRouteZ_free(_res: number): void {
13178 if(!isWasmInitialized) {
13179 throw new Error("initializeWasm() must be awaited first!");
13181 const nativeResponseValue = wasm.TS_CVec_PrivateRouteZ_free(_res);
13182 // debug statements here
13184 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_ok(struct LDKPositiveTimestamp o);
13186 export function CResult_PositiveTimestampCreationErrorZ_ok(o: bigint): bigint {
13187 if(!isWasmInitialized) {
13188 throw new Error("initializeWasm() must be awaited first!");
13190 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_ok(o);
13191 return nativeResponseValue;
13193 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_err(enum LDKCreationError e);
13195 export function CResult_PositiveTimestampCreationErrorZ_err(e: CreationError): bigint {
13196 if(!isWasmInitialized) {
13197 throw new Error("initializeWasm() must be awaited first!");
13199 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_err(e);
13200 return nativeResponseValue;
13202 // bool CResult_PositiveTimestampCreationErrorZ_is_ok(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR o);
13204 export function CResult_PositiveTimestampCreationErrorZ_is_ok(o: bigint): boolean {
13205 if(!isWasmInitialized) {
13206 throw new Error("initializeWasm() must be awaited first!");
13208 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_is_ok(o);
13209 return nativeResponseValue;
13211 // void CResult_PositiveTimestampCreationErrorZ_free(struct LDKCResult_PositiveTimestampCreationErrorZ _res);
13213 export function CResult_PositiveTimestampCreationErrorZ_free(_res: bigint): void {
13214 if(!isWasmInitialized) {
13215 throw new Error("initializeWasm() must be awaited first!");
13217 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_free(_res);
13218 // debug statements here
13220 // uint64_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg);
13222 export function CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg: bigint): bigint {
13223 if(!isWasmInitialized) {
13224 throw new Error("initializeWasm() must be awaited first!");
13226 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg);
13227 return nativeResponseValue;
13229 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_clone(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR orig);
13231 export function CResult_PositiveTimestampCreationErrorZ_clone(orig: bigint): bigint {
13232 if(!isWasmInitialized) {
13233 throw new Error("initializeWasm() must be awaited first!");
13235 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone(orig);
13236 return nativeResponseValue;
13238 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_ok(void);
13240 export function CResult_NoneSemanticErrorZ_ok(): bigint {
13241 if(!isWasmInitialized) {
13242 throw new Error("initializeWasm() must be awaited first!");
13244 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_ok();
13245 return nativeResponseValue;
13247 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_err(enum LDKSemanticError e);
13249 export function CResult_NoneSemanticErrorZ_err(e: SemanticError): bigint {
13250 if(!isWasmInitialized) {
13251 throw new Error("initializeWasm() must be awaited first!");
13253 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_err(e);
13254 return nativeResponseValue;
13256 // bool CResult_NoneSemanticErrorZ_is_ok(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR o);
13258 export function CResult_NoneSemanticErrorZ_is_ok(o: bigint): boolean {
13259 if(!isWasmInitialized) {
13260 throw new Error("initializeWasm() must be awaited first!");
13262 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_is_ok(o);
13263 return nativeResponseValue;
13265 // void CResult_NoneSemanticErrorZ_free(struct LDKCResult_NoneSemanticErrorZ _res);
13267 export function CResult_NoneSemanticErrorZ_free(_res: bigint): void {
13268 if(!isWasmInitialized) {
13269 throw new Error("initializeWasm() must be awaited first!");
13271 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_free(_res);
13272 // debug statements here
13274 // uint64_t CResult_NoneSemanticErrorZ_clone_ptr(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR arg);
13276 export function CResult_NoneSemanticErrorZ_clone_ptr(arg: bigint): bigint {
13277 if(!isWasmInitialized) {
13278 throw new Error("initializeWasm() must be awaited first!");
13280 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone_ptr(arg);
13281 return nativeResponseValue;
13283 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_clone(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR orig);
13285 export function CResult_NoneSemanticErrorZ_clone(orig: bigint): bigint {
13286 if(!isWasmInitialized) {
13287 throw new Error("initializeWasm() must be awaited first!");
13289 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone(orig);
13290 return nativeResponseValue;
13292 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_ok(struct LDKInvoice o);
13294 export function CResult_InvoiceSemanticErrorZ_ok(o: bigint): bigint {
13295 if(!isWasmInitialized) {
13296 throw new Error("initializeWasm() must be awaited first!");
13298 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_ok(o);
13299 return nativeResponseValue;
13301 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_err(enum LDKSemanticError e);
13303 export function CResult_InvoiceSemanticErrorZ_err(e: SemanticError): bigint {
13304 if(!isWasmInitialized) {
13305 throw new Error("initializeWasm() must be awaited first!");
13307 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_err(e);
13308 return nativeResponseValue;
13310 // bool CResult_InvoiceSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR o);
13312 export function CResult_InvoiceSemanticErrorZ_is_ok(o: bigint): boolean {
13313 if(!isWasmInitialized) {
13314 throw new Error("initializeWasm() must be awaited first!");
13316 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_is_ok(o);
13317 return nativeResponseValue;
13319 // void CResult_InvoiceSemanticErrorZ_free(struct LDKCResult_InvoiceSemanticErrorZ _res);
13321 export function CResult_InvoiceSemanticErrorZ_free(_res: bigint): void {
13322 if(!isWasmInitialized) {
13323 throw new Error("initializeWasm() must be awaited first!");
13325 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_free(_res);
13326 // debug statements here
13328 // uint64_t CResult_InvoiceSemanticErrorZ_clone_ptr(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR arg);
13330 export function CResult_InvoiceSemanticErrorZ_clone_ptr(arg: bigint): bigint {
13331 if(!isWasmInitialized) {
13332 throw new Error("initializeWasm() must be awaited first!");
13334 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone_ptr(arg);
13335 return nativeResponseValue;
13337 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_clone(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR orig);
13339 export function CResult_InvoiceSemanticErrorZ_clone(orig: bigint): bigint {
13340 if(!isWasmInitialized) {
13341 throw new Error("initializeWasm() must be awaited first!");
13343 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone(orig);
13344 return nativeResponseValue;
13346 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_ok(struct LDKDescription o);
13348 export function CResult_DescriptionCreationErrorZ_ok(o: bigint): bigint {
13349 if(!isWasmInitialized) {
13350 throw new Error("initializeWasm() must be awaited first!");
13352 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_ok(o);
13353 return nativeResponseValue;
13355 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_err(enum LDKCreationError e);
13357 export function CResult_DescriptionCreationErrorZ_err(e: CreationError): bigint {
13358 if(!isWasmInitialized) {
13359 throw new Error("initializeWasm() must be awaited first!");
13361 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_err(e);
13362 return nativeResponseValue;
13364 // bool CResult_DescriptionCreationErrorZ_is_ok(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR o);
13366 export function CResult_DescriptionCreationErrorZ_is_ok(o: bigint): boolean {
13367 if(!isWasmInitialized) {
13368 throw new Error("initializeWasm() must be awaited first!");
13370 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_is_ok(o);
13371 return nativeResponseValue;
13373 // void CResult_DescriptionCreationErrorZ_free(struct LDKCResult_DescriptionCreationErrorZ _res);
13375 export function CResult_DescriptionCreationErrorZ_free(_res: bigint): void {
13376 if(!isWasmInitialized) {
13377 throw new Error("initializeWasm() must be awaited first!");
13379 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_free(_res);
13380 // debug statements here
13382 // uint64_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg);
13384 export function CResult_DescriptionCreationErrorZ_clone_ptr(arg: bigint): bigint {
13385 if(!isWasmInitialized) {
13386 throw new Error("initializeWasm() must be awaited first!");
13388 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone_ptr(arg);
13389 return nativeResponseValue;
13391 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_clone(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR orig);
13393 export function CResult_DescriptionCreationErrorZ_clone(orig: bigint): bigint {
13394 if(!isWasmInitialized) {
13395 throw new Error("initializeWasm() must be awaited first!");
13397 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone(orig);
13398 return nativeResponseValue;
13400 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_ok(struct LDKPrivateRoute o);
13402 export function CResult_PrivateRouteCreationErrorZ_ok(o: bigint): bigint {
13403 if(!isWasmInitialized) {
13404 throw new Error("initializeWasm() must be awaited first!");
13406 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_ok(o);
13407 return nativeResponseValue;
13409 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_err(enum LDKCreationError e);
13411 export function CResult_PrivateRouteCreationErrorZ_err(e: CreationError): bigint {
13412 if(!isWasmInitialized) {
13413 throw new Error("initializeWasm() must be awaited first!");
13415 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_err(e);
13416 return nativeResponseValue;
13418 // bool CResult_PrivateRouteCreationErrorZ_is_ok(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR o);
13420 export function CResult_PrivateRouteCreationErrorZ_is_ok(o: bigint): boolean {
13421 if(!isWasmInitialized) {
13422 throw new Error("initializeWasm() must be awaited first!");
13424 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_is_ok(o);
13425 return nativeResponseValue;
13427 // void CResult_PrivateRouteCreationErrorZ_free(struct LDKCResult_PrivateRouteCreationErrorZ _res);
13429 export function CResult_PrivateRouteCreationErrorZ_free(_res: bigint): void {
13430 if(!isWasmInitialized) {
13431 throw new Error("initializeWasm() must be awaited first!");
13433 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_free(_res);
13434 // debug statements here
13436 // uint64_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg);
13438 export function CResult_PrivateRouteCreationErrorZ_clone_ptr(arg: bigint): bigint {
13439 if(!isWasmInitialized) {
13440 throw new Error("initializeWasm() must be awaited first!");
13442 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(arg);
13443 return nativeResponseValue;
13445 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_clone(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR orig);
13447 export function CResult_PrivateRouteCreationErrorZ_clone(orig: bigint): bigint {
13448 if(!isWasmInitialized) {
13449 throw new Error("initializeWasm() must be awaited first!");
13451 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone(orig);
13452 return nativeResponseValue;
13454 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_ok(struct LDKStr o);
13456 export function CResult_StringErrorZ_ok(o: number): bigint {
13457 if(!isWasmInitialized) {
13458 throw new Error("initializeWasm() must be awaited first!");
13460 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_ok(o);
13461 return nativeResponseValue;
13463 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_err(enum LDKSecp256k1Error e);
13465 export function CResult_StringErrorZ_err(e: Secp256k1Error): bigint {
13466 if(!isWasmInitialized) {
13467 throw new Error("initializeWasm() must be awaited first!");
13469 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_err(e);
13470 return nativeResponseValue;
13472 // bool CResult_StringErrorZ_is_ok(const struct LDKCResult_StringErrorZ *NONNULL_PTR o);
13474 export function CResult_StringErrorZ_is_ok(o: bigint): boolean {
13475 if(!isWasmInitialized) {
13476 throw new Error("initializeWasm() must be awaited first!");
13478 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_is_ok(o);
13479 return nativeResponseValue;
13481 // void CResult_StringErrorZ_free(struct LDKCResult_StringErrorZ _res);
13483 export function CResult_StringErrorZ_free(_res: bigint): void {
13484 if(!isWasmInitialized) {
13485 throw new Error("initializeWasm() must be awaited first!");
13487 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_free(_res);
13488 // debug statements here
13490 // uint64_t CResult_StringErrorZ_clone_ptr(LDKCResult_StringErrorZ *NONNULL_PTR arg);
13492 export function CResult_StringErrorZ_clone_ptr(arg: bigint): bigint {
13493 if(!isWasmInitialized) {
13494 throw new Error("initializeWasm() must be awaited first!");
13496 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_clone_ptr(arg);
13497 return nativeResponseValue;
13499 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_clone(const struct LDKCResult_StringErrorZ *NONNULL_PTR orig);
13501 export function CResult_StringErrorZ_clone(orig: bigint): bigint {
13502 if(!isWasmInitialized) {
13503 throw new Error("initializeWasm() must be awaited first!");
13505 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_clone(orig);
13506 return nativeResponseValue;
13508 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
13510 export function CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: bigint): bigint {
13511 if(!isWasmInitialized) {
13512 throw new Error("initializeWasm() must be awaited first!");
13514 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o);
13515 return nativeResponseValue;
13517 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
13519 export function CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: bigint): bigint {
13520 if(!isWasmInitialized) {
13521 throw new Error("initializeWasm() must be awaited first!");
13523 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(e);
13524 return nativeResponseValue;
13526 // bool CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR o);
13528 export function CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
13529 if(!isWasmInitialized) {
13530 throw new Error("initializeWasm() must be awaited first!");
13532 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o);
13533 return nativeResponseValue;
13535 // void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
13537 export function CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: bigint): void {
13538 if(!isWasmInitialized) {
13539 throw new Error("initializeWasm() must be awaited first!");
13541 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res);
13542 // debug statements here
13544 // uint64_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg);
13546 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13547 if(!isWasmInitialized) {
13548 throw new Error("initializeWasm() must be awaited first!");
13550 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg);
13551 return nativeResponseValue;
13553 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
13555 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: bigint): bigint {
13556 if(!isWasmInitialized) {
13557 throw new Error("initializeWasm() must be awaited first!");
13559 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig);
13560 return nativeResponseValue;
13562 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_some(struct LDKMonitorEvent o);
13564 export function COption_MonitorEventZ_some(o: bigint): bigint {
13565 if(!isWasmInitialized) {
13566 throw new Error("initializeWasm() must be awaited first!");
13568 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_some(o);
13569 return nativeResponseValue;
13571 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_none(void);
13573 export function COption_MonitorEventZ_none(): bigint {
13574 if(!isWasmInitialized) {
13575 throw new Error("initializeWasm() must be awaited first!");
13577 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_none();
13578 return nativeResponseValue;
13580 // void COption_MonitorEventZ_free(struct LDKCOption_MonitorEventZ _res);
13582 export function COption_MonitorEventZ_free(_res: bigint): void {
13583 if(!isWasmInitialized) {
13584 throw new Error("initializeWasm() must be awaited first!");
13586 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_free(_res);
13587 // debug statements here
13589 // uint64_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg);
13591 export function COption_MonitorEventZ_clone_ptr(arg: bigint): bigint {
13592 if(!isWasmInitialized) {
13593 throw new Error("initializeWasm() must be awaited first!");
13595 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone_ptr(arg);
13596 return nativeResponseValue;
13598 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_clone(const struct LDKCOption_MonitorEventZ *NONNULL_PTR orig);
13600 export function COption_MonitorEventZ_clone(orig: bigint): bigint {
13601 if(!isWasmInitialized) {
13602 throw new Error("initializeWasm() must be awaited first!");
13604 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone(orig);
13605 return nativeResponseValue;
13607 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_ok(struct LDKCOption_MonitorEventZ o);
13609 export function CResult_COption_MonitorEventZDecodeErrorZ_ok(o: bigint): bigint {
13610 if(!isWasmInitialized) {
13611 throw new Error("initializeWasm() must be awaited first!");
13613 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(o);
13614 return nativeResponseValue;
13616 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_err(struct LDKDecodeError e);
13618 export function CResult_COption_MonitorEventZDecodeErrorZ_err(e: bigint): bigint {
13619 if(!isWasmInitialized) {
13620 throw new Error("initializeWasm() must be awaited first!");
13622 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_err(e);
13623 return nativeResponseValue;
13625 // bool CResult_COption_MonitorEventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR o);
13627 export function CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o: bigint): boolean {
13628 if(!isWasmInitialized) {
13629 throw new Error("initializeWasm() must be awaited first!");
13631 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o);
13632 return nativeResponseValue;
13634 // void CResult_COption_MonitorEventZDecodeErrorZ_free(struct LDKCResult_COption_MonitorEventZDecodeErrorZ _res);
13636 export function CResult_COption_MonitorEventZDecodeErrorZ_free(_res: bigint): void {
13637 if(!isWasmInitialized) {
13638 throw new Error("initializeWasm() must be awaited first!");
13640 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_free(_res);
13641 // debug statements here
13643 // uint64_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg);
13645 export function CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13646 if(!isWasmInitialized) {
13647 throw new Error("initializeWasm() must be awaited first!");
13649 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg);
13650 return nativeResponseValue;
13652 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_clone(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR orig);
13654 export function CResult_COption_MonitorEventZDecodeErrorZ_clone(orig: bigint): bigint {
13655 if(!isWasmInitialized) {
13656 throw new Error("initializeWasm() must be awaited first!");
13658 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(orig);
13659 return nativeResponseValue;
13661 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
13663 export function CResult_HTLCUpdateDecodeErrorZ_ok(o: bigint): bigint {
13664 if(!isWasmInitialized) {
13665 throw new Error("initializeWasm() must be awaited first!");
13667 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_ok(o);
13668 return nativeResponseValue;
13670 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
13672 export function CResult_HTLCUpdateDecodeErrorZ_err(e: bigint): bigint {
13673 if(!isWasmInitialized) {
13674 throw new Error("initializeWasm() must be awaited first!");
13676 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_err(e);
13677 return nativeResponseValue;
13679 // bool CResult_HTLCUpdateDecodeErrorZ_is_ok(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR o);
13681 export function CResult_HTLCUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
13682 if(!isWasmInitialized) {
13683 throw new Error("initializeWasm() must be awaited first!");
13685 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(o);
13686 return nativeResponseValue;
13688 // void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
13690 export function CResult_HTLCUpdateDecodeErrorZ_free(_res: bigint): void {
13691 if(!isWasmInitialized) {
13692 throw new Error("initializeWasm() must be awaited first!");
13694 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_free(_res);
13695 // debug statements here
13697 // uint64_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg);
13699 export function CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13700 if(!isWasmInitialized) {
13701 throw new Error("initializeWasm() must be awaited first!");
13703 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg);
13704 return nativeResponseValue;
13706 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
13708 export function CResult_HTLCUpdateDecodeErrorZ_clone(orig: bigint): bigint {
13709 if(!isWasmInitialized) {
13710 throw new Error("initializeWasm() must be awaited first!");
13712 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone(orig);
13713 return nativeResponseValue;
13715 // uint64_t C2Tuple_OutPointScriptZ_clone_ptr(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR arg);
13717 export function C2Tuple_OutPointScriptZ_clone_ptr(arg: bigint): bigint {
13718 if(!isWasmInitialized) {
13719 throw new Error("initializeWasm() must be awaited first!");
13721 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone_ptr(arg);
13722 return nativeResponseValue;
13724 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_clone(const struct LDKC2Tuple_OutPointScriptZ *NONNULL_PTR orig);
13726 export function C2Tuple_OutPointScriptZ_clone(orig: bigint): bigint {
13727 if(!isWasmInitialized) {
13728 throw new Error("initializeWasm() must be awaited first!");
13730 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone(orig);
13731 return nativeResponseValue;
13733 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
13735 export function C2Tuple_OutPointScriptZ_new(a: bigint, b: number): bigint {
13736 if(!isWasmInitialized) {
13737 throw new Error("initializeWasm() must be awaited first!");
13739 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_new(a, b);
13740 return nativeResponseValue;
13742 // void C2Tuple_OutPointScriptZ_free(struct LDKC2Tuple_OutPointScriptZ _res);
13744 export function C2Tuple_OutPointScriptZ_free(_res: bigint): void {
13745 if(!isWasmInitialized) {
13746 throw new Error("initializeWasm() must be awaited first!");
13748 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_free(_res);
13749 // debug statements here
13751 // uint64_t C2Tuple_u32ScriptZ_clone_ptr(LDKC2Tuple_u32ScriptZ *NONNULL_PTR arg);
13753 export function C2Tuple_u32ScriptZ_clone_ptr(arg: bigint): bigint {
13754 if(!isWasmInitialized) {
13755 throw new Error("initializeWasm() must be awaited first!");
13757 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone_ptr(arg);
13758 return nativeResponseValue;
13760 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_clone(const struct LDKC2Tuple_u32ScriptZ *NONNULL_PTR orig);
13762 export function C2Tuple_u32ScriptZ_clone(orig: bigint): bigint {
13763 if(!isWasmInitialized) {
13764 throw new Error("initializeWasm() must be awaited first!");
13766 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone(orig);
13767 return nativeResponseValue;
13769 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_new(uint32_t a, struct LDKCVec_u8Z b);
13771 export function C2Tuple_u32ScriptZ_new(a: number, b: number): bigint {
13772 if(!isWasmInitialized) {
13773 throw new Error("initializeWasm() must be awaited first!");
13775 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_new(a, b);
13776 return nativeResponseValue;
13778 // void C2Tuple_u32ScriptZ_free(struct LDKC2Tuple_u32ScriptZ _res);
13780 export function C2Tuple_u32ScriptZ_free(_res: bigint): void {
13781 if(!isWasmInitialized) {
13782 throw new Error("initializeWasm() must be awaited first!");
13784 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_free(_res);
13785 // debug statements here
13787 // void CVec_C2Tuple_u32ScriptZZ_free(struct LDKCVec_C2Tuple_u32ScriptZZ _res);
13789 export function CVec_C2Tuple_u32ScriptZZ_free(_res: number): void {
13790 if(!isWasmInitialized) {
13791 throw new Error("initializeWasm() must be awaited first!");
13793 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32ScriptZZ_free(_res);
13794 // debug statements here
13796 // uint64_t C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR arg);
13798 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg: bigint): bigint {
13799 if(!isWasmInitialized) {
13800 throw new Error("initializeWasm() must be awaited first!");
13802 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg);
13803 return nativeResponseValue;
13805 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR orig);
13807 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig: bigint): bigint {
13808 if(!isWasmInitialized) {
13809 throw new Error("initializeWasm() must be awaited first!");
13811 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig);
13812 return nativeResponseValue;
13814 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32ScriptZZ b);
13816 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a: number, b: number): bigint {
13817 if(!isWasmInitialized) {
13818 throw new Error("initializeWasm() must be awaited first!");
13820 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a, b);
13821 return nativeResponseValue;
13823 // void C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res);
13825 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res: bigint): void {
13826 if(!isWasmInitialized) {
13827 throw new Error("initializeWasm() must be awaited first!");
13829 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res);
13830 // debug statements here
13832 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res);
13834 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res: number): void {
13835 if(!isWasmInitialized) {
13836 throw new Error("initializeWasm() must be awaited first!");
13838 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res);
13839 // debug statements here
13841 // void CVec_EventZ_free(struct LDKCVec_EventZ _res);
13843 export function CVec_EventZ_free(_res: number): void {
13844 if(!isWasmInitialized) {
13845 throw new Error("initializeWasm() must be awaited first!");
13847 const nativeResponseValue = wasm.TS_CVec_EventZ_free(_res);
13848 // debug statements here
13850 // void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
13852 export function CVec_TransactionZ_free(_res: number): void {
13853 if(!isWasmInitialized) {
13854 throw new Error("initializeWasm() must be awaited first!");
13856 const nativeResponseValue = wasm.TS_CVec_TransactionZ_free(_res);
13857 // debug statements here
13859 // uint64_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg);
13861 export function C2Tuple_u32TxOutZ_clone_ptr(arg: bigint): bigint {
13862 if(!isWasmInitialized) {
13863 throw new Error("initializeWasm() must be awaited first!");
13865 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone_ptr(arg);
13866 return nativeResponseValue;
13868 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
13870 export function C2Tuple_u32TxOutZ_clone(orig: bigint): bigint {
13871 if(!isWasmInitialized) {
13872 throw new Error("initializeWasm() must be awaited first!");
13874 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone(orig);
13875 return nativeResponseValue;
13877 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
13879 export function C2Tuple_u32TxOutZ_new(a: number, b: bigint): bigint {
13880 if(!isWasmInitialized) {
13881 throw new Error("initializeWasm() must be awaited first!");
13883 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_new(a, b);
13884 return nativeResponseValue;
13886 // void C2Tuple_u32TxOutZ_free(struct LDKC2Tuple_u32TxOutZ _res);
13888 export function C2Tuple_u32TxOutZ_free(_res: bigint): void {
13889 if(!isWasmInitialized) {
13890 throw new Error("initializeWasm() must be awaited first!");
13892 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_free(_res);
13893 // debug statements here
13895 // void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
13897 export function CVec_C2Tuple_u32TxOutZZ_free(_res: number): void {
13898 if(!isWasmInitialized) {
13899 throw new Error("initializeWasm() must be awaited first!");
13901 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32TxOutZZ_free(_res);
13902 // debug statements here
13904 // uint64_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg);
13906 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg: bigint): bigint {
13907 if(!isWasmInitialized) {
13908 throw new Error("initializeWasm() must be awaited first!");
13910 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg);
13911 return nativeResponseValue;
13913 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR orig);
13915 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig: bigint): bigint {
13916 if(!isWasmInitialized) {
13917 throw new Error("initializeWasm() must be awaited first!");
13919 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig);
13920 return nativeResponseValue;
13922 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
13924 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a: number, b: number): bigint {
13925 if(!isWasmInitialized) {
13926 throw new Error("initializeWasm() must be awaited first!");
13928 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a, b);
13929 return nativeResponseValue;
13931 // void C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res);
13933 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res: bigint): void {
13934 if(!isWasmInitialized) {
13935 throw new Error("initializeWasm() must be awaited first!");
13937 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res);
13938 // debug statements here
13940 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res);
13942 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res: number): void {
13943 if(!isWasmInitialized) {
13944 throw new Error("initializeWasm() must be awaited first!");
13946 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res);
13947 // debug statements here
13949 // void CVec_BalanceZ_free(struct LDKCVec_BalanceZ _res);
13951 export function CVec_BalanceZ_free(_res: number): void {
13952 if(!isWasmInitialized) {
13953 throw new Error("initializeWasm() must be awaited first!");
13955 const nativeResponseValue = wasm.TS_CVec_BalanceZ_free(_res);
13956 // debug statements here
13958 // uint64_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg);
13960 export function C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg: bigint): bigint {
13961 if(!isWasmInitialized) {
13962 throw new Error("initializeWasm() must be awaited first!");
13964 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg);
13965 return nativeResponseValue;
13967 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_clone(const struct LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR orig);
13969 export function C2Tuple_BlockHashChannelMonitorZ_clone(orig: bigint): bigint {
13970 if(!isWasmInitialized) {
13971 throw new Error("initializeWasm() must be awaited first!");
13973 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone(orig);
13974 return nativeResponseValue;
13976 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
13978 export function C2Tuple_BlockHashChannelMonitorZ_new(a: number, b: bigint): bigint {
13979 if(!isWasmInitialized) {
13980 throw new Error("initializeWasm() must be awaited first!");
13982 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_new(a, b);
13983 return nativeResponseValue;
13985 // void C2Tuple_BlockHashChannelMonitorZ_free(struct LDKC2Tuple_BlockHashChannelMonitorZ _res);
13987 export function C2Tuple_BlockHashChannelMonitorZ_free(_res: bigint): void {
13988 if(!isWasmInitialized) {
13989 throw new Error("initializeWasm() must be awaited first!");
13991 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_free(_res);
13992 // debug statements here
13994 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelMonitorZ o);
13996 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o: bigint): bigint {
13997 if(!isWasmInitialized) {
13998 throw new Error("initializeWasm() must be awaited first!");
14000 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o);
14001 return nativeResponseValue;
14003 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
14005 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e: bigint): bigint {
14006 if(!isWasmInitialized) {
14007 throw new Error("initializeWasm() must be awaited first!");
14009 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e);
14010 return nativeResponseValue;
14012 // bool CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR o);
14014 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o: bigint): boolean {
14015 if(!isWasmInitialized) {
14016 throw new Error("initializeWasm() must be awaited first!");
14018 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o);
14019 return nativeResponseValue;
14021 // void CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res);
14023 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res: bigint): void {
14024 if(!isWasmInitialized) {
14025 throw new Error("initializeWasm() must be awaited first!");
14027 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res);
14028 // debug statements here
14030 // uint64_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg);
14032 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14033 if(!isWasmInitialized) {
14034 throw new Error("initializeWasm() must be awaited first!");
14036 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg);
14037 return nativeResponseValue;
14039 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR orig);
14041 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig: bigint): bigint {
14042 if(!isWasmInitialized) {
14043 throw new Error("initializeWasm() must be awaited first!");
14045 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig);
14046 return nativeResponseValue;
14048 // uint64_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg);
14050 export function C2Tuple_PublicKeyTypeZ_clone_ptr(arg: bigint): bigint {
14051 if(!isWasmInitialized) {
14052 throw new Error("initializeWasm() must be awaited first!");
14054 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone_ptr(arg);
14055 return nativeResponseValue;
14057 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_clone(const struct LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR orig);
14059 export function C2Tuple_PublicKeyTypeZ_clone(orig: bigint): bigint {
14060 if(!isWasmInitialized) {
14061 throw new Error("initializeWasm() must be awaited first!");
14063 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone(orig);
14064 return nativeResponseValue;
14066 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_new(struct LDKPublicKey a, struct LDKType b);
14068 export function C2Tuple_PublicKeyTypeZ_new(a: number, b: bigint): bigint {
14069 if(!isWasmInitialized) {
14070 throw new Error("initializeWasm() must be awaited first!");
14072 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_new(a, b);
14073 return nativeResponseValue;
14075 // void C2Tuple_PublicKeyTypeZ_free(struct LDKC2Tuple_PublicKeyTypeZ _res);
14077 export function C2Tuple_PublicKeyTypeZ_free(_res: bigint): void {
14078 if(!isWasmInitialized) {
14079 throw new Error("initializeWasm() must be awaited first!");
14081 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_free(_res);
14082 // debug statements here
14084 // void CVec_C2Tuple_PublicKeyTypeZZ_free(struct LDKCVec_C2Tuple_PublicKeyTypeZZ _res);
14086 export function CVec_C2Tuple_PublicKeyTypeZZ_free(_res: number): void {
14087 if(!isWasmInitialized) {
14088 throw new Error("initializeWasm() must be awaited first!");
14090 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyTypeZZ_free(_res);
14091 // debug statements here
14093 // struct LDKCOption_NetAddressZ COption_NetAddressZ_some(struct LDKNetAddress o);
14095 export function COption_NetAddressZ_some(o: bigint): bigint {
14096 if(!isWasmInitialized) {
14097 throw new Error("initializeWasm() must be awaited first!");
14099 const nativeResponseValue = wasm.TS_COption_NetAddressZ_some(o);
14100 return nativeResponseValue;
14102 // struct LDKCOption_NetAddressZ COption_NetAddressZ_none(void);
14104 export function COption_NetAddressZ_none(): bigint {
14105 if(!isWasmInitialized) {
14106 throw new Error("initializeWasm() must be awaited first!");
14108 const nativeResponseValue = wasm.TS_COption_NetAddressZ_none();
14109 return nativeResponseValue;
14111 // void COption_NetAddressZ_free(struct LDKCOption_NetAddressZ _res);
14113 export function COption_NetAddressZ_free(_res: bigint): void {
14114 if(!isWasmInitialized) {
14115 throw new Error("initializeWasm() must be awaited first!");
14117 const nativeResponseValue = wasm.TS_COption_NetAddressZ_free(_res);
14118 // debug statements here
14120 // uint64_t COption_NetAddressZ_clone_ptr(LDKCOption_NetAddressZ *NONNULL_PTR arg);
14122 export function COption_NetAddressZ_clone_ptr(arg: bigint): bigint {
14123 if(!isWasmInitialized) {
14124 throw new Error("initializeWasm() must be awaited first!");
14126 const nativeResponseValue = wasm.TS_COption_NetAddressZ_clone_ptr(arg);
14127 return nativeResponseValue;
14129 // struct LDKCOption_NetAddressZ COption_NetAddressZ_clone(const struct LDKCOption_NetAddressZ *NONNULL_PTR orig);
14131 export function COption_NetAddressZ_clone(orig: bigint): bigint {
14132 if(!isWasmInitialized) {
14133 throw new Error("initializeWasm() must be awaited first!");
14135 const nativeResponseValue = wasm.TS_COption_NetAddressZ_clone(orig);
14136 return nativeResponseValue;
14138 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
14140 export function CResult_CVec_u8ZPeerHandleErrorZ_ok(o: number): bigint {
14141 if(!isWasmInitialized) {
14142 throw new Error("initializeWasm() must be awaited first!");
14144 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(o);
14145 return nativeResponseValue;
14147 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
14149 export function CResult_CVec_u8ZPeerHandleErrorZ_err(e: bigint): bigint {
14150 if(!isWasmInitialized) {
14151 throw new Error("initializeWasm() must be awaited first!");
14153 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_err(e);
14154 return nativeResponseValue;
14156 // bool CResult_CVec_u8ZPeerHandleErrorZ_is_ok(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR o);
14158 export function CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o: bigint): boolean {
14159 if(!isWasmInitialized) {
14160 throw new Error("initializeWasm() must be awaited first!");
14162 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o);
14163 return nativeResponseValue;
14165 // void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
14167 export function CResult_CVec_u8ZPeerHandleErrorZ_free(_res: bigint): void {
14168 if(!isWasmInitialized) {
14169 throw new Error("initializeWasm() must be awaited first!");
14171 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_free(_res);
14172 // debug statements here
14174 // uint64_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg);
14176 export function CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
14177 if(!isWasmInitialized) {
14178 throw new Error("initializeWasm() must be awaited first!");
14180 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg);
14181 return nativeResponseValue;
14183 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
14185 export function CResult_CVec_u8ZPeerHandleErrorZ_clone(orig: bigint): bigint {
14186 if(!isWasmInitialized) {
14187 throw new Error("initializeWasm() must be awaited first!");
14189 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(orig);
14190 return nativeResponseValue;
14192 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
14194 export function CResult_NonePeerHandleErrorZ_ok(): bigint {
14195 if(!isWasmInitialized) {
14196 throw new Error("initializeWasm() must be awaited first!");
14198 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_ok();
14199 return nativeResponseValue;
14201 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
14203 export function CResult_NonePeerHandleErrorZ_err(e: bigint): bigint {
14204 if(!isWasmInitialized) {
14205 throw new Error("initializeWasm() must be awaited first!");
14207 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_err(e);
14208 return nativeResponseValue;
14210 // bool CResult_NonePeerHandleErrorZ_is_ok(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR o);
14212 export function CResult_NonePeerHandleErrorZ_is_ok(o: bigint): boolean {
14213 if(!isWasmInitialized) {
14214 throw new Error("initializeWasm() must be awaited first!");
14216 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_is_ok(o);
14217 return nativeResponseValue;
14219 // void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
14221 export function CResult_NonePeerHandleErrorZ_free(_res: bigint): void {
14222 if(!isWasmInitialized) {
14223 throw new Error("initializeWasm() must be awaited first!");
14225 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_free(_res);
14226 // debug statements here
14228 // uint64_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg);
14230 export function CResult_NonePeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
14231 if(!isWasmInitialized) {
14232 throw new Error("initializeWasm() must be awaited first!");
14234 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone_ptr(arg);
14235 return nativeResponseValue;
14237 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
14239 export function CResult_NonePeerHandleErrorZ_clone(orig: bigint): bigint {
14240 if(!isWasmInitialized) {
14241 throw new Error("initializeWasm() must be awaited first!");
14243 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone(orig);
14244 return nativeResponseValue;
14246 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
14248 export function CResult_boolPeerHandleErrorZ_ok(o: boolean): bigint {
14249 if(!isWasmInitialized) {
14250 throw new Error("initializeWasm() must be awaited first!");
14252 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_ok(o);
14253 return nativeResponseValue;
14255 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
14257 export function CResult_boolPeerHandleErrorZ_err(e: bigint): bigint {
14258 if(!isWasmInitialized) {
14259 throw new Error("initializeWasm() must be awaited first!");
14261 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_err(e);
14262 return nativeResponseValue;
14264 // bool CResult_boolPeerHandleErrorZ_is_ok(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR o);
14266 export function CResult_boolPeerHandleErrorZ_is_ok(o: bigint): boolean {
14267 if(!isWasmInitialized) {
14268 throw new Error("initializeWasm() must be awaited first!");
14270 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_is_ok(o);
14271 return nativeResponseValue;
14273 // void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
14275 export function CResult_boolPeerHandleErrorZ_free(_res: bigint): void {
14276 if(!isWasmInitialized) {
14277 throw new Error("initializeWasm() must be awaited first!");
14279 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_free(_res);
14280 // debug statements here
14282 // uint64_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg);
14284 export function CResult_boolPeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
14285 if(!isWasmInitialized) {
14286 throw new Error("initializeWasm() must be awaited first!");
14288 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone_ptr(arg);
14289 return nativeResponseValue;
14291 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
14293 export function CResult_boolPeerHandleErrorZ_clone(orig: bigint): bigint {
14294 if(!isWasmInitialized) {
14295 throw new Error("initializeWasm() must be awaited first!");
14297 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone(orig);
14298 return nativeResponseValue;
14300 // struct LDKCResult_NoneSendErrorZ CResult_NoneSendErrorZ_ok(void);
14302 export function CResult_NoneSendErrorZ_ok(): bigint {
14303 if(!isWasmInitialized) {
14304 throw new Error("initializeWasm() must be awaited first!");
14306 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_ok();
14307 return nativeResponseValue;
14309 // struct LDKCResult_NoneSendErrorZ CResult_NoneSendErrorZ_err(struct LDKSendError e);
14311 export function CResult_NoneSendErrorZ_err(e: bigint): bigint {
14312 if(!isWasmInitialized) {
14313 throw new Error("initializeWasm() must be awaited first!");
14315 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_err(e);
14316 return nativeResponseValue;
14318 // bool CResult_NoneSendErrorZ_is_ok(const struct LDKCResult_NoneSendErrorZ *NONNULL_PTR o);
14320 export function CResult_NoneSendErrorZ_is_ok(o: bigint): boolean {
14321 if(!isWasmInitialized) {
14322 throw new Error("initializeWasm() must be awaited first!");
14324 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_is_ok(o);
14325 return nativeResponseValue;
14327 // void CResult_NoneSendErrorZ_free(struct LDKCResult_NoneSendErrorZ _res);
14329 export function CResult_NoneSendErrorZ_free(_res: bigint): void {
14330 if(!isWasmInitialized) {
14331 throw new Error("initializeWasm() must be awaited first!");
14333 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_free(_res);
14334 // debug statements here
14336 // struct LDKCResult_u32GraphSyncErrorZ CResult_u32GraphSyncErrorZ_ok(uint32_t o);
14338 export function CResult_u32GraphSyncErrorZ_ok(o: number): bigint {
14339 if(!isWasmInitialized) {
14340 throw new Error("initializeWasm() must be awaited first!");
14342 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_ok(o);
14343 return nativeResponseValue;
14345 // struct LDKCResult_u32GraphSyncErrorZ CResult_u32GraphSyncErrorZ_err(struct LDKGraphSyncError e);
14347 export function CResult_u32GraphSyncErrorZ_err(e: bigint): bigint {
14348 if(!isWasmInitialized) {
14349 throw new Error("initializeWasm() must be awaited first!");
14351 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_err(e);
14352 return nativeResponseValue;
14354 // bool CResult_u32GraphSyncErrorZ_is_ok(const struct LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR o);
14356 export function CResult_u32GraphSyncErrorZ_is_ok(o: bigint): boolean {
14357 if(!isWasmInitialized) {
14358 throw new Error("initializeWasm() must be awaited first!");
14360 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_is_ok(o);
14361 return nativeResponseValue;
14363 // void CResult_u32GraphSyncErrorZ_free(struct LDKCResult_u32GraphSyncErrorZ _res);
14365 export function CResult_u32GraphSyncErrorZ_free(_res: bigint): void {
14366 if(!isWasmInitialized) {
14367 throw new Error("initializeWasm() must be awaited first!");
14369 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_free(_res);
14370 // debug statements here
14372 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_ok(void);
14374 export function CResult_NoneErrorZ_ok(): bigint {
14375 if(!isWasmInitialized) {
14376 throw new Error("initializeWasm() must be awaited first!");
14378 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_ok();
14379 return nativeResponseValue;
14381 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_err(enum LDKIOError e);
14383 export function CResult_NoneErrorZ_err(e: IOError): bigint {
14384 if(!isWasmInitialized) {
14385 throw new Error("initializeWasm() must be awaited first!");
14387 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_err(e);
14388 return nativeResponseValue;
14390 // bool CResult_NoneErrorZ_is_ok(const struct LDKCResult_NoneErrorZ *NONNULL_PTR o);
14392 export function CResult_NoneErrorZ_is_ok(o: bigint): boolean {
14393 if(!isWasmInitialized) {
14394 throw new Error("initializeWasm() must be awaited first!");
14396 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_is_ok(o);
14397 return nativeResponseValue;
14399 // void CResult_NoneErrorZ_free(struct LDKCResult_NoneErrorZ _res);
14401 export function CResult_NoneErrorZ_free(_res: bigint): void {
14402 if(!isWasmInitialized) {
14403 throw new Error("initializeWasm() must be awaited first!");
14405 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_free(_res);
14406 // debug statements here
14408 // uint64_t CResult_NoneErrorZ_clone_ptr(LDKCResult_NoneErrorZ *NONNULL_PTR arg);
14410 export function CResult_NoneErrorZ_clone_ptr(arg: bigint): bigint {
14411 if(!isWasmInitialized) {
14412 throw new Error("initializeWasm() must be awaited first!");
14414 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone_ptr(arg);
14415 return nativeResponseValue;
14417 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_clone(const struct LDKCResult_NoneErrorZ *NONNULL_PTR orig);
14419 export function CResult_NoneErrorZ_clone(orig: bigint): bigint {
14420 if(!isWasmInitialized) {
14421 throw new Error("initializeWasm() must be awaited first!");
14423 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone(orig);
14424 return nativeResponseValue;
14426 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_ok(struct LDKNetAddress o);
14428 export function CResult_NetAddressDecodeErrorZ_ok(o: bigint): bigint {
14429 if(!isWasmInitialized) {
14430 throw new Error("initializeWasm() must be awaited first!");
14432 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_ok(o);
14433 return nativeResponseValue;
14435 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_err(struct LDKDecodeError e);
14437 export function CResult_NetAddressDecodeErrorZ_err(e: bigint): bigint {
14438 if(!isWasmInitialized) {
14439 throw new Error("initializeWasm() must be awaited first!");
14441 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_err(e);
14442 return nativeResponseValue;
14444 // bool CResult_NetAddressDecodeErrorZ_is_ok(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR o);
14446 export function CResult_NetAddressDecodeErrorZ_is_ok(o: bigint): boolean {
14447 if(!isWasmInitialized) {
14448 throw new Error("initializeWasm() must be awaited first!");
14450 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_is_ok(o);
14451 return nativeResponseValue;
14453 // void CResult_NetAddressDecodeErrorZ_free(struct LDKCResult_NetAddressDecodeErrorZ _res);
14455 export function CResult_NetAddressDecodeErrorZ_free(_res: bigint): void {
14456 if(!isWasmInitialized) {
14457 throw new Error("initializeWasm() must be awaited first!");
14459 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_free(_res);
14460 // debug statements here
14462 // uint64_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg);
14464 export function CResult_NetAddressDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14465 if(!isWasmInitialized) {
14466 throw new Error("initializeWasm() must be awaited first!");
14468 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone_ptr(arg);
14469 return nativeResponseValue;
14471 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_clone(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR orig);
14473 export function CResult_NetAddressDecodeErrorZ_clone(orig: bigint): bigint {
14474 if(!isWasmInitialized) {
14475 throw new Error("initializeWasm() must be awaited first!");
14477 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone(orig);
14478 return nativeResponseValue;
14480 // void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
14482 export function CVec_UpdateAddHTLCZ_free(_res: number): void {
14483 if(!isWasmInitialized) {
14484 throw new Error("initializeWasm() must be awaited first!");
14486 const nativeResponseValue = wasm.TS_CVec_UpdateAddHTLCZ_free(_res);
14487 // debug statements here
14489 // void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
14491 export function CVec_UpdateFulfillHTLCZ_free(_res: number): void {
14492 if(!isWasmInitialized) {
14493 throw new Error("initializeWasm() must be awaited first!");
14495 const nativeResponseValue = wasm.TS_CVec_UpdateFulfillHTLCZ_free(_res);
14496 // debug statements here
14498 // void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
14500 export function CVec_UpdateFailHTLCZ_free(_res: number): void {
14501 if(!isWasmInitialized) {
14502 throw new Error("initializeWasm() must be awaited first!");
14504 const nativeResponseValue = wasm.TS_CVec_UpdateFailHTLCZ_free(_res);
14505 // debug statements here
14507 // void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
14509 export function CVec_UpdateFailMalformedHTLCZ_free(_res: number): void {
14510 if(!isWasmInitialized) {
14511 throw new Error("initializeWasm() must be awaited first!");
14513 const nativeResponseValue = wasm.TS_CVec_UpdateFailMalformedHTLCZ_free(_res);
14514 // debug statements here
14516 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
14518 export function CResult_AcceptChannelDecodeErrorZ_ok(o: bigint): bigint {
14519 if(!isWasmInitialized) {
14520 throw new Error("initializeWasm() must be awaited first!");
14522 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_ok(o);
14523 return nativeResponseValue;
14525 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
14527 export function CResult_AcceptChannelDecodeErrorZ_err(e: bigint): bigint {
14528 if(!isWasmInitialized) {
14529 throw new Error("initializeWasm() must be awaited first!");
14531 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_err(e);
14532 return nativeResponseValue;
14534 // bool CResult_AcceptChannelDecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR o);
14536 export function CResult_AcceptChannelDecodeErrorZ_is_ok(o: bigint): boolean {
14537 if(!isWasmInitialized) {
14538 throw new Error("initializeWasm() must be awaited first!");
14540 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_is_ok(o);
14541 return nativeResponseValue;
14543 // void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
14545 export function CResult_AcceptChannelDecodeErrorZ_free(_res: bigint): void {
14546 if(!isWasmInitialized) {
14547 throw new Error("initializeWasm() must be awaited first!");
14549 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_free(_res);
14550 // debug statements here
14552 // uint64_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg);
14554 export function CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14555 if(!isWasmInitialized) {
14556 throw new Error("initializeWasm() must be awaited first!");
14558 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg);
14559 return nativeResponseValue;
14561 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
14563 export function CResult_AcceptChannelDecodeErrorZ_clone(orig: bigint): bigint {
14564 if(!isWasmInitialized) {
14565 throw new Error("initializeWasm() must be awaited first!");
14567 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone(orig);
14568 return nativeResponseValue;
14570 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
14572 export function CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: bigint): bigint {
14573 if(!isWasmInitialized) {
14574 throw new Error("initializeWasm() must be awaited first!");
14576 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(o);
14577 return nativeResponseValue;
14579 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
14581 export function CResult_AnnouncementSignaturesDecodeErrorZ_err(e: bigint): bigint {
14582 if(!isWasmInitialized) {
14583 throw new Error("initializeWasm() must be awaited first!");
14585 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(e);
14586 return nativeResponseValue;
14588 // bool CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR o);
14590 export function CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o: bigint): boolean {
14591 if(!isWasmInitialized) {
14592 throw new Error("initializeWasm() must be awaited first!");
14594 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o);
14595 return nativeResponseValue;
14597 // void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
14599 export function CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: bigint): void {
14600 if(!isWasmInitialized) {
14601 throw new Error("initializeWasm() must be awaited first!");
14603 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(_res);
14604 // debug statements here
14606 // uint64_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg);
14608 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14609 if(!isWasmInitialized) {
14610 throw new Error("initializeWasm() must be awaited first!");
14612 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg);
14613 return nativeResponseValue;
14615 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
14617 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: bigint): bigint {
14618 if(!isWasmInitialized) {
14619 throw new Error("initializeWasm() must be awaited first!");
14621 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig);
14622 return nativeResponseValue;
14624 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
14626 export function CResult_ChannelReestablishDecodeErrorZ_ok(o: bigint): bigint {
14627 if(!isWasmInitialized) {
14628 throw new Error("initializeWasm() must be awaited first!");
14630 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_ok(o);
14631 return nativeResponseValue;
14633 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
14635 export function CResult_ChannelReestablishDecodeErrorZ_err(e: bigint): bigint {
14636 if(!isWasmInitialized) {
14637 throw new Error("initializeWasm() must be awaited first!");
14639 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_err(e);
14640 return nativeResponseValue;
14642 // bool CResult_ChannelReestablishDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR o);
14644 export function CResult_ChannelReestablishDecodeErrorZ_is_ok(o: bigint): boolean {
14645 if(!isWasmInitialized) {
14646 throw new Error("initializeWasm() must be awaited first!");
14648 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(o);
14649 return nativeResponseValue;
14651 // void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
14653 export function CResult_ChannelReestablishDecodeErrorZ_free(_res: bigint): void {
14654 if(!isWasmInitialized) {
14655 throw new Error("initializeWasm() must be awaited first!");
14657 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_free(_res);
14658 // debug statements here
14660 // uint64_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg);
14662 export function CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14663 if(!isWasmInitialized) {
14664 throw new Error("initializeWasm() must be awaited first!");
14666 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg);
14667 return nativeResponseValue;
14669 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
14671 export function CResult_ChannelReestablishDecodeErrorZ_clone(orig: bigint): bigint {
14672 if(!isWasmInitialized) {
14673 throw new Error("initializeWasm() must be awaited first!");
14675 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone(orig);
14676 return nativeResponseValue;
14678 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
14680 export function CResult_ClosingSignedDecodeErrorZ_ok(o: bigint): bigint {
14681 if(!isWasmInitialized) {
14682 throw new Error("initializeWasm() must be awaited first!");
14684 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_ok(o);
14685 return nativeResponseValue;
14687 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
14689 export function CResult_ClosingSignedDecodeErrorZ_err(e: bigint): bigint {
14690 if(!isWasmInitialized) {
14691 throw new Error("initializeWasm() must be awaited first!");
14693 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_err(e);
14694 return nativeResponseValue;
14696 // bool CResult_ClosingSignedDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR o);
14698 export function CResult_ClosingSignedDecodeErrorZ_is_ok(o: bigint): boolean {
14699 if(!isWasmInitialized) {
14700 throw new Error("initializeWasm() must be awaited first!");
14702 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_is_ok(o);
14703 return nativeResponseValue;
14705 // void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
14707 export function CResult_ClosingSignedDecodeErrorZ_free(_res: bigint): void {
14708 if(!isWasmInitialized) {
14709 throw new Error("initializeWasm() must be awaited first!");
14711 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_free(_res);
14712 // debug statements here
14714 // uint64_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg);
14716 export function CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14717 if(!isWasmInitialized) {
14718 throw new Error("initializeWasm() must be awaited first!");
14720 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg);
14721 return nativeResponseValue;
14723 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
14725 export function CResult_ClosingSignedDecodeErrorZ_clone(orig: bigint): bigint {
14726 if(!isWasmInitialized) {
14727 throw new Error("initializeWasm() must be awaited first!");
14729 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone(orig);
14730 return nativeResponseValue;
14732 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(struct LDKClosingSignedFeeRange o);
14734 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o: bigint): bigint {
14735 if(!isWasmInitialized) {
14736 throw new Error("initializeWasm() must be awaited first!");
14738 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o);
14739 return nativeResponseValue;
14741 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_err(struct LDKDecodeError e);
14743 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e: bigint): bigint {
14744 if(!isWasmInitialized) {
14745 throw new Error("initializeWasm() must be awaited first!");
14747 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e);
14748 return nativeResponseValue;
14750 // bool CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR o);
14752 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o: bigint): boolean {
14753 if(!isWasmInitialized) {
14754 throw new Error("initializeWasm() must be awaited first!");
14756 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o);
14757 return nativeResponseValue;
14759 // void CResult_ClosingSignedFeeRangeDecodeErrorZ_free(struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res);
14761 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res: bigint): void {
14762 if(!isWasmInitialized) {
14763 throw new Error("initializeWasm() must be awaited first!");
14765 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res);
14766 // debug statements here
14768 // uint64_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg);
14770 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14771 if(!isWasmInitialized) {
14772 throw new Error("initializeWasm() must be awaited first!");
14774 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg);
14775 return nativeResponseValue;
14777 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR orig);
14779 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig: bigint): bigint {
14780 if(!isWasmInitialized) {
14781 throw new Error("initializeWasm() must be awaited first!");
14783 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig);
14784 return nativeResponseValue;
14786 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
14788 export function CResult_CommitmentSignedDecodeErrorZ_ok(o: bigint): bigint {
14789 if(!isWasmInitialized) {
14790 throw new Error("initializeWasm() must be awaited first!");
14792 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_ok(o);
14793 return nativeResponseValue;
14795 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
14797 export function CResult_CommitmentSignedDecodeErrorZ_err(e: bigint): bigint {
14798 if(!isWasmInitialized) {
14799 throw new Error("initializeWasm() must be awaited first!");
14801 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_err(e);
14802 return nativeResponseValue;
14804 // bool CResult_CommitmentSignedDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR o);
14806 export function CResult_CommitmentSignedDecodeErrorZ_is_ok(o: bigint): boolean {
14807 if(!isWasmInitialized) {
14808 throw new Error("initializeWasm() must be awaited first!");
14810 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(o);
14811 return nativeResponseValue;
14813 // void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
14815 export function CResult_CommitmentSignedDecodeErrorZ_free(_res: bigint): void {
14816 if(!isWasmInitialized) {
14817 throw new Error("initializeWasm() must be awaited first!");
14819 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_free(_res);
14820 // debug statements here
14822 // uint64_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg);
14824 export function CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14825 if(!isWasmInitialized) {
14826 throw new Error("initializeWasm() must be awaited first!");
14828 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg);
14829 return nativeResponseValue;
14831 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
14833 export function CResult_CommitmentSignedDecodeErrorZ_clone(orig: bigint): bigint {
14834 if(!isWasmInitialized) {
14835 throw new Error("initializeWasm() must be awaited first!");
14837 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone(orig);
14838 return nativeResponseValue;
14840 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
14842 export function CResult_FundingCreatedDecodeErrorZ_ok(o: bigint): bigint {
14843 if(!isWasmInitialized) {
14844 throw new Error("initializeWasm() must be awaited first!");
14846 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_ok(o);
14847 return nativeResponseValue;
14849 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
14851 export function CResult_FundingCreatedDecodeErrorZ_err(e: bigint): bigint {
14852 if(!isWasmInitialized) {
14853 throw new Error("initializeWasm() must be awaited first!");
14855 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_err(e);
14856 return nativeResponseValue;
14858 // bool CResult_FundingCreatedDecodeErrorZ_is_ok(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR o);
14860 export function CResult_FundingCreatedDecodeErrorZ_is_ok(o: bigint): boolean {
14861 if(!isWasmInitialized) {
14862 throw new Error("initializeWasm() must be awaited first!");
14864 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_is_ok(o);
14865 return nativeResponseValue;
14867 // void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
14869 export function CResult_FundingCreatedDecodeErrorZ_free(_res: bigint): void {
14870 if(!isWasmInitialized) {
14871 throw new Error("initializeWasm() must be awaited first!");
14873 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_free(_res);
14874 // debug statements here
14876 // uint64_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg);
14878 export function CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14879 if(!isWasmInitialized) {
14880 throw new Error("initializeWasm() must be awaited first!");
14882 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg);
14883 return nativeResponseValue;
14885 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
14887 export function CResult_FundingCreatedDecodeErrorZ_clone(orig: bigint): bigint {
14888 if(!isWasmInitialized) {
14889 throw new Error("initializeWasm() must be awaited first!");
14891 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone(orig);
14892 return nativeResponseValue;
14894 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
14896 export function CResult_FundingSignedDecodeErrorZ_ok(o: bigint): bigint {
14897 if(!isWasmInitialized) {
14898 throw new Error("initializeWasm() must be awaited first!");
14900 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_ok(o);
14901 return nativeResponseValue;
14903 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
14905 export function CResult_FundingSignedDecodeErrorZ_err(e: bigint): bigint {
14906 if(!isWasmInitialized) {
14907 throw new Error("initializeWasm() must be awaited first!");
14909 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_err(e);
14910 return nativeResponseValue;
14912 // bool CResult_FundingSignedDecodeErrorZ_is_ok(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR o);
14914 export function CResult_FundingSignedDecodeErrorZ_is_ok(o: bigint): boolean {
14915 if(!isWasmInitialized) {
14916 throw new Error("initializeWasm() must be awaited first!");
14918 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_is_ok(o);
14919 return nativeResponseValue;
14921 // void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
14923 export function CResult_FundingSignedDecodeErrorZ_free(_res: bigint): void {
14924 if(!isWasmInitialized) {
14925 throw new Error("initializeWasm() must be awaited first!");
14927 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_free(_res);
14928 // debug statements here
14930 // uint64_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg);
14932 export function CResult_FundingSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14933 if(!isWasmInitialized) {
14934 throw new Error("initializeWasm() must be awaited first!");
14936 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(arg);
14937 return nativeResponseValue;
14939 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
14941 export function CResult_FundingSignedDecodeErrorZ_clone(orig: bigint): bigint {
14942 if(!isWasmInitialized) {
14943 throw new Error("initializeWasm() must be awaited first!");
14945 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone(orig);
14946 return nativeResponseValue;
14948 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_ok(struct LDKChannelReady o);
14950 export function CResult_ChannelReadyDecodeErrorZ_ok(o: bigint): bigint {
14951 if(!isWasmInitialized) {
14952 throw new Error("initializeWasm() must be awaited first!");
14954 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_ok(o);
14955 return nativeResponseValue;
14957 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_err(struct LDKDecodeError e);
14959 export function CResult_ChannelReadyDecodeErrorZ_err(e: bigint): bigint {
14960 if(!isWasmInitialized) {
14961 throw new Error("initializeWasm() must be awaited first!");
14963 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_err(e);
14964 return nativeResponseValue;
14966 // bool CResult_ChannelReadyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR o);
14968 export function CResult_ChannelReadyDecodeErrorZ_is_ok(o: bigint): boolean {
14969 if(!isWasmInitialized) {
14970 throw new Error("initializeWasm() must be awaited first!");
14972 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_is_ok(o);
14973 return nativeResponseValue;
14975 // void CResult_ChannelReadyDecodeErrorZ_free(struct LDKCResult_ChannelReadyDecodeErrorZ _res);
14977 export function CResult_ChannelReadyDecodeErrorZ_free(_res: bigint): void {
14978 if(!isWasmInitialized) {
14979 throw new Error("initializeWasm() must be awaited first!");
14981 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_free(_res);
14982 // debug statements here
14984 // uint64_t CResult_ChannelReadyDecodeErrorZ_clone_ptr(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR arg);
14986 export function CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14987 if(!isWasmInitialized) {
14988 throw new Error("initializeWasm() must be awaited first!");
14990 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg);
14991 return nativeResponseValue;
14993 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_clone(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR orig);
14995 export function CResult_ChannelReadyDecodeErrorZ_clone(orig: bigint): bigint {
14996 if(!isWasmInitialized) {
14997 throw new Error("initializeWasm() must be awaited first!");
14999 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone(orig);
15000 return nativeResponseValue;
15002 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
15004 export function CResult_InitDecodeErrorZ_ok(o: bigint): bigint {
15005 if(!isWasmInitialized) {
15006 throw new Error("initializeWasm() must be awaited first!");
15008 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_ok(o);
15009 return nativeResponseValue;
15011 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
15013 export function CResult_InitDecodeErrorZ_err(e: bigint): bigint {
15014 if(!isWasmInitialized) {
15015 throw new Error("initializeWasm() must be awaited first!");
15017 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_err(e);
15018 return nativeResponseValue;
15020 // bool CResult_InitDecodeErrorZ_is_ok(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR o);
15022 export function CResult_InitDecodeErrorZ_is_ok(o: bigint): boolean {
15023 if(!isWasmInitialized) {
15024 throw new Error("initializeWasm() must be awaited first!");
15026 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_is_ok(o);
15027 return nativeResponseValue;
15029 // void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
15031 export function CResult_InitDecodeErrorZ_free(_res: bigint): void {
15032 if(!isWasmInitialized) {
15033 throw new Error("initializeWasm() must be awaited first!");
15035 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_free(_res);
15036 // debug statements here
15038 // uint64_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg);
15040 export function CResult_InitDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15041 if(!isWasmInitialized) {
15042 throw new Error("initializeWasm() must be awaited first!");
15044 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone_ptr(arg);
15045 return nativeResponseValue;
15047 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
15049 export function CResult_InitDecodeErrorZ_clone(orig: bigint): bigint {
15050 if(!isWasmInitialized) {
15051 throw new Error("initializeWasm() must be awaited first!");
15053 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone(orig);
15054 return nativeResponseValue;
15056 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
15058 export function CResult_OpenChannelDecodeErrorZ_ok(o: bigint): bigint {
15059 if(!isWasmInitialized) {
15060 throw new Error("initializeWasm() must be awaited first!");
15062 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_ok(o);
15063 return nativeResponseValue;
15065 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
15067 export function CResult_OpenChannelDecodeErrorZ_err(e: bigint): bigint {
15068 if(!isWasmInitialized) {
15069 throw new Error("initializeWasm() must be awaited first!");
15071 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_err(e);
15072 return nativeResponseValue;
15074 // bool CResult_OpenChannelDecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR o);
15076 export function CResult_OpenChannelDecodeErrorZ_is_ok(o: bigint): boolean {
15077 if(!isWasmInitialized) {
15078 throw new Error("initializeWasm() must be awaited first!");
15080 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_is_ok(o);
15081 return nativeResponseValue;
15083 // void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
15085 export function CResult_OpenChannelDecodeErrorZ_free(_res: bigint): void {
15086 if(!isWasmInitialized) {
15087 throw new Error("initializeWasm() must be awaited first!");
15089 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_free(_res);
15090 // debug statements here
15092 // uint64_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg);
15094 export function CResult_OpenChannelDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15095 if(!isWasmInitialized) {
15096 throw new Error("initializeWasm() must be awaited first!");
15098 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(arg);
15099 return nativeResponseValue;
15101 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
15103 export function CResult_OpenChannelDecodeErrorZ_clone(orig: bigint): bigint {
15104 if(!isWasmInitialized) {
15105 throw new Error("initializeWasm() must be awaited first!");
15107 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone(orig);
15108 return nativeResponseValue;
15110 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
15112 export function CResult_RevokeAndACKDecodeErrorZ_ok(o: bigint): bigint {
15113 if(!isWasmInitialized) {
15114 throw new Error("initializeWasm() must be awaited first!");
15116 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_ok(o);
15117 return nativeResponseValue;
15119 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
15121 export function CResult_RevokeAndACKDecodeErrorZ_err(e: bigint): bigint {
15122 if(!isWasmInitialized) {
15123 throw new Error("initializeWasm() must be awaited first!");
15125 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_err(e);
15126 return nativeResponseValue;
15128 // bool CResult_RevokeAndACKDecodeErrorZ_is_ok(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR o);
15130 export function CResult_RevokeAndACKDecodeErrorZ_is_ok(o: bigint): boolean {
15131 if(!isWasmInitialized) {
15132 throw new Error("initializeWasm() must be awaited first!");
15134 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(o);
15135 return nativeResponseValue;
15137 // void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
15139 export function CResult_RevokeAndACKDecodeErrorZ_free(_res: bigint): void {
15140 if(!isWasmInitialized) {
15141 throw new Error("initializeWasm() must be awaited first!");
15143 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_free(_res);
15144 // debug statements here
15146 // uint64_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg);
15148 export function CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15149 if(!isWasmInitialized) {
15150 throw new Error("initializeWasm() must be awaited first!");
15152 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg);
15153 return nativeResponseValue;
15155 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
15157 export function CResult_RevokeAndACKDecodeErrorZ_clone(orig: bigint): bigint {
15158 if(!isWasmInitialized) {
15159 throw new Error("initializeWasm() must be awaited first!");
15161 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone(orig);
15162 return nativeResponseValue;
15164 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
15166 export function CResult_ShutdownDecodeErrorZ_ok(o: bigint): bigint {
15167 if(!isWasmInitialized) {
15168 throw new Error("initializeWasm() must be awaited first!");
15170 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_ok(o);
15171 return nativeResponseValue;
15173 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
15175 export function CResult_ShutdownDecodeErrorZ_err(e: bigint): bigint {
15176 if(!isWasmInitialized) {
15177 throw new Error("initializeWasm() must be awaited first!");
15179 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_err(e);
15180 return nativeResponseValue;
15182 // bool CResult_ShutdownDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR o);
15184 export function CResult_ShutdownDecodeErrorZ_is_ok(o: bigint): boolean {
15185 if(!isWasmInitialized) {
15186 throw new Error("initializeWasm() must be awaited first!");
15188 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_is_ok(o);
15189 return nativeResponseValue;
15191 // void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
15193 export function CResult_ShutdownDecodeErrorZ_free(_res: bigint): void {
15194 if(!isWasmInitialized) {
15195 throw new Error("initializeWasm() must be awaited first!");
15197 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_free(_res);
15198 // debug statements here
15200 // uint64_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg);
15202 export function CResult_ShutdownDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15203 if(!isWasmInitialized) {
15204 throw new Error("initializeWasm() must be awaited first!");
15206 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone_ptr(arg);
15207 return nativeResponseValue;
15209 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
15211 export function CResult_ShutdownDecodeErrorZ_clone(orig: bigint): bigint {
15212 if(!isWasmInitialized) {
15213 throw new Error("initializeWasm() must be awaited first!");
15215 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone(orig);
15216 return nativeResponseValue;
15218 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
15220 export function CResult_UpdateFailHTLCDecodeErrorZ_ok(o: bigint): bigint {
15221 if(!isWasmInitialized) {
15222 throw new Error("initializeWasm() must be awaited first!");
15224 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(o);
15225 return nativeResponseValue;
15227 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
15229 export function CResult_UpdateFailHTLCDecodeErrorZ_err(e: bigint): bigint {
15230 if(!isWasmInitialized) {
15231 throw new Error("initializeWasm() must be awaited first!");
15233 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_err(e);
15234 return nativeResponseValue;
15236 // bool CResult_UpdateFailHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR o);
15238 export function CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
15239 if(!isWasmInitialized) {
15240 throw new Error("initializeWasm() must be awaited first!");
15242 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o);
15243 return nativeResponseValue;
15245 // void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
15247 export function CResult_UpdateFailHTLCDecodeErrorZ_free(_res: bigint): void {
15248 if(!isWasmInitialized) {
15249 throw new Error("initializeWasm() must be awaited first!");
15251 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_free(_res);
15252 // debug statements here
15254 // uint64_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg);
15256 export function CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15257 if(!isWasmInitialized) {
15258 throw new Error("initializeWasm() must be awaited first!");
15260 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg);
15261 return nativeResponseValue;
15263 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
15265 export function CResult_UpdateFailHTLCDecodeErrorZ_clone(orig: bigint): bigint {
15266 if(!isWasmInitialized) {
15267 throw new Error("initializeWasm() must be awaited first!");
15269 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(orig);
15270 return nativeResponseValue;
15272 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
15274 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o: bigint): bigint {
15275 if(!isWasmInitialized) {
15276 throw new Error("initializeWasm() must be awaited first!");
15278 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o);
15279 return nativeResponseValue;
15281 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
15283 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e: bigint): bigint {
15284 if(!isWasmInitialized) {
15285 throw new Error("initializeWasm() must be awaited first!");
15287 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e);
15288 return nativeResponseValue;
15290 // bool CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR o);
15292 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
15293 if(!isWasmInitialized) {
15294 throw new Error("initializeWasm() must be awaited first!");
15296 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o);
15297 return nativeResponseValue;
15299 // void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
15301 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res: bigint): void {
15302 if(!isWasmInitialized) {
15303 throw new Error("initializeWasm() must be awaited first!");
15305 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res);
15306 // debug statements here
15308 // uint64_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg);
15310 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15311 if(!isWasmInitialized) {
15312 throw new Error("initializeWasm() must be awaited first!");
15314 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg);
15315 return nativeResponseValue;
15317 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
15319 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig: bigint): bigint {
15320 if(!isWasmInitialized) {
15321 throw new Error("initializeWasm() must be awaited first!");
15323 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig);
15324 return nativeResponseValue;
15326 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
15328 export function CResult_UpdateFeeDecodeErrorZ_ok(o: bigint): bigint {
15329 if(!isWasmInitialized) {
15330 throw new Error("initializeWasm() must be awaited first!");
15332 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_ok(o);
15333 return nativeResponseValue;
15335 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
15337 export function CResult_UpdateFeeDecodeErrorZ_err(e: bigint): bigint {
15338 if(!isWasmInitialized) {
15339 throw new Error("initializeWasm() must be awaited first!");
15341 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_err(e);
15342 return nativeResponseValue;
15344 // bool CResult_UpdateFeeDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR o);
15346 export function CResult_UpdateFeeDecodeErrorZ_is_ok(o: bigint): boolean {
15347 if(!isWasmInitialized) {
15348 throw new Error("initializeWasm() must be awaited first!");
15350 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_is_ok(o);
15351 return nativeResponseValue;
15353 // void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
15355 export function CResult_UpdateFeeDecodeErrorZ_free(_res: bigint): void {
15356 if(!isWasmInitialized) {
15357 throw new Error("initializeWasm() must be awaited first!");
15359 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_free(_res);
15360 // debug statements here
15362 // uint64_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg);
15364 export function CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15365 if(!isWasmInitialized) {
15366 throw new Error("initializeWasm() must be awaited first!");
15368 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg);
15369 return nativeResponseValue;
15371 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
15373 export function CResult_UpdateFeeDecodeErrorZ_clone(orig: bigint): bigint {
15374 if(!isWasmInitialized) {
15375 throw new Error("initializeWasm() must be awaited first!");
15377 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone(orig);
15378 return nativeResponseValue;
15380 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
15382 export function CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o: bigint): bigint {
15383 if(!isWasmInitialized) {
15384 throw new Error("initializeWasm() must be awaited first!");
15386 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o);
15387 return nativeResponseValue;
15389 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
15391 export function CResult_UpdateFulfillHTLCDecodeErrorZ_err(e: bigint): bigint {
15392 if(!isWasmInitialized) {
15393 throw new Error("initializeWasm() must be awaited first!");
15395 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(e);
15396 return nativeResponseValue;
15398 // bool CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR o);
15400 export function CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
15401 if(!isWasmInitialized) {
15402 throw new Error("initializeWasm() must be awaited first!");
15404 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o);
15405 return nativeResponseValue;
15407 // void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
15409 export function CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res: bigint): void {
15410 if(!isWasmInitialized) {
15411 throw new Error("initializeWasm() must be awaited first!");
15413 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res);
15414 // debug statements here
15416 // uint64_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg);
15418 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15419 if(!isWasmInitialized) {
15420 throw new Error("initializeWasm() must be awaited first!");
15422 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg);
15423 return nativeResponseValue;
15425 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
15427 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig: bigint): bigint {
15428 if(!isWasmInitialized) {
15429 throw new Error("initializeWasm() must be awaited first!");
15431 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig);
15432 return nativeResponseValue;
15434 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
15436 export function CResult_UpdateAddHTLCDecodeErrorZ_ok(o: bigint): bigint {
15437 if(!isWasmInitialized) {
15438 throw new Error("initializeWasm() must be awaited first!");
15440 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(o);
15441 return nativeResponseValue;
15443 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
15445 export function CResult_UpdateAddHTLCDecodeErrorZ_err(e: bigint): bigint {
15446 if(!isWasmInitialized) {
15447 throw new Error("initializeWasm() must be awaited first!");
15449 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_err(e);
15450 return nativeResponseValue;
15452 // bool CResult_UpdateAddHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR o);
15454 export function CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
15455 if(!isWasmInitialized) {
15456 throw new Error("initializeWasm() must be awaited first!");
15458 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o);
15459 return nativeResponseValue;
15461 // void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
15463 export function CResult_UpdateAddHTLCDecodeErrorZ_free(_res: bigint): void {
15464 if(!isWasmInitialized) {
15465 throw new Error("initializeWasm() must be awaited first!");
15467 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_free(_res);
15468 // debug statements here
15470 // uint64_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg);
15472 export function CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15473 if(!isWasmInitialized) {
15474 throw new Error("initializeWasm() must be awaited first!");
15476 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg);
15477 return nativeResponseValue;
15479 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
15481 export function CResult_UpdateAddHTLCDecodeErrorZ_clone(orig: bigint): bigint {
15482 if(!isWasmInitialized) {
15483 throw new Error("initializeWasm() must be awaited first!");
15485 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(orig);
15486 return nativeResponseValue;
15488 // struct LDKCResult_OnionMessageDecodeErrorZ CResult_OnionMessageDecodeErrorZ_ok(struct LDKOnionMessage o);
15490 export function CResult_OnionMessageDecodeErrorZ_ok(o: bigint): bigint {
15491 if(!isWasmInitialized) {
15492 throw new Error("initializeWasm() must be awaited first!");
15494 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_ok(o);
15495 return nativeResponseValue;
15497 // struct LDKCResult_OnionMessageDecodeErrorZ CResult_OnionMessageDecodeErrorZ_err(struct LDKDecodeError e);
15499 export function CResult_OnionMessageDecodeErrorZ_err(e: bigint): bigint {
15500 if(!isWasmInitialized) {
15501 throw new Error("initializeWasm() must be awaited first!");
15503 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_err(e);
15504 return nativeResponseValue;
15506 // bool CResult_OnionMessageDecodeErrorZ_is_ok(const struct LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR o);
15508 export function CResult_OnionMessageDecodeErrorZ_is_ok(o: bigint): boolean {
15509 if(!isWasmInitialized) {
15510 throw new Error("initializeWasm() must be awaited first!");
15512 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_is_ok(o);
15513 return nativeResponseValue;
15515 // void CResult_OnionMessageDecodeErrorZ_free(struct LDKCResult_OnionMessageDecodeErrorZ _res);
15517 export function CResult_OnionMessageDecodeErrorZ_free(_res: bigint): void {
15518 if(!isWasmInitialized) {
15519 throw new Error("initializeWasm() must be awaited first!");
15521 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_free(_res);
15522 // debug statements here
15524 // uint64_t CResult_OnionMessageDecodeErrorZ_clone_ptr(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR arg);
15526 export function CResult_OnionMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15527 if(!isWasmInitialized) {
15528 throw new Error("initializeWasm() must be awaited first!");
15530 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_clone_ptr(arg);
15531 return nativeResponseValue;
15533 // struct LDKCResult_OnionMessageDecodeErrorZ CResult_OnionMessageDecodeErrorZ_clone(const struct LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR orig);
15535 export function CResult_OnionMessageDecodeErrorZ_clone(orig: bigint): bigint {
15536 if(!isWasmInitialized) {
15537 throw new Error("initializeWasm() must be awaited first!");
15539 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_clone(orig);
15540 return nativeResponseValue;
15542 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
15544 export function CResult_PingDecodeErrorZ_ok(o: bigint): bigint {
15545 if(!isWasmInitialized) {
15546 throw new Error("initializeWasm() must be awaited first!");
15548 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_ok(o);
15549 return nativeResponseValue;
15551 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
15553 export function CResult_PingDecodeErrorZ_err(e: bigint): bigint {
15554 if(!isWasmInitialized) {
15555 throw new Error("initializeWasm() must be awaited first!");
15557 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_err(e);
15558 return nativeResponseValue;
15560 // bool CResult_PingDecodeErrorZ_is_ok(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR o);
15562 export function CResult_PingDecodeErrorZ_is_ok(o: bigint): boolean {
15563 if(!isWasmInitialized) {
15564 throw new Error("initializeWasm() must be awaited first!");
15566 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_is_ok(o);
15567 return nativeResponseValue;
15569 // void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
15571 export function CResult_PingDecodeErrorZ_free(_res: bigint): void {
15572 if(!isWasmInitialized) {
15573 throw new Error("initializeWasm() must be awaited first!");
15575 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_free(_res);
15576 // debug statements here
15578 // uint64_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg);
15580 export function CResult_PingDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15581 if(!isWasmInitialized) {
15582 throw new Error("initializeWasm() must be awaited first!");
15584 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone_ptr(arg);
15585 return nativeResponseValue;
15587 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
15589 export function CResult_PingDecodeErrorZ_clone(orig: bigint): bigint {
15590 if(!isWasmInitialized) {
15591 throw new Error("initializeWasm() must be awaited first!");
15593 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone(orig);
15594 return nativeResponseValue;
15596 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
15598 export function CResult_PongDecodeErrorZ_ok(o: bigint): bigint {
15599 if(!isWasmInitialized) {
15600 throw new Error("initializeWasm() must be awaited first!");
15602 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_ok(o);
15603 return nativeResponseValue;
15605 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
15607 export function CResult_PongDecodeErrorZ_err(e: bigint): bigint {
15608 if(!isWasmInitialized) {
15609 throw new Error("initializeWasm() must be awaited first!");
15611 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_err(e);
15612 return nativeResponseValue;
15614 // bool CResult_PongDecodeErrorZ_is_ok(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR o);
15616 export function CResult_PongDecodeErrorZ_is_ok(o: bigint): boolean {
15617 if(!isWasmInitialized) {
15618 throw new Error("initializeWasm() must be awaited first!");
15620 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_is_ok(o);
15621 return nativeResponseValue;
15623 // void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
15625 export function CResult_PongDecodeErrorZ_free(_res: bigint): void {
15626 if(!isWasmInitialized) {
15627 throw new Error("initializeWasm() must be awaited first!");
15629 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_free(_res);
15630 // debug statements here
15632 // uint64_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg);
15634 export function CResult_PongDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15635 if(!isWasmInitialized) {
15636 throw new Error("initializeWasm() must be awaited first!");
15638 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone_ptr(arg);
15639 return nativeResponseValue;
15641 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
15643 export function CResult_PongDecodeErrorZ_clone(orig: bigint): bigint {
15644 if(!isWasmInitialized) {
15645 throw new Error("initializeWasm() must be awaited first!");
15647 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone(orig);
15648 return nativeResponseValue;
15650 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
15652 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
15653 if(!isWasmInitialized) {
15654 throw new Error("initializeWasm() must be awaited first!");
15656 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o);
15657 return nativeResponseValue;
15659 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
15661 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e: bigint): bigint {
15662 if(!isWasmInitialized) {
15663 throw new Error("initializeWasm() must be awaited first!");
15665 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e);
15666 return nativeResponseValue;
15668 // bool CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
15670 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
15671 if(!isWasmInitialized) {
15672 throw new Error("initializeWasm() must be awaited first!");
15674 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o);
15675 return nativeResponseValue;
15677 // void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
15679 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res: bigint): void {
15680 if(!isWasmInitialized) {
15681 throw new Error("initializeWasm() must be awaited first!");
15683 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res);
15684 // debug statements here
15686 // uint64_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
15688 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15689 if(!isWasmInitialized) {
15690 throw new Error("initializeWasm() must be awaited first!");
15692 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
15693 return nativeResponseValue;
15695 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
15697 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
15698 if(!isWasmInitialized) {
15699 throw new Error("initializeWasm() must be awaited first!");
15701 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig);
15702 return nativeResponseValue;
15704 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
15706 export function CResult_ChannelAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
15707 if(!isWasmInitialized) {
15708 throw new Error("initializeWasm() must be awaited first!");
15710 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(o);
15711 return nativeResponseValue;
15713 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
15715 export function CResult_ChannelAnnouncementDecodeErrorZ_err(e: bigint): bigint {
15716 if(!isWasmInitialized) {
15717 throw new Error("initializeWasm() must be awaited first!");
15719 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_err(e);
15720 return nativeResponseValue;
15722 // bool CResult_ChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
15724 export function CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
15725 if(!isWasmInitialized) {
15726 throw new Error("initializeWasm() must be awaited first!");
15728 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o);
15729 return nativeResponseValue;
15731 // void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
15733 export function CResult_ChannelAnnouncementDecodeErrorZ_free(_res: bigint): void {
15734 if(!isWasmInitialized) {
15735 throw new Error("initializeWasm() must be awaited first!");
15737 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_free(_res);
15738 // debug statements here
15740 // uint64_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
15742 export function CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15743 if(!isWasmInitialized) {
15744 throw new Error("initializeWasm() must be awaited first!");
15746 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
15747 return nativeResponseValue;
15749 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
15751 export function CResult_ChannelAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
15752 if(!isWasmInitialized) {
15753 throw new Error("initializeWasm() must be awaited first!");
15755 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(orig);
15756 return nativeResponseValue;
15758 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
15760 export function CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o: bigint): bigint {
15761 if(!isWasmInitialized) {
15762 throw new Error("initializeWasm() must be awaited first!");
15764 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o);
15765 return nativeResponseValue;
15767 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
15769 export function CResult_UnsignedChannelUpdateDecodeErrorZ_err(e: bigint): bigint {
15770 if(!isWasmInitialized) {
15771 throw new Error("initializeWasm() must be awaited first!");
15773 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(e);
15774 return nativeResponseValue;
15776 // bool CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR o);
15778 export function CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
15779 if(!isWasmInitialized) {
15780 throw new Error("initializeWasm() must be awaited first!");
15782 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o);
15783 return nativeResponseValue;
15785 // void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
15787 export function CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res: bigint): void {
15788 if(!isWasmInitialized) {
15789 throw new Error("initializeWasm() must be awaited first!");
15791 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res);
15792 // debug statements here
15794 // uint64_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
15796 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15797 if(!isWasmInitialized) {
15798 throw new Error("initializeWasm() must be awaited first!");
15800 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg);
15801 return nativeResponseValue;
15803 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
15805 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig: bigint): bigint {
15806 if(!isWasmInitialized) {
15807 throw new Error("initializeWasm() must be awaited first!");
15809 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig);
15810 return nativeResponseValue;
15812 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
15814 export function CResult_ChannelUpdateDecodeErrorZ_ok(o: bigint): bigint {
15815 if(!isWasmInitialized) {
15816 throw new Error("initializeWasm() must be awaited first!");
15818 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_ok(o);
15819 return nativeResponseValue;
15821 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
15823 export function CResult_ChannelUpdateDecodeErrorZ_err(e: bigint): bigint {
15824 if(!isWasmInitialized) {
15825 throw new Error("initializeWasm() must be awaited first!");
15827 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_err(e);
15828 return nativeResponseValue;
15830 // bool CResult_ChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR o);
15832 export function CResult_ChannelUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
15833 if(!isWasmInitialized) {
15834 throw new Error("initializeWasm() must be awaited first!");
15836 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(o);
15837 return nativeResponseValue;
15839 // void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
15841 export function CResult_ChannelUpdateDecodeErrorZ_free(_res: bigint): void {
15842 if(!isWasmInitialized) {
15843 throw new Error("initializeWasm() must be awaited first!");
15845 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_free(_res);
15846 // debug statements here
15848 // uint64_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
15850 export function CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15851 if(!isWasmInitialized) {
15852 throw new Error("initializeWasm() must be awaited first!");
15854 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg);
15855 return nativeResponseValue;
15857 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
15859 export function CResult_ChannelUpdateDecodeErrorZ_clone(orig: bigint): bigint {
15860 if(!isWasmInitialized) {
15861 throw new Error("initializeWasm() must be awaited first!");
15863 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone(orig);
15864 return nativeResponseValue;
15866 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
15868 export function CResult_ErrorMessageDecodeErrorZ_ok(o: bigint): bigint {
15869 if(!isWasmInitialized) {
15870 throw new Error("initializeWasm() must be awaited first!");
15872 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_ok(o);
15873 return nativeResponseValue;
15875 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
15877 export function CResult_ErrorMessageDecodeErrorZ_err(e: bigint): bigint {
15878 if(!isWasmInitialized) {
15879 throw new Error("initializeWasm() must be awaited first!");
15881 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_err(e);
15882 return nativeResponseValue;
15884 // bool CResult_ErrorMessageDecodeErrorZ_is_ok(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR o);
15886 export function CResult_ErrorMessageDecodeErrorZ_is_ok(o: bigint): boolean {
15887 if(!isWasmInitialized) {
15888 throw new Error("initializeWasm() must be awaited first!");
15890 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_is_ok(o);
15891 return nativeResponseValue;
15893 // void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
15895 export function CResult_ErrorMessageDecodeErrorZ_free(_res: bigint): void {
15896 if(!isWasmInitialized) {
15897 throw new Error("initializeWasm() must be awaited first!");
15899 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_free(_res);
15900 // debug statements here
15902 // uint64_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg);
15904 export function CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15905 if(!isWasmInitialized) {
15906 throw new Error("initializeWasm() must be awaited first!");
15908 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg);
15909 return nativeResponseValue;
15911 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
15913 export function CResult_ErrorMessageDecodeErrorZ_clone(orig: bigint): bigint {
15914 if(!isWasmInitialized) {
15915 throw new Error("initializeWasm() must be awaited first!");
15917 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone(orig);
15918 return nativeResponseValue;
15920 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_ok(struct LDKWarningMessage o);
15922 export function CResult_WarningMessageDecodeErrorZ_ok(o: bigint): bigint {
15923 if(!isWasmInitialized) {
15924 throw new Error("initializeWasm() must be awaited first!");
15926 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_ok(o);
15927 return nativeResponseValue;
15929 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_err(struct LDKDecodeError e);
15931 export function CResult_WarningMessageDecodeErrorZ_err(e: bigint): bigint {
15932 if(!isWasmInitialized) {
15933 throw new Error("initializeWasm() must be awaited first!");
15935 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_err(e);
15936 return nativeResponseValue;
15938 // bool CResult_WarningMessageDecodeErrorZ_is_ok(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR o);
15940 export function CResult_WarningMessageDecodeErrorZ_is_ok(o: bigint): boolean {
15941 if(!isWasmInitialized) {
15942 throw new Error("initializeWasm() must be awaited first!");
15944 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_is_ok(o);
15945 return nativeResponseValue;
15947 // void CResult_WarningMessageDecodeErrorZ_free(struct LDKCResult_WarningMessageDecodeErrorZ _res);
15949 export function CResult_WarningMessageDecodeErrorZ_free(_res: bigint): void {
15950 if(!isWasmInitialized) {
15951 throw new Error("initializeWasm() must be awaited first!");
15953 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_free(_res);
15954 // debug statements here
15956 // uint64_t CResult_WarningMessageDecodeErrorZ_clone_ptr(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR arg);
15958 export function CResult_WarningMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15959 if(!isWasmInitialized) {
15960 throw new Error("initializeWasm() must be awaited first!");
15962 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone_ptr(arg);
15963 return nativeResponseValue;
15965 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_clone(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR orig);
15967 export function CResult_WarningMessageDecodeErrorZ_clone(orig: bigint): bigint {
15968 if(!isWasmInitialized) {
15969 throw new Error("initializeWasm() must be awaited first!");
15971 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone(orig);
15972 return nativeResponseValue;
15974 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
15976 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
15977 if(!isWasmInitialized) {
15978 throw new Error("initializeWasm() must be awaited first!");
15980 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o);
15981 return nativeResponseValue;
15983 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
15985 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e: bigint): bigint {
15986 if(!isWasmInitialized) {
15987 throw new Error("initializeWasm() must be awaited first!");
15989 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e);
15990 return nativeResponseValue;
15992 // bool CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
15994 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
15995 if(!isWasmInitialized) {
15996 throw new Error("initializeWasm() must be awaited first!");
15998 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o);
15999 return nativeResponseValue;
16001 // void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
16003 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res: bigint): void {
16004 if(!isWasmInitialized) {
16005 throw new Error("initializeWasm() must be awaited first!");
16007 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res);
16008 // debug statements here
16010 // uint64_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
16012 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16013 if(!isWasmInitialized) {
16014 throw new Error("initializeWasm() must be awaited first!");
16016 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg);
16017 return nativeResponseValue;
16019 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
16021 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
16022 if(!isWasmInitialized) {
16023 throw new Error("initializeWasm() must be awaited first!");
16025 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig);
16026 return nativeResponseValue;
16028 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
16030 export function CResult_NodeAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
16031 if(!isWasmInitialized) {
16032 throw new Error("initializeWasm() must be awaited first!");
16034 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_ok(o);
16035 return nativeResponseValue;
16037 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
16039 export function CResult_NodeAnnouncementDecodeErrorZ_err(e: bigint): bigint {
16040 if(!isWasmInitialized) {
16041 throw new Error("initializeWasm() must be awaited first!");
16043 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_err(e);
16044 return nativeResponseValue;
16046 // bool CResult_NodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
16048 export function CResult_NodeAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
16049 if(!isWasmInitialized) {
16050 throw new Error("initializeWasm() must be awaited first!");
16052 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(o);
16053 return nativeResponseValue;
16055 // void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
16057 export function CResult_NodeAnnouncementDecodeErrorZ_free(_res: bigint): void {
16058 if(!isWasmInitialized) {
16059 throw new Error("initializeWasm() must be awaited first!");
16061 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_free(_res);
16062 // debug statements here
16064 // uint64_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
16066 export function CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16067 if(!isWasmInitialized) {
16068 throw new Error("initializeWasm() must be awaited first!");
16070 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg);
16071 return nativeResponseValue;
16073 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
16075 export function CResult_NodeAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
16076 if(!isWasmInitialized) {
16077 throw new Error("initializeWasm() must be awaited first!");
16079 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone(orig);
16080 return nativeResponseValue;
16082 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
16084 export function CResult_QueryShortChannelIdsDecodeErrorZ_ok(o: bigint): bigint {
16085 if(!isWasmInitialized) {
16086 throw new Error("initializeWasm() must be awaited first!");
16088 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(o);
16089 return nativeResponseValue;
16091 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
16093 export function CResult_QueryShortChannelIdsDecodeErrorZ_err(e: bigint): bigint {
16094 if(!isWasmInitialized) {
16095 throw new Error("initializeWasm() must be awaited first!");
16097 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(e);
16098 return nativeResponseValue;
16100 // bool CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR o);
16102 export function CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o: bigint): boolean {
16103 if(!isWasmInitialized) {
16104 throw new Error("initializeWasm() must be awaited first!");
16106 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o);
16107 return nativeResponseValue;
16109 // void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
16111 export function CResult_QueryShortChannelIdsDecodeErrorZ_free(_res: bigint): void {
16112 if(!isWasmInitialized) {
16113 throw new Error("initializeWasm() must be awaited first!");
16115 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(_res);
16116 // debug statements here
16118 // uint64_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg);
16120 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16121 if(!isWasmInitialized) {
16122 throw new Error("initializeWasm() must be awaited first!");
16124 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg);
16125 return nativeResponseValue;
16127 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
16129 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig: bigint): bigint {
16130 if(!isWasmInitialized) {
16131 throw new Error("initializeWasm() must be awaited first!");
16133 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig);
16134 return nativeResponseValue;
16136 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
16138 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o: bigint): bigint {
16139 if(!isWasmInitialized) {
16140 throw new Error("initializeWasm() must be awaited first!");
16142 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o);
16143 return nativeResponseValue;
16145 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
16147 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e: bigint): bigint {
16148 if(!isWasmInitialized) {
16149 throw new Error("initializeWasm() must be awaited first!");
16151 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e);
16152 return nativeResponseValue;
16154 // bool CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR o);
16156 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o: bigint): boolean {
16157 if(!isWasmInitialized) {
16158 throw new Error("initializeWasm() must be awaited first!");
16160 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o);
16161 return nativeResponseValue;
16163 // void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
16165 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res: bigint): void {
16166 if(!isWasmInitialized) {
16167 throw new Error("initializeWasm() must be awaited first!");
16169 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res);
16170 // debug statements here
16172 // uint64_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg);
16174 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16175 if(!isWasmInitialized) {
16176 throw new Error("initializeWasm() must be awaited first!");
16178 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg);
16179 return nativeResponseValue;
16181 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
16183 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig: bigint): bigint {
16184 if(!isWasmInitialized) {
16185 throw new Error("initializeWasm() must be awaited first!");
16187 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig);
16188 return nativeResponseValue;
16190 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
16192 export function CResult_QueryChannelRangeDecodeErrorZ_ok(o: bigint): bigint {
16193 if(!isWasmInitialized) {
16194 throw new Error("initializeWasm() must be awaited first!");
16196 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_ok(o);
16197 return nativeResponseValue;
16199 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
16201 export function CResult_QueryChannelRangeDecodeErrorZ_err(e: bigint): bigint {
16202 if(!isWasmInitialized) {
16203 throw new Error("initializeWasm() must be awaited first!");
16205 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_err(e);
16206 return nativeResponseValue;
16208 // bool CResult_QueryChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR o);
16210 export function CResult_QueryChannelRangeDecodeErrorZ_is_ok(o: bigint): boolean {
16211 if(!isWasmInitialized) {
16212 throw new Error("initializeWasm() must be awaited first!");
16214 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(o);
16215 return nativeResponseValue;
16217 // void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
16219 export function CResult_QueryChannelRangeDecodeErrorZ_free(_res: bigint): void {
16220 if(!isWasmInitialized) {
16221 throw new Error("initializeWasm() must be awaited first!");
16223 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_free(_res);
16224 // debug statements here
16226 // uint64_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg);
16228 export function CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16229 if(!isWasmInitialized) {
16230 throw new Error("initializeWasm() must be awaited first!");
16232 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg);
16233 return nativeResponseValue;
16235 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
16237 export function CResult_QueryChannelRangeDecodeErrorZ_clone(orig: bigint): bigint {
16238 if(!isWasmInitialized) {
16239 throw new Error("initializeWasm() must be awaited first!");
16241 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone(orig);
16242 return nativeResponseValue;
16244 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
16246 export function CResult_ReplyChannelRangeDecodeErrorZ_ok(o: bigint): bigint {
16247 if(!isWasmInitialized) {
16248 throw new Error("initializeWasm() must be awaited first!");
16250 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(o);
16251 return nativeResponseValue;
16253 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
16255 export function CResult_ReplyChannelRangeDecodeErrorZ_err(e: bigint): bigint {
16256 if(!isWasmInitialized) {
16257 throw new Error("initializeWasm() must be awaited first!");
16259 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_err(e);
16260 return nativeResponseValue;
16262 // bool CResult_ReplyChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR o);
16264 export function CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o: bigint): boolean {
16265 if(!isWasmInitialized) {
16266 throw new Error("initializeWasm() must be awaited first!");
16268 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o);
16269 return nativeResponseValue;
16271 // void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
16273 export function CResult_ReplyChannelRangeDecodeErrorZ_free(_res: bigint): void {
16274 if(!isWasmInitialized) {
16275 throw new Error("initializeWasm() must be awaited first!");
16277 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_free(_res);
16278 // debug statements here
16280 // uint64_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg);
16282 export function CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16283 if(!isWasmInitialized) {
16284 throw new Error("initializeWasm() must be awaited first!");
16286 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg);
16287 return nativeResponseValue;
16289 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
16291 export function CResult_ReplyChannelRangeDecodeErrorZ_clone(orig: bigint): bigint {
16292 if(!isWasmInitialized) {
16293 throw new Error("initializeWasm() must be awaited first!");
16295 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(orig);
16296 return nativeResponseValue;
16298 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
16300 export function CResult_GossipTimestampFilterDecodeErrorZ_ok(o: bigint): bigint {
16301 if(!isWasmInitialized) {
16302 throw new Error("initializeWasm() must be awaited first!");
16304 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(o);
16305 return nativeResponseValue;
16307 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
16309 export function CResult_GossipTimestampFilterDecodeErrorZ_err(e: bigint): bigint {
16310 if(!isWasmInitialized) {
16311 throw new Error("initializeWasm() must be awaited first!");
16313 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_err(e);
16314 return nativeResponseValue;
16316 // bool CResult_GossipTimestampFilterDecodeErrorZ_is_ok(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR o);
16318 export function CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o: bigint): boolean {
16319 if(!isWasmInitialized) {
16320 throw new Error("initializeWasm() must be awaited first!");
16322 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o);
16323 return nativeResponseValue;
16325 // void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
16327 export function CResult_GossipTimestampFilterDecodeErrorZ_free(_res: bigint): void {
16328 if(!isWasmInitialized) {
16329 throw new Error("initializeWasm() must be awaited first!");
16331 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_free(_res);
16332 // debug statements here
16334 // uint64_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg);
16336 export function CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16337 if(!isWasmInitialized) {
16338 throw new Error("initializeWasm() must be awaited first!");
16340 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg);
16341 return nativeResponseValue;
16343 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
16345 export function CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: bigint): bigint {
16346 if(!isWasmInitialized) {
16347 throw new Error("initializeWasm() must be awaited first!");
16349 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(orig);
16350 return nativeResponseValue;
16352 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_ok(struct LDKInvoice o);
16354 export function CResult_InvoiceSignOrCreationErrorZ_ok(o: bigint): bigint {
16355 if(!isWasmInitialized) {
16356 throw new Error("initializeWasm() must be awaited first!");
16358 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_ok(o);
16359 return nativeResponseValue;
16361 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_err(struct LDKSignOrCreationError e);
16363 export function CResult_InvoiceSignOrCreationErrorZ_err(e: bigint): bigint {
16364 if(!isWasmInitialized) {
16365 throw new Error("initializeWasm() must be awaited first!");
16367 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_err(e);
16368 return nativeResponseValue;
16370 // bool CResult_InvoiceSignOrCreationErrorZ_is_ok(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR o);
16372 export function CResult_InvoiceSignOrCreationErrorZ_is_ok(o: bigint): boolean {
16373 if(!isWasmInitialized) {
16374 throw new Error("initializeWasm() must be awaited first!");
16376 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_is_ok(o);
16377 return nativeResponseValue;
16379 // void CResult_InvoiceSignOrCreationErrorZ_free(struct LDKCResult_InvoiceSignOrCreationErrorZ _res);
16381 export function CResult_InvoiceSignOrCreationErrorZ_free(_res: bigint): void {
16382 if(!isWasmInitialized) {
16383 throw new Error("initializeWasm() must be awaited first!");
16385 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_free(_res);
16386 // debug statements here
16388 // uint64_t CResult_InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR arg);
16390 export function CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg: bigint): bigint {
16391 if(!isWasmInitialized) {
16392 throw new Error("initializeWasm() must be awaited first!");
16394 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg);
16395 return nativeResponseValue;
16397 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_clone(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR orig);
16399 export function CResult_InvoiceSignOrCreationErrorZ_clone(orig: bigint): bigint {
16400 if(!isWasmInitialized) {
16401 throw new Error("initializeWasm() must be awaited first!");
16403 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone(orig);
16404 return nativeResponseValue;
16406 // struct LDKCOption_FilterZ COption_FilterZ_some(struct LDKFilter o);
16408 export function COption_FilterZ_some(o: bigint): bigint {
16409 if(!isWasmInitialized) {
16410 throw new Error("initializeWasm() must be awaited first!");
16412 const nativeResponseValue = wasm.TS_COption_FilterZ_some(o);
16413 return nativeResponseValue;
16415 // struct LDKCOption_FilterZ COption_FilterZ_none(void);
16417 export function COption_FilterZ_none(): bigint {
16418 if(!isWasmInitialized) {
16419 throw new Error("initializeWasm() must be awaited first!");
16421 const nativeResponseValue = wasm.TS_COption_FilterZ_none();
16422 return nativeResponseValue;
16424 // void COption_FilterZ_free(struct LDKCOption_FilterZ _res);
16426 export function COption_FilterZ_free(_res: bigint): void {
16427 if(!isWasmInitialized) {
16428 throw new Error("initializeWasm() must be awaited first!");
16430 const nativeResponseValue = wasm.TS_COption_FilterZ_free(_res);
16431 // debug statements here
16433 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_ok(struct LDKLockedChannelMonitor o);
16435 export function CResult_LockedChannelMonitorNoneZ_ok(o: bigint): bigint {
16436 if(!isWasmInitialized) {
16437 throw new Error("initializeWasm() must be awaited first!");
16439 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_ok(o);
16440 return nativeResponseValue;
16442 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_err(void);
16444 export function CResult_LockedChannelMonitorNoneZ_err(): bigint {
16445 if(!isWasmInitialized) {
16446 throw new Error("initializeWasm() must be awaited first!");
16448 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_err();
16449 return nativeResponseValue;
16451 // bool CResult_LockedChannelMonitorNoneZ_is_ok(const struct LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR o);
16453 export function CResult_LockedChannelMonitorNoneZ_is_ok(o: bigint): boolean {
16454 if(!isWasmInitialized) {
16455 throw new Error("initializeWasm() must be awaited first!");
16457 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_is_ok(o);
16458 return nativeResponseValue;
16460 // void CResult_LockedChannelMonitorNoneZ_free(struct LDKCResult_LockedChannelMonitorNoneZ _res);
16462 export function CResult_LockedChannelMonitorNoneZ_free(_res: bigint): void {
16463 if(!isWasmInitialized) {
16464 throw new Error("initializeWasm() must be awaited first!");
16466 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_free(_res);
16467 // debug statements here
16469 // void CVec_OutPointZ_free(struct LDKCVec_OutPointZ _res);
16471 export function CVec_OutPointZ_free(_res: number): void {
16472 if(!isWasmInitialized) {
16473 throw new Error("initializeWasm() must be awaited first!");
16475 const nativeResponseValue = wasm.TS_CVec_OutPointZ_free(_res);
16476 // debug statements here
16478 // void PaymentPurpose_free(struct LDKPaymentPurpose this_ptr);
16480 export function PaymentPurpose_free(this_ptr: bigint): void {
16481 if(!isWasmInitialized) {
16482 throw new Error("initializeWasm() must be awaited first!");
16484 const nativeResponseValue = wasm.TS_PaymentPurpose_free(this_ptr);
16485 // debug statements here
16487 // uint64_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg);
16489 export function PaymentPurpose_clone_ptr(arg: bigint): bigint {
16490 if(!isWasmInitialized) {
16491 throw new Error("initializeWasm() must be awaited first!");
16493 const nativeResponseValue = wasm.TS_PaymentPurpose_clone_ptr(arg);
16494 return nativeResponseValue;
16496 // struct LDKPaymentPurpose PaymentPurpose_clone(const struct LDKPaymentPurpose *NONNULL_PTR orig);
16498 export function PaymentPurpose_clone(orig: bigint): bigint {
16499 if(!isWasmInitialized) {
16500 throw new Error("initializeWasm() must be awaited first!");
16502 const nativeResponseValue = wasm.TS_PaymentPurpose_clone(orig);
16503 return nativeResponseValue;
16505 // struct LDKPaymentPurpose PaymentPurpose_invoice_payment(struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_secret);
16507 export function PaymentPurpose_invoice_payment(payment_preimage: number, payment_secret: number): bigint {
16508 if(!isWasmInitialized) {
16509 throw new Error("initializeWasm() must be awaited first!");
16511 const nativeResponseValue = wasm.TS_PaymentPurpose_invoice_payment(payment_preimage, payment_secret);
16512 return nativeResponseValue;
16514 // struct LDKPaymentPurpose PaymentPurpose_spontaneous_payment(struct LDKThirtyTwoBytes a);
16516 export function PaymentPurpose_spontaneous_payment(a: number): bigint {
16517 if(!isWasmInitialized) {
16518 throw new Error("initializeWasm() must be awaited first!");
16520 const nativeResponseValue = wasm.TS_PaymentPurpose_spontaneous_payment(a);
16521 return nativeResponseValue;
16523 // struct LDKCVec_u8Z PaymentPurpose_write(const struct LDKPaymentPurpose *NONNULL_PTR obj);
16525 export function PaymentPurpose_write(obj: bigint): number {
16526 if(!isWasmInitialized) {
16527 throw new Error("initializeWasm() must be awaited first!");
16529 const nativeResponseValue = wasm.TS_PaymentPurpose_write(obj);
16530 return nativeResponseValue;
16532 // struct LDKCResult_PaymentPurposeDecodeErrorZ PaymentPurpose_read(struct LDKu8slice ser);
16534 export function PaymentPurpose_read(ser: number): bigint {
16535 if(!isWasmInitialized) {
16536 throw new Error("initializeWasm() must be awaited first!");
16538 const nativeResponseValue = wasm.TS_PaymentPurpose_read(ser);
16539 return nativeResponseValue;
16541 // void ClosureReason_free(struct LDKClosureReason this_ptr);
16543 export function ClosureReason_free(this_ptr: bigint): void {
16544 if(!isWasmInitialized) {
16545 throw new Error("initializeWasm() must be awaited first!");
16547 const nativeResponseValue = wasm.TS_ClosureReason_free(this_ptr);
16548 // debug statements here
16550 // uint64_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg);
16552 export function ClosureReason_clone_ptr(arg: bigint): bigint {
16553 if(!isWasmInitialized) {
16554 throw new Error("initializeWasm() must be awaited first!");
16556 const nativeResponseValue = wasm.TS_ClosureReason_clone_ptr(arg);
16557 return nativeResponseValue;
16559 // struct LDKClosureReason ClosureReason_clone(const struct LDKClosureReason *NONNULL_PTR orig);
16561 export function ClosureReason_clone(orig: bigint): bigint {
16562 if(!isWasmInitialized) {
16563 throw new Error("initializeWasm() must be awaited first!");
16565 const nativeResponseValue = wasm.TS_ClosureReason_clone(orig);
16566 return nativeResponseValue;
16568 // struct LDKClosureReason ClosureReason_counterparty_force_closed(struct LDKStr peer_msg);
16570 export function ClosureReason_counterparty_force_closed(peer_msg: number): bigint {
16571 if(!isWasmInitialized) {
16572 throw new Error("initializeWasm() must be awaited first!");
16574 const nativeResponseValue = wasm.TS_ClosureReason_counterparty_force_closed(peer_msg);
16575 return nativeResponseValue;
16577 // struct LDKClosureReason ClosureReason_holder_force_closed(void);
16579 export function ClosureReason_holder_force_closed(): bigint {
16580 if(!isWasmInitialized) {
16581 throw new Error("initializeWasm() must be awaited first!");
16583 const nativeResponseValue = wasm.TS_ClosureReason_holder_force_closed();
16584 return nativeResponseValue;
16586 // struct LDKClosureReason ClosureReason_cooperative_closure(void);
16588 export function ClosureReason_cooperative_closure(): bigint {
16589 if(!isWasmInitialized) {
16590 throw new Error("initializeWasm() must be awaited first!");
16592 const nativeResponseValue = wasm.TS_ClosureReason_cooperative_closure();
16593 return nativeResponseValue;
16595 // struct LDKClosureReason ClosureReason_commitment_tx_confirmed(void);
16597 export function ClosureReason_commitment_tx_confirmed(): bigint {
16598 if(!isWasmInitialized) {
16599 throw new Error("initializeWasm() must be awaited first!");
16601 const nativeResponseValue = wasm.TS_ClosureReason_commitment_tx_confirmed();
16602 return nativeResponseValue;
16604 // struct LDKClosureReason ClosureReason_funding_timed_out(void);
16606 export function ClosureReason_funding_timed_out(): bigint {
16607 if(!isWasmInitialized) {
16608 throw new Error("initializeWasm() must be awaited first!");
16610 const nativeResponseValue = wasm.TS_ClosureReason_funding_timed_out();
16611 return nativeResponseValue;
16613 // struct LDKClosureReason ClosureReason_processing_error(struct LDKStr err);
16615 export function ClosureReason_processing_error(err: number): bigint {
16616 if(!isWasmInitialized) {
16617 throw new Error("initializeWasm() must be awaited first!");
16619 const nativeResponseValue = wasm.TS_ClosureReason_processing_error(err);
16620 return nativeResponseValue;
16622 // struct LDKClosureReason ClosureReason_disconnected_peer(void);
16624 export function ClosureReason_disconnected_peer(): bigint {
16625 if(!isWasmInitialized) {
16626 throw new Error("initializeWasm() must be awaited first!");
16628 const nativeResponseValue = wasm.TS_ClosureReason_disconnected_peer();
16629 return nativeResponseValue;
16631 // struct LDKClosureReason ClosureReason_outdated_channel_manager(void);
16633 export function ClosureReason_outdated_channel_manager(): bigint {
16634 if(!isWasmInitialized) {
16635 throw new Error("initializeWasm() must be awaited first!");
16637 const nativeResponseValue = wasm.TS_ClosureReason_outdated_channel_manager();
16638 return nativeResponseValue;
16640 // struct LDKCVec_u8Z ClosureReason_write(const struct LDKClosureReason *NONNULL_PTR obj);
16642 export function ClosureReason_write(obj: bigint): number {
16643 if(!isWasmInitialized) {
16644 throw new Error("initializeWasm() must be awaited first!");
16646 const nativeResponseValue = wasm.TS_ClosureReason_write(obj);
16647 return nativeResponseValue;
16649 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ ClosureReason_read(struct LDKu8slice ser);
16651 export function ClosureReason_read(ser: number): bigint {
16652 if(!isWasmInitialized) {
16653 throw new Error("initializeWasm() must be awaited first!");
16655 const nativeResponseValue = wasm.TS_ClosureReason_read(ser);
16656 return nativeResponseValue;
16658 // void HTLCDestination_free(struct LDKHTLCDestination this_ptr);
16660 export function HTLCDestination_free(this_ptr: bigint): void {
16661 if(!isWasmInitialized) {
16662 throw new Error("initializeWasm() must be awaited first!");
16664 const nativeResponseValue = wasm.TS_HTLCDestination_free(this_ptr);
16665 // debug statements here
16667 // uint64_t HTLCDestination_clone_ptr(LDKHTLCDestination *NONNULL_PTR arg);
16669 export function HTLCDestination_clone_ptr(arg: bigint): bigint {
16670 if(!isWasmInitialized) {
16671 throw new Error("initializeWasm() must be awaited first!");
16673 const nativeResponseValue = wasm.TS_HTLCDestination_clone_ptr(arg);
16674 return nativeResponseValue;
16676 // struct LDKHTLCDestination HTLCDestination_clone(const struct LDKHTLCDestination *NONNULL_PTR orig);
16678 export function HTLCDestination_clone(orig: bigint): bigint {
16679 if(!isWasmInitialized) {
16680 throw new Error("initializeWasm() must be awaited first!");
16682 const nativeResponseValue = wasm.TS_HTLCDestination_clone(orig);
16683 return nativeResponseValue;
16685 // struct LDKHTLCDestination HTLCDestination_next_hop_channel(struct LDKPublicKey node_id, struct LDKThirtyTwoBytes channel_id);
16687 export function HTLCDestination_next_hop_channel(node_id: number, channel_id: number): bigint {
16688 if(!isWasmInitialized) {
16689 throw new Error("initializeWasm() must be awaited first!");
16691 const nativeResponseValue = wasm.TS_HTLCDestination_next_hop_channel(node_id, channel_id);
16692 return nativeResponseValue;
16694 // struct LDKHTLCDestination HTLCDestination_unknown_next_hop(uint64_t requested_forward_scid);
16696 export function HTLCDestination_unknown_next_hop(requested_forward_scid: bigint): bigint {
16697 if(!isWasmInitialized) {
16698 throw new Error("initializeWasm() must be awaited first!");
16700 const nativeResponseValue = wasm.TS_HTLCDestination_unknown_next_hop(requested_forward_scid);
16701 return nativeResponseValue;
16703 // struct LDKHTLCDestination HTLCDestination_failed_payment(struct LDKThirtyTwoBytes payment_hash);
16705 export function HTLCDestination_failed_payment(payment_hash: number): bigint {
16706 if(!isWasmInitialized) {
16707 throw new Error("initializeWasm() must be awaited first!");
16709 const nativeResponseValue = wasm.TS_HTLCDestination_failed_payment(payment_hash);
16710 return nativeResponseValue;
16712 // struct LDKCVec_u8Z HTLCDestination_write(const struct LDKHTLCDestination *NONNULL_PTR obj);
16714 export function HTLCDestination_write(obj: bigint): number {
16715 if(!isWasmInitialized) {
16716 throw new Error("initializeWasm() must be awaited first!");
16718 const nativeResponseValue = wasm.TS_HTLCDestination_write(obj);
16719 return nativeResponseValue;
16721 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ HTLCDestination_read(struct LDKu8slice ser);
16723 export function HTLCDestination_read(ser: number): bigint {
16724 if(!isWasmInitialized) {
16725 throw new Error("initializeWasm() must be awaited first!");
16727 const nativeResponseValue = wasm.TS_HTLCDestination_read(ser);
16728 return nativeResponseValue;
16730 // void Event_free(struct LDKEvent this_ptr);
16732 export function Event_free(this_ptr: bigint): void {
16733 if(!isWasmInitialized) {
16734 throw new Error("initializeWasm() must be awaited first!");
16736 const nativeResponseValue = wasm.TS_Event_free(this_ptr);
16737 // debug statements here
16739 // uint64_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg);
16741 export function Event_clone_ptr(arg: bigint): bigint {
16742 if(!isWasmInitialized) {
16743 throw new Error("initializeWasm() must be awaited first!");
16745 const nativeResponseValue = wasm.TS_Event_clone_ptr(arg);
16746 return nativeResponseValue;
16748 // struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
16750 export function Event_clone(orig: bigint): bigint {
16751 if(!isWasmInitialized) {
16752 throw new Error("initializeWasm() must be awaited first!");
16754 const nativeResponseValue = wasm.TS_Event_clone(orig);
16755 return nativeResponseValue;
16757 // struct LDKEvent Event_funding_generation_ready(struct LDKThirtyTwoBytes temporary_channel_id, struct LDKPublicKey counterparty_node_id, uint64_t channel_value_satoshis, struct LDKCVec_u8Z output_script, uint64_t user_channel_id);
16759 export function Event_funding_generation_ready(temporary_channel_id: number, counterparty_node_id: number, channel_value_satoshis: bigint, output_script: number, user_channel_id: bigint): bigint {
16760 if(!isWasmInitialized) {
16761 throw new Error("initializeWasm() must be awaited first!");
16763 const nativeResponseValue = wasm.TS_Event_funding_generation_ready(temporary_channel_id, counterparty_node_id, channel_value_satoshis, output_script, user_channel_id);
16764 return nativeResponseValue;
16766 // struct LDKEvent Event_payment_received(struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose);
16768 export function Event_payment_received(payment_hash: number, amount_msat: bigint, purpose: bigint): bigint {
16769 if(!isWasmInitialized) {
16770 throw new Error("initializeWasm() must be awaited first!");
16772 const nativeResponseValue = wasm.TS_Event_payment_received(payment_hash, amount_msat, purpose);
16773 return nativeResponseValue;
16775 // struct LDKEvent Event_payment_claimed(struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose);
16777 export function Event_payment_claimed(payment_hash: number, amount_msat: bigint, purpose: bigint): bigint {
16778 if(!isWasmInitialized) {
16779 throw new Error("initializeWasm() must be awaited first!");
16781 const nativeResponseValue = wasm.TS_Event_payment_claimed(payment_hash, amount_msat, purpose);
16782 return nativeResponseValue;
16784 // struct LDKEvent Event_payment_sent(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z fee_paid_msat);
16786 export function Event_payment_sent(payment_id: number, payment_preimage: number, payment_hash: number, fee_paid_msat: bigint): bigint {
16787 if(!isWasmInitialized) {
16788 throw new Error("initializeWasm() must be awaited first!");
16790 const nativeResponseValue = wasm.TS_Event_payment_sent(payment_id, payment_preimage, payment_hash, fee_paid_msat);
16791 return nativeResponseValue;
16793 // struct LDKEvent Event_payment_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash);
16795 export function Event_payment_failed(payment_id: number, payment_hash: number): bigint {
16796 if(!isWasmInitialized) {
16797 throw new Error("initializeWasm() must be awaited first!");
16799 const nativeResponseValue = wasm.TS_Event_payment_failed(payment_id, payment_hash);
16800 return nativeResponseValue;
16802 // struct LDKEvent Event_payment_path_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path);
16804 export function Event_payment_path_successful(payment_id: number, payment_hash: number, path: number): bigint {
16805 if(!isWasmInitialized) {
16806 throw new Error("initializeWasm() must be awaited first!");
16808 const nativeResponseValue = wasm.TS_Event_payment_path_successful(payment_id, payment_hash, path);
16809 return nativeResponseValue;
16811 // struct LDKEvent Event_payment_path_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, bool payment_failed_permanently, struct LDKCOption_NetworkUpdateZ network_update, bool all_paths_failed, struct LDKCVec_RouteHopZ path, struct LDKCOption_u64Z short_channel_id, struct LDKRouteParameters retry);
16813 export function Event_payment_path_failed(payment_id: number, payment_hash: number, payment_failed_permanently: boolean, network_update: bigint, all_paths_failed: boolean, path: number, short_channel_id: bigint, retry: bigint): bigint {
16814 if(!isWasmInitialized) {
16815 throw new Error("initializeWasm() must be awaited first!");
16817 const nativeResponseValue = wasm.TS_Event_payment_path_failed(payment_id, payment_hash, payment_failed_permanently, network_update, all_paths_failed, path, short_channel_id, retry);
16818 return nativeResponseValue;
16820 // struct LDKEvent Event_probe_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path);
16822 export function Event_probe_successful(payment_id: number, payment_hash: number, path: number): bigint {
16823 if(!isWasmInitialized) {
16824 throw new Error("initializeWasm() must be awaited first!");
16826 const nativeResponseValue = wasm.TS_Event_probe_successful(payment_id, payment_hash, path);
16827 return nativeResponseValue;
16829 // struct LDKEvent Event_probe_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path, struct LDKCOption_u64Z short_channel_id);
16831 export function Event_probe_failed(payment_id: number, payment_hash: number, path: number, short_channel_id: bigint): bigint {
16832 if(!isWasmInitialized) {
16833 throw new Error("initializeWasm() must be awaited first!");
16835 const nativeResponseValue = wasm.TS_Event_probe_failed(payment_id, payment_hash, path, short_channel_id);
16836 return nativeResponseValue;
16838 // struct LDKEvent Event_pending_htlcs_forwardable(uint64_t time_forwardable);
16840 export function Event_pending_htlcs_forwardable(time_forwardable: bigint): bigint {
16841 if(!isWasmInitialized) {
16842 throw new Error("initializeWasm() must be awaited first!");
16844 const nativeResponseValue = wasm.TS_Event_pending_htlcs_forwardable(time_forwardable);
16845 return nativeResponseValue;
16847 // struct LDKEvent Event_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ outputs);
16849 export function Event_spendable_outputs(outputs: number): bigint {
16850 if(!isWasmInitialized) {
16851 throw new Error("initializeWasm() must be awaited first!");
16853 const nativeResponseValue = wasm.TS_Event_spendable_outputs(outputs);
16854 return nativeResponseValue;
16856 // struct LDKEvent Event_payment_forwarded(struct LDKThirtyTwoBytes prev_channel_id, struct LDKThirtyTwoBytes next_channel_id, struct LDKCOption_u64Z fee_earned_msat, bool claim_from_onchain_tx);
16858 export function Event_payment_forwarded(prev_channel_id: number, next_channel_id: number, fee_earned_msat: bigint, claim_from_onchain_tx: boolean): bigint {
16859 if(!isWasmInitialized) {
16860 throw new Error("initializeWasm() must be awaited first!");
16862 const nativeResponseValue = wasm.TS_Event_payment_forwarded(prev_channel_id, next_channel_id, fee_earned_msat, claim_from_onchain_tx);
16863 return nativeResponseValue;
16865 // struct LDKEvent Event_channel_closed(struct LDKThirtyTwoBytes channel_id, uint64_t user_channel_id, struct LDKClosureReason reason);
16867 export function Event_channel_closed(channel_id: number, user_channel_id: bigint, reason: bigint): bigint {
16868 if(!isWasmInitialized) {
16869 throw new Error("initializeWasm() must be awaited first!");
16871 const nativeResponseValue = wasm.TS_Event_channel_closed(channel_id, user_channel_id, reason);
16872 return nativeResponseValue;
16874 // struct LDKEvent Event_discard_funding(struct LDKThirtyTwoBytes channel_id, struct LDKTransaction transaction);
16876 export function Event_discard_funding(channel_id: number, transaction: number): bigint {
16877 if(!isWasmInitialized) {
16878 throw new Error("initializeWasm() must be awaited first!");
16880 const nativeResponseValue = wasm.TS_Event_discard_funding(channel_id, transaction);
16881 return nativeResponseValue;
16883 // struct LDKEvent Event_open_channel_request(struct LDKThirtyTwoBytes temporary_channel_id, struct LDKPublicKey counterparty_node_id, uint64_t funding_satoshis, uint64_t push_msat, struct LDKChannelTypeFeatures channel_type);
16885 export function Event_open_channel_request(temporary_channel_id: number, counterparty_node_id: number, funding_satoshis: bigint, push_msat: bigint, channel_type: bigint): bigint {
16886 if(!isWasmInitialized) {
16887 throw new Error("initializeWasm() must be awaited first!");
16889 const nativeResponseValue = wasm.TS_Event_open_channel_request(temporary_channel_id, counterparty_node_id, funding_satoshis, push_msat, channel_type);
16890 return nativeResponseValue;
16892 // struct LDKEvent Event_htlchandling_failed(struct LDKThirtyTwoBytes prev_channel_id, struct LDKHTLCDestination failed_next_destination);
16894 export function Event_htlchandling_failed(prev_channel_id: number, failed_next_destination: bigint): bigint {
16895 if(!isWasmInitialized) {
16896 throw new Error("initializeWasm() must be awaited first!");
16898 const nativeResponseValue = wasm.TS_Event_htlchandling_failed(prev_channel_id, failed_next_destination);
16899 return nativeResponseValue;
16901 // struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
16903 export function Event_write(obj: bigint): number {
16904 if(!isWasmInitialized) {
16905 throw new Error("initializeWasm() must be awaited first!");
16907 const nativeResponseValue = wasm.TS_Event_write(obj);
16908 return nativeResponseValue;
16910 // struct LDKCResult_COption_EventZDecodeErrorZ Event_read(struct LDKu8slice ser);
16912 export function Event_read(ser: number): bigint {
16913 if(!isWasmInitialized) {
16914 throw new Error("initializeWasm() must be awaited first!");
16916 const nativeResponseValue = wasm.TS_Event_read(ser);
16917 return nativeResponseValue;
16919 // void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
16921 export function MessageSendEvent_free(this_ptr: bigint): void {
16922 if(!isWasmInitialized) {
16923 throw new Error("initializeWasm() must be awaited first!");
16925 const nativeResponseValue = wasm.TS_MessageSendEvent_free(this_ptr);
16926 // debug statements here
16928 // uint64_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg);
16930 export function MessageSendEvent_clone_ptr(arg: bigint): bigint {
16931 if(!isWasmInitialized) {
16932 throw new Error("initializeWasm() must be awaited first!");
16934 const nativeResponseValue = wasm.TS_MessageSendEvent_clone_ptr(arg);
16935 return nativeResponseValue;
16937 // struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
16939 export function MessageSendEvent_clone(orig: bigint): bigint {
16940 if(!isWasmInitialized) {
16941 throw new Error("initializeWasm() must be awaited first!");
16943 const nativeResponseValue = wasm.TS_MessageSendEvent_clone(orig);
16944 return nativeResponseValue;
16946 // struct LDKMessageSendEvent MessageSendEvent_send_accept_channel(struct LDKPublicKey node_id, struct LDKAcceptChannel msg);
16948 export function MessageSendEvent_send_accept_channel(node_id: number, msg: bigint): bigint {
16949 if(!isWasmInitialized) {
16950 throw new Error("initializeWasm() must be awaited first!");
16952 const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel(node_id, msg);
16953 return nativeResponseValue;
16955 // struct LDKMessageSendEvent MessageSendEvent_send_open_channel(struct LDKPublicKey node_id, struct LDKOpenChannel msg);
16957 export function MessageSendEvent_send_open_channel(node_id: number, msg: bigint): bigint {
16958 if(!isWasmInitialized) {
16959 throw new Error("initializeWasm() must be awaited first!");
16961 const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel(node_id, msg);
16962 return nativeResponseValue;
16964 // struct LDKMessageSendEvent MessageSendEvent_send_funding_created(struct LDKPublicKey node_id, struct LDKFundingCreated msg);
16966 export function MessageSendEvent_send_funding_created(node_id: number, msg: bigint): bigint {
16967 if(!isWasmInitialized) {
16968 throw new Error("initializeWasm() must be awaited first!");
16970 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_created(node_id, msg);
16971 return nativeResponseValue;
16973 // struct LDKMessageSendEvent MessageSendEvent_send_funding_signed(struct LDKPublicKey node_id, struct LDKFundingSigned msg);
16975 export function MessageSendEvent_send_funding_signed(node_id: number, msg: bigint): bigint {
16976 if(!isWasmInitialized) {
16977 throw new Error("initializeWasm() must be awaited first!");
16979 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_signed(node_id, msg);
16980 return nativeResponseValue;
16982 // struct LDKMessageSendEvent MessageSendEvent_send_channel_ready(struct LDKPublicKey node_id, struct LDKChannelReady msg);
16984 export function MessageSendEvent_send_channel_ready(node_id: number, msg: bigint): bigint {
16985 if(!isWasmInitialized) {
16986 throw new Error("initializeWasm() must be awaited first!");
16988 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_ready(node_id, msg);
16989 return nativeResponseValue;
16991 // struct LDKMessageSendEvent MessageSendEvent_send_announcement_signatures(struct LDKPublicKey node_id, struct LDKAnnouncementSignatures msg);
16993 export function MessageSendEvent_send_announcement_signatures(node_id: number, msg: bigint): bigint {
16994 if(!isWasmInitialized) {
16995 throw new Error("initializeWasm() must be awaited first!");
16997 const nativeResponseValue = wasm.TS_MessageSendEvent_send_announcement_signatures(node_id, msg);
16998 return nativeResponseValue;
17000 // struct LDKMessageSendEvent MessageSendEvent_update_htlcs(struct LDKPublicKey node_id, struct LDKCommitmentUpdate updates);
17002 export function MessageSendEvent_update_htlcs(node_id: number, updates: bigint): bigint {
17003 if(!isWasmInitialized) {
17004 throw new Error("initializeWasm() must be awaited first!");
17006 const nativeResponseValue = wasm.TS_MessageSendEvent_update_htlcs(node_id, updates);
17007 return nativeResponseValue;
17009 // struct LDKMessageSendEvent MessageSendEvent_send_revoke_and_ack(struct LDKPublicKey node_id, struct LDKRevokeAndACK msg);
17011 export function MessageSendEvent_send_revoke_and_ack(node_id: number, msg: bigint): bigint {
17012 if(!isWasmInitialized) {
17013 throw new Error("initializeWasm() must be awaited first!");
17015 const nativeResponseValue = wasm.TS_MessageSendEvent_send_revoke_and_ack(node_id, msg);
17016 return nativeResponseValue;
17018 // struct LDKMessageSendEvent MessageSendEvent_send_closing_signed(struct LDKPublicKey node_id, struct LDKClosingSigned msg);
17020 export function MessageSendEvent_send_closing_signed(node_id: number, msg: bigint): bigint {
17021 if(!isWasmInitialized) {
17022 throw new Error("initializeWasm() must be awaited first!");
17024 const nativeResponseValue = wasm.TS_MessageSendEvent_send_closing_signed(node_id, msg);
17025 return nativeResponseValue;
17027 // struct LDKMessageSendEvent MessageSendEvent_send_shutdown(struct LDKPublicKey node_id, struct LDKShutdown msg);
17029 export function MessageSendEvent_send_shutdown(node_id: number, msg: bigint): bigint {
17030 if(!isWasmInitialized) {
17031 throw new Error("initializeWasm() must be awaited first!");
17033 const nativeResponseValue = wasm.TS_MessageSendEvent_send_shutdown(node_id, msg);
17034 return nativeResponseValue;
17036 // struct LDKMessageSendEvent MessageSendEvent_send_channel_reestablish(struct LDKPublicKey node_id, struct LDKChannelReestablish msg);
17038 export function MessageSendEvent_send_channel_reestablish(node_id: number, msg: bigint): bigint {
17039 if(!isWasmInitialized) {
17040 throw new Error("initializeWasm() must be awaited first!");
17042 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_reestablish(node_id, msg);
17043 return nativeResponseValue;
17045 // struct LDKMessageSendEvent MessageSendEvent_send_channel_announcement(struct LDKPublicKey node_id, struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
17047 export function MessageSendEvent_send_channel_announcement(node_id: number, msg: bigint, update_msg: bigint): bigint {
17048 if(!isWasmInitialized) {
17049 throw new Error("initializeWasm() must be awaited first!");
17051 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_announcement(node_id, msg, update_msg);
17052 return nativeResponseValue;
17054 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_announcement(struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
17056 export function MessageSendEvent_broadcast_channel_announcement(msg: bigint, update_msg: bigint): bigint {
17057 if(!isWasmInitialized) {
17058 throw new Error("initializeWasm() must be awaited first!");
17060 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_announcement(msg, update_msg);
17061 return nativeResponseValue;
17063 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_update(struct LDKChannelUpdate msg);
17065 export function MessageSendEvent_broadcast_channel_update(msg: bigint): bigint {
17066 if(!isWasmInitialized) {
17067 throw new Error("initializeWasm() must be awaited first!");
17069 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_update(msg);
17070 return nativeResponseValue;
17072 // struct LDKMessageSendEvent MessageSendEvent_send_channel_update(struct LDKPublicKey node_id, struct LDKChannelUpdate msg);
17074 export function MessageSendEvent_send_channel_update(node_id: number, msg: bigint): bigint {
17075 if(!isWasmInitialized) {
17076 throw new Error("initializeWasm() must be awaited first!");
17078 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_update(node_id, msg);
17079 return nativeResponseValue;
17081 // struct LDKMessageSendEvent MessageSendEvent_handle_error(struct LDKPublicKey node_id, struct LDKErrorAction action);
17083 export function MessageSendEvent_handle_error(node_id: number, action: bigint): bigint {
17084 if(!isWasmInitialized) {
17085 throw new Error("initializeWasm() must be awaited first!");
17087 const nativeResponseValue = wasm.TS_MessageSendEvent_handle_error(node_id, action);
17088 return nativeResponseValue;
17090 // struct LDKMessageSendEvent MessageSendEvent_send_channel_range_query(struct LDKPublicKey node_id, struct LDKQueryChannelRange msg);
17092 export function MessageSendEvent_send_channel_range_query(node_id: number, msg: bigint): bigint {
17093 if(!isWasmInitialized) {
17094 throw new Error("initializeWasm() must be awaited first!");
17096 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_range_query(node_id, msg);
17097 return nativeResponseValue;
17099 // struct LDKMessageSendEvent MessageSendEvent_send_short_ids_query(struct LDKPublicKey node_id, struct LDKQueryShortChannelIds msg);
17101 export function MessageSendEvent_send_short_ids_query(node_id: number, msg: bigint): bigint {
17102 if(!isWasmInitialized) {
17103 throw new Error("initializeWasm() must be awaited first!");
17105 const nativeResponseValue = wasm.TS_MessageSendEvent_send_short_ids_query(node_id, msg);
17106 return nativeResponseValue;
17108 // struct LDKMessageSendEvent MessageSendEvent_send_reply_channel_range(struct LDKPublicKey node_id, struct LDKReplyChannelRange msg);
17110 export function MessageSendEvent_send_reply_channel_range(node_id: number, msg: bigint): bigint {
17111 if(!isWasmInitialized) {
17112 throw new Error("initializeWasm() must be awaited first!");
17114 const nativeResponseValue = wasm.TS_MessageSendEvent_send_reply_channel_range(node_id, msg);
17115 return nativeResponseValue;
17117 // struct LDKMessageSendEvent MessageSendEvent_send_gossip_timestamp_filter(struct LDKPublicKey node_id, struct LDKGossipTimestampFilter msg);
17119 export function MessageSendEvent_send_gossip_timestamp_filter(node_id: number, msg: bigint): bigint {
17120 if(!isWasmInitialized) {
17121 throw new Error("initializeWasm() must be awaited first!");
17123 const nativeResponseValue = wasm.TS_MessageSendEvent_send_gossip_timestamp_filter(node_id, msg);
17124 return nativeResponseValue;
17126 // void MessageSendEventsProvider_free(struct LDKMessageSendEventsProvider this_ptr);
17128 export function MessageSendEventsProvider_free(this_ptr: bigint): void {
17129 if(!isWasmInitialized) {
17130 throw new Error("initializeWasm() must be awaited first!");
17132 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_free(this_ptr);
17133 // debug statements here
17135 // void OnionMessageProvider_free(struct LDKOnionMessageProvider this_ptr);
17137 export function OnionMessageProvider_free(this_ptr: bigint): void {
17138 if(!isWasmInitialized) {
17139 throw new Error("initializeWasm() must be awaited first!");
17141 const nativeResponseValue = wasm.TS_OnionMessageProvider_free(this_ptr);
17142 // debug statements here
17144 // void EventsProvider_free(struct LDKEventsProvider this_ptr);
17146 export function EventsProvider_free(this_ptr: bigint): void {
17147 if(!isWasmInitialized) {
17148 throw new Error("initializeWasm() must be awaited first!");
17150 const nativeResponseValue = wasm.TS_EventsProvider_free(this_ptr);
17151 // debug statements here
17153 // void EventHandler_free(struct LDKEventHandler this_ptr);
17155 export function EventHandler_free(this_ptr: bigint): void {
17156 if(!isWasmInitialized) {
17157 throw new Error("initializeWasm() must be awaited first!");
17159 const nativeResponseValue = wasm.TS_EventHandler_free(this_ptr);
17160 // debug statements here
17162 // void APIError_free(struct LDKAPIError this_ptr);
17164 export function APIError_free(this_ptr: bigint): void {
17165 if(!isWasmInitialized) {
17166 throw new Error("initializeWasm() must be awaited first!");
17168 const nativeResponseValue = wasm.TS_APIError_free(this_ptr);
17169 // debug statements here
17171 // uint64_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg);
17173 export function APIError_clone_ptr(arg: bigint): bigint {
17174 if(!isWasmInitialized) {
17175 throw new Error("initializeWasm() must be awaited first!");
17177 const nativeResponseValue = wasm.TS_APIError_clone_ptr(arg);
17178 return nativeResponseValue;
17180 // struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
17182 export function APIError_clone(orig: bigint): bigint {
17183 if(!isWasmInitialized) {
17184 throw new Error("initializeWasm() must be awaited first!");
17186 const nativeResponseValue = wasm.TS_APIError_clone(orig);
17187 return nativeResponseValue;
17189 // struct LDKAPIError APIError_apimisuse_error(struct LDKStr err);
17191 export function APIError_apimisuse_error(err: number): bigint {
17192 if(!isWasmInitialized) {
17193 throw new Error("initializeWasm() must be awaited first!");
17195 const nativeResponseValue = wasm.TS_APIError_apimisuse_error(err);
17196 return nativeResponseValue;
17198 // struct LDKAPIError APIError_fee_rate_too_high(struct LDKStr err, uint32_t feerate);
17200 export function APIError_fee_rate_too_high(err: number, feerate: number): bigint {
17201 if(!isWasmInitialized) {
17202 throw new Error("initializeWasm() must be awaited first!");
17204 const nativeResponseValue = wasm.TS_APIError_fee_rate_too_high(err, feerate);
17205 return nativeResponseValue;
17207 // struct LDKAPIError APIError_route_error(struct LDKStr err);
17209 export function APIError_route_error(err: number): bigint {
17210 if(!isWasmInitialized) {
17211 throw new Error("initializeWasm() must be awaited first!");
17213 const nativeResponseValue = wasm.TS_APIError_route_error(err);
17214 return nativeResponseValue;
17216 // struct LDKAPIError APIError_channel_unavailable(struct LDKStr err);
17218 export function APIError_channel_unavailable(err: number): bigint {
17219 if(!isWasmInitialized) {
17220 throw new Error("initializeWasm() must be awaited first!");
17222 const nativeResponseValue = wasm.TS_APIError_channel_unavailable(err);
17223 return nativeResponseValue;
17225 // struct LDKAPIError APIError_monitor_update_failed(void);
17227 export function APIError_monitor_update_failed(): bigint {
17228 if(!isWasmInitialized) {
17229 throw new Error("initializeWasm() must be awaited first!");
17231 const nativeResponseValue = wasm.TS_APIError_monitor_update_failed();
17232 return nativeResponseValue;
17234 // struct LDKAPIError APIError_incompatible_shutdown_script(struct LDKShutdownScript script);
17236 export function APIError_incompatible_shutdown_script(script: bigint): bigint {
17237 if(!isWasmInitialized) {
17238 throw new Error("initializeWasm() must be awaited first!");
17240 const nativeResponseValue = wasm.TS_APIError_incompatible_shutdown_script(script);
17241 return nativeResponseValue;
17243 // void BigSize_free(struct LDKBigSize this_obj);
17245 export function BigSize_free(this_obj: bigint): void {
17246 if(!isWasmInitialized) {
17247 throw new Error("initializeWasm() must be awaited first!");
17249 const nativeResponseValue = wasm.TS_BigSize_free(this_obj);
17250 // debug statements here
17252 // uint64_t BigSize_get_a(const struct LDKBigSize *NONNULL_PTR this_ptr);
17254 export function BigSize_get_a(this_ptr: bigint): bigint {
17255 if(!isWasmInitialized) {
17256 throw new Error("initializeWasm() must be awaited first!");
17258 const nativeResponseValue = wasm.TS_BigSize_get_a(this_ptr);
17259 return nativeResponseValue;
17261 // void BigSize_set_a(struct LDKBigSize *NONNULL_PTR this_ptr, uint64_t val);
17263 export function BigSize_set_a(this_ptr: bigint, val: bigint): void {
17264 if(!isWasmInitialized) {
17265 throw new Error("initializeWasm() must be awaited first!");
17267 const nativeResponseValue = wasm.TS_BigSize_set_a(this_ptr, val);
17268 // debug statements here
17270 // MUST_USE_RES struct LDKBigSize BigSize_new(uint64_t a_arg);
17272 export function BigSize_new(a_arg: bigint): bigint {
17273 if(!isWasmInitialized) {
17274 throw new Error("initializeWasm() must be awaited first!");
17276 const nativeResponseValue = wasm.TS_BigSize_new(a_arg);
17277 return nativeResponseValue;
17279 // void Hostname_free(struct LDKHostname this_obj);
17281 export function Hostname_free(this_obj: bigint): void {
17282 if(!isWasmInitialized) {
17283 throw new Error("initializeWasm() must be awaited first!");
17285 const nativeResponseValue = wasm.TS_Hostname_free(this_obj);
17286 // debug statements here
17288 // uint64_t Hostname_clone_ptr(LDKHostname *NONNULL_PTR arg);
17290 export function Hostname_clone_ptr(arg: bigint): bigint {
17291 if(!isWasmInitialized) {
17292 throw new Error("initializeWasm() must be awaited first!");
17294 const nativeResponseValue = wasm.TS_Hostname_clone_ptr(arg);
17295 return nativeResponseValue;
17297 // struct LDKHostname Hostname_clone(const struct LDKHostname *NONNULL_PTR orig);
17299 export function Hostname_clone(orig: bigint): bigint {
17300 if(!isWasmInitialized) {
17301 throw new Error("initializeWasm() must be awaited first!");
17303 const nativeResponseValue = wasm.TS_Hostname_clone(orig);
17304 return nativeResponseValue;
17306 // MUST_USE_RES uint8_t Hostname_len(const struct LDKHostname *NONNULL_PTR this_arg);
17308 export function Hostname_len(this_arg: bigint): number {
17309 if(!isWasmInitialized) {
17310 throw new Error("initializeWasm() must be awaited first!");
17312 const nativeResponseValue = wasm.TS_Hostname_len(this_arg);
17313 return nativeResponseValue;
17315 // struct LDKCResult_StringErrorZ sign(struct LDKu8slice msg, const uint8_t (*sk)[32]);
17317 export function sign(msg: number, sk: number): bigint {
17318 if(!isWasmInitialized) {
17319 throw new Error("initializeWasm() must be awaited first!");
17321 const nativeResponseValue = wasm.TS_sign(msg, sk);
17322 return nativeResponseValue;
17324 // struct LDKCResult_PublicKeyErrorZ recover_pk(struct LDKu8slice msg, struct LDKStr sig);
17326 export function recover_pk(msg: number, sig: number): bigint {
17327 if(!isWasmInitialized) {
17328 throw new Error("initializeWasm() must be awaited first!");
17330 const nativeResponseValue = wasm.TS_recover_pk(msg, sig);
17331 return nativeResponseValue;
17333 // bool verify(struct LDKu8slice msg, struct LDKStr sig, struct LDKPublicKey pk);
17335 export function verify(msg: number, sig: number, pk: number): boolean {
17336 if(!isWasmInitialized) {
17337 throw new Error("initializeWasm() must be awaited first!");
17339 const nativeResponseValue = wasm.TS_verify(msg, sig, pk);
17340 return nativeResponseValue;
17342 // struct LDKCVec_u8Z construct_invoice_preimage(struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z data_without_signature);
17344 export function construct_invoice_preimage(hrp_bytes: number, data_without_signature: number): number {
17345 if(!isWasmInitialized) {
17346 throw new Error("initializeWasm() must be awaited first!");
17348 const nativeResponseValue = wasm.TS_construct_invoice_preimage(hrp_bytes, data_without_signature);
17349 return nativeResponseValue;
17351 // void Persister_free(struct LDKPersister this_ptr);
17353 export function Persister_free(this_ptr: bigint): void {
17354 if(!isWasmInitialized) {
17355 throw new Error("initializeWasm() must be awaited first!");
17357 const nativeResponseValue = wasm.TS_Persister_free(this_ptr);
17358 // debug statements here
17360 // void FutureCallback_free(struct LDKFutureCallback this_ptr);
17362 export function FutureCallback_free(this_ptr: bigint): void {
17363 if(!isWasmInitialized) {
17364 throw new Error("initializeWasm() must be awaited first!");
17366 const nativeResponseValue = wasm.TS_FutureCallback_free(this_ptr);
17367 // debug statements here
17369 // void Future_free(struct LDKFuture this_obj);
17371 export function Future_free(this_obj: bigint): void {
17372 if(!isWasmInitialized) {
17373 throw new Error("initializeWasm() must be awaited first!");
17375 const nativeResponseValue = wasm.TS_Future_free(this_obj);
17376 // debug statements here
17378 // void Future_register_callback_fn(const struct LDKFuture *NONNULL_PTR this_arg, struct LDKFutureCallback callback);
17380 export function Future_register_callback_fn(this_arg: bigint, callback: bigint): void {
17381 if(!isWasmInitialized) {
17382 throw new Error("initializeWasm() must be awaited first!");
17384 const nativeResponseValue = wasm.TS_Future_register_callback_fn(this_arg, callback);
17385 // debug statements here
17387 // enum LDKLevel Level_clone(const enum LDKLevel *NONNULL_PTR orig);
17389 export function Level_clone(orig: bigint): Level {
17390 if(!isWasmInitialized) {
17391 throw new Error("initializeWasm() must be awaited first!");
17393 const nativeResponseValue = wasm.TS_Level_clone(orig);
17394 return nativeResponseValue;
17396 // enum LDKLevel Level_gossip(void);
17398 export function Level_gossip(): Level {
17399 if(!isWasmInitialized) {
17400 throw new Error("initializeWasm() must be awaited first!");
17402 const nativeResponseValue = wasm.TS_Level_gossip();
17403 return nativeResponseValue;
17405 // enum LDKLevel Level_trace(void);
17407 export function Level_trace(): Level {
17408 if(!isWasmInitialized) {
17409 throw new Error("initializeWasm() must be awaited first!");
17411 const nativeResponseValue = wasm.TS_Level_trace();
17412 return nativeResponseValue;
17414 // enum LDKLevel Level_debug(void);
17416 export function Level_debug(): Level {
17417 if(!isWasmInitialized) {
17418 throw new Error("initializeWasm() must be awaited first!");
17420 const nativeResponseValue = wasm.TS_Level_debug();
17421 return nativeResponseValue;
17423 // enum LDKLevel Level_info(void);
17425 export function Level_info(): Level {
17426 if(!isWasmInitialized) {
17427 throw new Error("initializeWasm() must be awaited first!");
17429 const nativeResponseValue = wasm.TS_Level_info();
17430 return nativeResponseValue;
17432 // enum LDKLevel Level_warn(void);
17434 export function Level_warn(): Level {
17435 if(!isWasmInitialized) {
17436 throw new Error("initializeWasm() must be awaited first!");
17438 const nativeResponseValue = wasm.TS_Level_warn();
17439 return nativeResponseValue;
17441 // enum LDKLevel Level_error(void);
17443 export function Level_error(): Level {
17444 if(!isWasmInitialized) {
17445 throw new Error("initializeWasm() must be awaited first!");
17447 const nativeResponseValue = wasm.TS_Level_error();
17448 return nativeResponseValue;
17450 // bool Level_eq(const enum LDKLevel *NONNULL_PTR a, const enum LDKLevel *NONNULL_PTR b);
17452 export function Level_eq(a: bigint, b: bigint): boolean {
17453 if(!isWasmInitialized) {
17454 throw new Error("initializeWasm() must be awaited first!");
17456 const nativeResponseValue = wasm.TS_Level_eq(a, b);
17457 return nativeResponseValue;
17459 // uint64_t Level_hash(const enum LDKLevel *NONNULL_PTR o);
17461 export function Level_hash(o: bigint): bigint {
17462 if(!isWasmInitialized) {
17463 throw new Error("initializeWasm() must be awaited first!");
17465 const nativeResponseValue = wasm.TS_Level_hash(o);
17466 return nativeResponseValue;
17468 // MUST_USE_RES enum LDKLevel Level_max(void);
17470 export function Level_max(): Level {
17471 if(!isWasmInitialized) {
17472 throw new Error("initializeWasm() must be awaited first!");
17474 const nativeResponseValue = wasm.TS_Level_max();
17475 return nativeResponseValue;
17477 // void Record_free(struct LDKRecord this_obj);
17479 export function Record_free(this_obj: bigint): void {
17480 if(!isWasmInitialized) {
17481 throw new Error("initializeWasm() must be awaited first!");
17483 const nativeResponseValue = wasm.TS_Record_free(this_obj);
17484 // debug statements here
17486 // enum LDKLevel Record_get_level(const struct LDKRecord *NONNULL_PTR this_ptr);
17488 export function Record_get_level(this_ptr: bigint): Level {
17489 if(!isWasmInitialized) {
17490 throw new Error("initializeWasm() must be awaited first!");
17492 const nativeResponseValue = wasm.TS_Record_get_level(this_ptr);
17493 return nativeResponseValue;
17495 // void Record_set_level(struct LDKRecord *NONNULL_PTR this_ptr, enum LDKLevel val);
17497 export function Record_set_level(this_ptr: bigint, val: Level): void {
17498 if(!isWasmInitialized) {
17499 throw new Error("initializeWasm() must be awaited first!");
17501 const nativeResponseValue = wasm.TS_Record_set_level(this_ptr, val);
17502 // debug statements here
17504 // struct LDKStr Record_get_args(const struct LDKRecord *NONNULL_PTR this_ptr);
17506 export function Record_get_args(this_ptr: bigint): number {
17507 if(!isWasmInitialized) {
17508 throw new Error("initializeWasm() must be awaited first!");
17510 const nativeResponseValue = wasm.TS_Record_get_args(this_ptr);
17511 return nativeResponseValue;
17513 // void Record_set_args(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
17515 export function Record_set_args(this_ptr: bigint, val: number): void {
17516 if(!isWasmInitialized) {
17517 throw new Error("initializeWasm() must be awaited first!");
17519 const nativeResponseValue = wasm.TS_Record_set_args(this_ptr, val);
17520 // debug statements here
17522 // struct LDKStr Record_get_module_path(const struct LDKRecord *NONNULL_PTR this_ptr);
17524 export function Record_get_module_path(this_ptr: bigint): number {
17525 if(!isWasmInitialized) {
17526 throw new Error("initializeWasm() must be awaited first!");
17528 const nativeResponseValue = wasm.TS_Record_get_module_path(this_ptr);
17529 return nativeResponseValue;
17531 // void Record_set_module_path(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
17533 export function Record_set_module_path(this_ptr: bigint, val: number): void {
17534 if(!isWasmInitialized) {
17535 throw new Error("initializeWasm() must be awaited first!");
17537 const nativeResponseValue = wasm.TS_Record_set_module_path(this_ptr, val);
17538 // debug statements here
17540 // struct LDKStr Record_get_file(const struct LDKRecord *NONNULL_PTR this_ptr);
17542 export function Record_get_file(this_ptr: bigint): number {
17543 if(!isWasmInitialized) {
17544 throw new Error("initializeWasm() must be awaited first!");
17546 const nativeResponseValue = wasm.TS_Record_get_file(this_ptr);
17547 return nativeResponseValue;
17549 // void Record_set_file(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
17551 export function Record_set_file(this_ptr: bigint, val: number): void {
17552 if(!isWasmInitialized) {
17553 throw new Error("initializeWasm() must be awaited first!");
17555 const nativeResponseValue = wasm.TS_Record_set_file(this_ptr, val);
17556 // debug statements here
17558 // uint32_t Record_get_line(const struct LDKRecord *NONNULL_PTR this_ptr);
17560 export function Record_get_line(this_ptr: bigint): number {
17561 if(!isWasmInitialized) {
17562 throw new Error("initializeWasm() must be awaited first!");
17564 const nativeResponseValue = wasm.TS_Record_get_line(this_ptr);
17565 return nativeResponseValue;
17567 // void Record_set_line(struct LDKRecord *NONNULL_PTR this_ptr, uint32_t val);
17569 export function Record_set_line(this_ptr: bigint, val: number): void {
17570 if(!isWasmInitialized) {
17571 throw new Error("initializeWasm() must be awaited first!");
17573 const nativeResponseValue = wasm.TS_Record_set_line(this_ptr, val);
17574 // debug statements here
17576 // uint64_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg);
17578 export function Record_clone_ptr(arg: bigint): bigint {
17579 if(!isWasmInitialized) {
17580 throw new Error("initializeWasm() must be awaited first!");
17582 const nativeResponseValue = wasm.TS_Record_clone_ptr(arg);
17583 return nativeResponseValue;
17585 // struct LDKRecord Record_clone(const struct LDKRecord *NONNULL_PTR orig);
17587 export function Record_clone(orig: bigint): bigint {
17588 if(!isWasmInitialized) {
17589 throw new Error("initializeWasm() must be awaited first!");
17591 const nativeResponseValue = wasm.TS_Record_clone(orig);
17592 return nativeResponseValue;
17594 // void Logger_free(struct LDKLogger this_ptr);
17596 export function Logger_free(this_ptr: bigint): void {
17597 if(!isWasmInitialized) {
17598 throw new Error("initializeWasm() must be awaited first!");
17600 const nativeResponseValue = wasm.TS_Logger_free(this_ptr);
17601 // debug statements here
17603 // void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_obj);
17605 export function ChannelHandshakeConfig_free(this_obj: bigint): void {
17606 if(!isWasmInitialized) {
17607 throw new Error("initializeWasm() must be awaited first!");
17609 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_free(this_obj);
17610 // debug statements here
17612 // uint32_t ChannelHandshakeConfig_get_minimum_depth(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
17614 export function ChannelHandshakeConfig_get_minimum_depth(this_ptr: bigint): number {
17615 if(!isWasmInitialized) {
17616 throw new Error("initializeWasm() must be awaited first!");
17618 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_minimum_depth(this_ptr);
17619 return nativeResponseValue;
17621 // void ChannelHandshakeConfig_set_minimum_depth(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
17623 export function ChannelHandshakeConfig_set_minimum_depth(this_ptr: bigint, val: number): void {
17624 if(!isWasmInitialized) {
17625 throw new Error("initializeWasm() must be awaited first!");
17627 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_minimum_depth(this_ptr, val);
17628 // debug statements here
17630 // uint16_t ChannelHandshakeConfig_get_our_to_self_delay(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
17632 export function ChannelHandshakeConfig_get_our_to_self_delay(this_ptr: bigint): number {
17633 if(!isWasmInitialized) {
17634 throw new Error("initializeWasm() must be awaited first!");
17636 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_to_self_delay(this_ptr);
17637 return nativeResponseValue;
17639 // void ChannelHandshakeConfig_set_our_to_self_delay(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
17641 export function ChannelHandshakeConfig_set_our_to_self_delay(this_ptr: bigint, val: number): void {
17642 if(!isWasmInitialized) {
17643 throw new Error("initializeWasm() must be awaited first!");
17645 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_to_self_delay(this_ptr, val);
17646 // debug statements here
17648 // uint64_t ChannelHandshakeConfig_get_our_htlc_minimum_msat(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
17650 export function ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr: bigint): bigint {
17651 if(!isWasmInitialized) {
17652 throw new Error("initializeWasm() must be awaited first!");
17654 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr);
17655 return nativeResponseValue;
17657 // void ChannelHandshakeConfig_set_our_htlc_minimum_msat(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint64_t val);
17659 export function ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
17660 if(!isWasmInitialized) {
17661 throw new Error("initializeWasm() must be awaited first!");
17663 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr, val);
17664 // debug statements here
17666 // uint8_t ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
17668 export function ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: bigint): number {
17669 if(!isWasmInitialized) {
17670 throw new Error("initializeWasm() must be awaited first!");
17672 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr);
17673 return nativeResponseValue;
17675 // void ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint8_t val);
17677 export function ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: bigint, val: number): void {
17678 if(!isWasmInitialized) {
17679 throw new Error("initializeWasm() must be awaited first!");
17681 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr, val);
17682 // debug statements here
17684 // bool ChannelHandshakeConfig_get_negotiate_scid_privacy(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
17686 export function ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr: bigint): boolean {
17687 if(!isWasmInitialized) {
17688 throw new Error("initializeWasm() must be awaited first!");
17690 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr);
17691 return nativeResponseValue;
17693 // void ChannelHandshakeConfig_set_negotiate_scid_privacy(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
17695 export function ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr: bigint, val: boolean): void {
17696 if(!isWasmInitialized) {
17697 throw new Error("initializeWasm() must be awaited first!");
17699 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr, val);
17700 // debug statements here
17702 // bool ChannelHandshakeConfig_get_announced_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
17704 export function ChannelHandshakeConfig_get_announced_channel(this_ptr: bigint): boolean {
17705 if(!isWasmInitialized) {
17706 throw new Error("initializeWasm() must be awaited first!");
17708 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_announced_channel(this_ptr);
17709 return nativeResponseValue;
17711 // void ChannelHandshakeConfig_set_announced_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
17713 export function ChannelHandshakeConfig_set_announced_channel(this_ptr: bigint, val: boolean): void {
17714 if(!isWasmInitialized) {
17715 throw new Error("initializeWasm() must be awaited first!");
17717 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_announced_channel(this_ptr, val);
17718 // debug statements here
17720 // bool ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
17722 export function ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr: bigint): boolean {
17723 if(!isWasmInitialized) {
17724 throw new Error("initializeWasm() must be awaited first!");
17726 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr);
17727 return nativeResponseValue;
17729 // void ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
17731 export function ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr: bigint, val: boolean): void {
17732 if(!isWasmInitialized) {
17733 throw new Error("initializeWasm() must be awaited first!");
17735 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr, val);
17736 // debug statements here
17738 // uint32_t ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
17740 export function ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(this_ptr: bigint): number {
17741 if(!isWasmInitialized) {
17742 throw new Error("initializeWasm() must be awaited first!");
17744 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(this_ptr);
17745 return nativeResponseValue;
17747 // void ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
17749 export function ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(this_ptr: bigint, val: number): void {
17750 if(!isWasmInitialized) {
17751 throw new Error("initializeWasm() must be awaited first!");
17753 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(this_ptr, val);
17754 // debug statements here
17756 // MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_new(uint32_t minimum_depth_arg, uint16_t our_to_self_delay_arg, uint64_t our_htlc_minimum_msat_arg, uint8_t max_inbound_htlc_value_in_flight_percent_of_channel_arg, bool negotiate_scid_privacy_arg, bool announced_channel_arg, bool commit_upfront_shutdown_pubkey_arg, uint32_t their_channel_reserve_proportional_millionths_arg);
17758 export function ChannelHandshakeConfig_new(minimum_depth_arg: number, our_to_self_delay_arg: number, our_htlc_minimum_msat_arg: bigint, max_inbound_htlc_value_in_flight_percent_of_channel_arg: number, negotiate_scid_privacy_arg: boolean, announced_channel_arg: boolean, commit_upfront_shutdown_pubkey_arg: boolean, their_channel_reserve_proportional_millionths_arg: number): bigint {
17759 if(!isWasmInitialized) {
17760 throw new Error("initializeWasm() must be awaited first!");
17762 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_new(minimum_depth_arg, our_to_self_delay_arg, our_htlc_minimum_msat_arg, max_inbound_htlc_value_in_flight_percent_of_channel_arg, negotiate_scid_privacy_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg, their_channel_reserve_proportional_millionths_arg);
17763 return nativeResponseValue;
17765 // uint64_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg);
17767 export function ChannelHandshakeConfig_clone_ptr(arg: bigint): bigint {
17768 if(!isWasmInitialized) {
17769 throw new Error("initializeWasm() must be awaited first!");
17771 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone_ptr(arg);
17772 return nativeResponseValue;
17774 // struct LDKChannelHandshakeConfig ChannelHandshakeConfig_clone(const struct LDKChannelHandshakeConfig *NONNULL_PTR orig);
17776 export function ChannelHandshakeConfig_clone(orig: bigint): bigint {
17777 if(!isWasmInitialized) {
17778 throw new Error("initializeWasm() must be awaited first!");
17780 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone(orig);
17781 return nativeResponseValue;
17783 // MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void);
17785 export function ChannelHandshakeConfig_default(): bigint {
17786 if(!isWasmInitialized) {
17787 throw new Error("initializeWasm() must be awaited first!");
17789 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_default();
17790 return nativeResponseValue;
17792 // void ChannelHandshakeLimits_free(struct LDKChannelHandshakeLimits this_obj);
17794 export function ChannelHandshakeLimits_free(this_obj: bigint): void {
17795 if(!isWasmInitialized) {
17796 throw new Error("initializeWasm() must be awaited first!");
17798 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_free(this_obj);
17799 // debug statements here
17801 // uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
17803 export function ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr: bigint): bigint {
17804 if(!isWasmInitialized) {
17805 throw new Error("initializeWasm() must be awaited first!");
17807 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr);
17808 return nativeResponseValue;
17810 // void ChannelHandshakeLimits_set_min_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
17812 export function ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr: bigint, val: bigint): void {
17813 if(!isWasmInitialized) {
17814 throw new Error("initializeWasm() must be awaited first!");
17816 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr, val);
17817 // debug statements here
17819 // uint64_t ChannelHandshakeLimits_get_max_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
17821 export function ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr: bigint): bigint {
17822 if(!isWasmInitialized) {
17823 throw new Error("initializeWasm() must be awaited first!");
17825 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr);
17826 return nativeResponseValue;
17828 // void ChannelHandshakeLimits_set_max_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
17830 export function ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr: bigint, val: bigint): void {
17831 if(!isWasmInitialized) {
17832 throw new Error("initializeWasm() must be awaited first!");
17834 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr, val);
17835 // debug statements here
17837 // uint64_t ChannelHandshakeLimits_get_max_htlc_minimum_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
17839 export function ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr: bigint): bigint {
17840 if(!isWasmInitialized) {
17841 throw new Error("initializeWasm() must be awaited first!");
17843 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr);
17844 return nativeResponseValue;
17846 // void ChannelHandshakeLimits_set_max_htlc_minimum_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
17848 export function ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
17849 if(!isWasmInitialized) {
17850 throw new Error("initializeWasm() must be awaited first!");
17852 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr, val);
17853 // debug statements here
17855 // uint64_t ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
17857 export function ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
17858 if(!isWasmInitialized) {
17859 throw new Error("initializeWasm() must be awaited first!");
17861 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr);
17862 return nativeResponseValue;
17864 // void ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
17866 export function ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
17867 if(!isWasmInitialized) {
17868 throw new Error("initializeWasm() must be awaited first!");
17870 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr, val);
17871 // debug statements here
17873 // uint64_t ChannelHandshakeLimits_get_max_channel_reserve_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
17875 export function ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr: bigint): bigint {
17876 if(!isWasmInitialized) {
17877 throw new Error("initializeWasm() must be awaited first!");
17879 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr);
17880 return nativeResponseValue;
17882 // void ChannelHandshakeLimits_set_max_channel_reserve_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
17884 export function ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
17885 if(!isWasmInitialized) {
17886 throw new Error("initializeWasm() must be awaited first!");
17888 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr, val);
17889 // debug statements here
17891 // uint16_t ChannelHandshakeLimits_get_min_max_accepted_htlcs(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
17893 export function ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr: bigint): number {
17894 if(!isWasmInitialized) {
17895 throw new Error("initializeWasm() must be awaited first!");
17897 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr);
17898 return nativeResponseValue;
17900 // void ChannelHandshakeLimits_set_min_max_accepted_htlcs(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
17902 export function ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr: bigint, val: number): void {
17903 if(!isWasmInitialized) {
17904 throw new Error("initializeWasm() must be awaited first!");
17906 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr, val);
17907 // debug statements here
17909 // uint32_t ChannelHandshakeLimits_get_max_minimum_depth(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
17911 export function ChannelHandshakeLimits_get_max_minimum_depth(this_ptr: bigint): number {
17912 if(!isWasmInitialized) {
17913 throw new Error("initializeWasm() must be awaited first!");
17915 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_minimum_depth(this_ptr);
17916 return nativeResponseValue;
17918 // void ChannelHandshakeLimits_set_max_minimum_depth(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint32_t val);
17920 export function ChannelHandshakeLimits_set_max_minimum_depth(this_ptr: bigint, val: number): void {
17921 if(!isWasmInitialized) {
17922 throw new Error("initializeWasm() must be awaited first!");
17924 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_minimum_depth(this_ptr, val);
17925 // debug statements here
17927 // bool ChannelHandshakeLimits_get_trust_own_funding_0conf(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
17929 export function ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr: bigint): boolean {
17930 if(!isWasmInitialized) {
17931 throw new Error("initializeWasm() must be awaited first!");
17933 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr);
17934 return nativeResponseValue;
17936 // void ChannelHandshakeLimits_set_trust_own_funding_0conf(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
17938 export function ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr: bigint, val: boolean): void {
17939 if(!isWasmInitialized) {
17940 throw new Error("initializeWasm() must be awaited first!");
17942 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr, val);
17943 // debug statements here
17945 // bool ChannelHandshakeLimits_get_force_announced_channel_preference(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
17947 export function ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr: bigint): boolean {
17948 if(!isWasmInitialized) {
17949 throw new Error("initializeWasm() must be awaited first!");
17951 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr);
17952 return nativeResponseValue;
17954 // void ChannelHandshakeLimits_set_force_announced_channel_preference(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
17956 export function ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr: bigint, val: boolean): void {
17957 if(!isWasmInitialized) {
17958 throw new Error("initializeWasm() must be awaited first!");
17960 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr, val);
17961 // debug statements here
17963 // uint16_t ChannelHandshakeLimits_get_their_to_self_delay(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
17965 export function ChannelHandshakeLimits_get_their_to_self_delay(this_ptr: bigint): number {
17966 if(!isWasmInitialized) {
17967 throw new Error("initializeWasm() must be awaited first!");
17969 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_their_to_self_delay(this_ptr);
17970 return nativeResponseValue;
17972 // void ChannelHandshakeLimits_set_their_to_self_delay(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
17974 export function ChannelHandshakeLimits_set_their_to_self_delay(this_ptr: bigint, val: number): void {
17975 if(!isWasmInitialized) {
17976 throw new Error("initializeWasm() must be awaited first!");
17978 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_their_to_self_delay(this_ptr, val);
17979 // debug statements here
17981 // MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_new(uint64_t min_funding_satoshis_arg, uint64_t max_funding_satoshis_arg, uint64_t max_htlc_minimum_msat_arg, uint64_t min_max_htlc_value_in_flight_msat_arg, uint64_t max_channel_reserve_satoshis_arg, uint16_t min_max_accepted_htlcs_arg, uint32_t max_minimum_depth_arg, bool trust_own_funding_0conf_arg, bool force_announced_channel_preference_arg, uint16_t their_to_self_delay_arg);
17983 export function ChannelHandshakeLimits_new(min_funding_satoshis_arg: bigint, max_funding_satoshis_arg: bigint, max_htlc_minimum_msat_arg: bigint, min_max_htlc_value_in_flight_msat_arg: bigint, max_channel_reserve_satoshis_arg: bigint, min_max_accepted_htlcs_arg: number, max_minimum_depth_arg: number, trust_own_funding_0conf_arg: boolean, force_announced_channel_preference_arg: boolean, their_to_self_delay_arg: number): bigint {
17984 if(!isWasmInitialized) {
17985 throw new Error("initializeWasm() must be awaited first!");
17987 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_new(min_funding_satoshis_arg, max_funding_satoshis_arg, max_htlc_minimum_msat_arg, min_max_htlc_value_in_flight_msat_arg, max_channel_reserve_satoshis_arg, min_max_accepted_htlcs_arg, max_minimum_depth_arg, trust_own_funding_0conf_arg, force_announced_channel_preference_arg, their_to_self_delay_arg);
17988 return nativeResponseValue;
17990 // uint64_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg);
17992 export function ChannelHandshakeLimits_clone_ptr(arg: bigint): bigint {
17993 if(!isWasmInitialized) {
17994 throw new Error("initializeWasm() must be awaited first!");
17996 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone_ptr(arg);
17997 return nativeResponseValue;
17999 // struct LDKChannelHandshakeLimits ChannelHandshakeLimits_clone(const struct LDKChannelHandshakeLimits *NONNULL_PTR orig);
18001 export function ChannelHandshakeLimits_clone(orig: bigint): bigint {
18002 if(!isWasmInitialized) {
18003 throw new Error("initializeWasm() must be awaited first!");
18005 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone(orig);
18006 return nativeResponseValue;
18008 // MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_default(void);
18010 export function ChannelHandshakeLimits_default(): bigint {
18011 if(!isWasmInitialized) {
18012 throw new Error("initializeWasm() must be awaited first!");
18014 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_default();
18015 return nativeResponseValue;
18017 // void ChannelConfig_free(struct LDKChannelConfig this_obj);
18019 export function ChannelConfig_free(this_obj: bigint): void {
18020 if(!isWasmInitialized) {
18021 throw new Error("initializeWasm() must be awaited first!");
18023 const nativeResponseValue = wasm.TS_ChannelConfig_free(this_obj);
18024 // debug statements here
18026 // uint32_t ChannelConfig_get_forwarding_fee_proportional_millionths(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
18028 export function ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr: bigint): number {
18029 if(!isWasmInitialized) {
18030 throw new Error("initializeWasm() must be awaited first!");
18032 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr);
18033 return nativeResponseValue;
18035 // void ChannelConfig_set_forwarding_fee_proportional_millionths(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
18037 export function ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr: bigint, val: number): void {
18038 if(!isWasmInitialized) {
18039 throw new Error("initializeWasm() must be awaited first!");
18041 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr, val);
18042 // debug statements here
18044 // uint32_t ChannelConfig_get_forwarding_fee_base_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
18046 export function ChannelConfig_get_forwarding_fee_base_msat(this_ptr: bigint): number {
18047 if(!isWasmInitialized) {
18048 throw new Error("initializeWasm() must be awaited first!");
18050 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_base_msat(this_ptr);
18051 return nativeResponseValue;
18053 // void ChannelConfig_set_forwarding_fee_base_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
18055 export function ChannelConfig_set_forwarding_fee_base_msat(this_ptr: bigint, val: number): void {
18056 if(!isWasmInitialized) {
18057 throw new Error("initializeWasm() must be awaited first!");
18059 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_base_msat(this_ptr, val);
18060 // debug statements here
18062 // uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
18064 export function ChannelConfig_get_cltv_expiry_delta(this_ptr: bigint): number {
18065 if(!isWasmInitialized) {
18066 throw new Error("initializeWasm() must be awaited first!");
18068 const nativeResponseValue = wasm.TS_ChannelConfig_get_cltv_expiry_delta(this_ptr);
18069 return nativeResponseValue;
18071 // void ChannelConfig_set_cltv_expiry_delta(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint16_t val);
18073 export function ChannelConfig_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
18074 if(!isWasmInitialized) {
18075 throw new Error("initializeWasm() must be awaited first!");
18077 const nativeResponseValue = wasm.TS_ChannelConfig_set_cltv_expiry_delta(this_ptr, val);
18078 // debug statements here
18080 // uint64_t ChannelConfig_get_max_dust_htlc_exposure_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
18082 export function ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr: bigint): bigint {
18083 if(!isWasmInitialized) {
18084 throw new Error("initializeWasm() must be awaited first!");
18086 const nativeResponseValue = wasm.TS_ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr);
18087 return nativeResponseValue;
18089 // void ChannelConfig_set_max_dust_htlc_exposure_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
18091 export function ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr: bigint, val: bigint): void {
18092 if(!isWasmInitialized) {
18093 throw new Error("initializeWasm() must be awaited first!");
18095 const nativeResponseValue = wasm.TS_ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr, val);
18096 // debug statements here
18098 // uint64_t ChannelConfig_get_force_close_avoidance_max_fee_satoshis(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
18100 export function ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr: bigint): bigint {
18101 if(!isWasmInitialized) {
18102 throw new Error("initializeWasm() must be awaited first!");
18104 const nativeResponseValue = wasm.TS_ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr);
18105 return nativeResponseValue;
18107 // void ChannelConfig_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
18109 export function ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr: bigint, val: bigint): void {
18110 if(!isWasmInitialized) {
18111 throw new Error("initializeWasm() must be awaited first!");
18113 const nativeResponseValue = wasm.TS_ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr, val);
18114 // debug statements here
18116 // 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, uint64_t max_dust_htlc_exposure_msat_arg, uint64_t force_close_avoidance_max_fee_satoshis_arg);
18118 export function ChannelConfig_new(forwarding_fee_proportional_millionths_arg: number, forwarding_fee_base_msat_arg: number, cltv_expiry_delta_arg: number, max_dust_htlc_exposure_msat_arg: bigint, force_close_avoidance_max_fee_satoshis_arg: bigint): bigint {
18119 if(!isWasmInitialized) {
18120 throw new Error("initializeWasm() must be awaited first!");
18122 const nativeResponseValue = wasm.TS_ChannelConfig_new(forwarding_fee_proportional_millionths_arg, forwarding_fee_base_msat_arg, cltv_expiry_delta_arg, max_dust_htlc_exposure_msat_arg, force_close_avoidance_max_fee_satoshis_arg);
18123 return nativeResponseValue;
18125 // uint64_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg);
18127 export function ChannelConfig_clone_ptr(arg: bigint): bigint {
18128 if(!isWasmInitialized) {
18129 throw new Error("initializeWasm() must be awaited first!");
18131 const nativeResponseValue = wasm.TS_ChannelConfig_clone_ptr(arg);
18132 return nativeResponseValue;
18134 // struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
18136 export function ChannelConfig_clone(orig: bigint): bigint {
18137 if(!isWasmInitialized) {
18138 throw new Error("initializeWasm() must be awaited first!");
18140 const nativeResponseValue = wasm.TS_ChannelConfig_clone(orig);
18141 return nativeResponseValue;
18143 // MUST_USE_RES struct LDKChannelConfig ChannelConfig_default(void);
18145 export function ChannelConfig_default(): bigint {
18146 if(!isWasmInitialized) {
18147 throw new Error("initializeWasm() must be awaited first!");
18149 const nativeResponseValue = wasm.TS_ChannelConfig_default();
18150 return nativeResponseValue;
18152 // struct LDKCVec_u8Z ChannelConfig_write(const struct LDKChannelConfig *NONNULL_PTR obj);
18154 export function ChannelConfig_write(obj: bigint): number {
18155 if(!isWasmInitialized) {
18156 throw new Error("initializeWasm() must be awaited first!");
18158 const nativeResponseValue = wasm.TS_ChannelConfig_write(obj);
18159 return nativeResponseValue;
18161 // struct LDKCResult_ChannelConfigDecodeErrorZ ChannelConfig_read(struct LDKu8slice ser);
18163 export function ChannelConfig_read(ser: number): bigint {
18164 if(!isWasmInitialized) {
18165 throw new Error("initializeWasm() must be awaited first!");
18167 const nativeResponseValue = wasm.TS_ChannelConfig_read(ser);
18168 return nativeResponseValue;
18170 // void UserConfig_free(struct LDKUserConfig this_obj);
18172 export function UserConfig_free(this_obj: bigint): void {
18173 if(!isWasmInitialized) {
18174 throw new Error("initializeWasm() must be awaited first!");
18176 const nativeResponseValue = wasm.TS_UserConfig_free(this_obj);
18177 // debug statements here
18179 // struct LDKChannelHandshakeConfig UserConfig_get_channel_handshake_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
18181 export function UserConfig_get_channel_handshake_config(this_ptr: bigint): bigint {
18182 if(!isWasmInitialized) {
18183 throw new Error("initializeWasm() must be awaited first!");
18185 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_config(this_ptr);
18186 return nativeResponseValue;
18188 // void UserConfig_set_channel_handshake_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeConfig val);
18190 export function UserConfig_set_channel_handshake_config(this_ptr: bigint, val: bigint): void {
18191 if(!isWasmInitialized) {
18192 throw new Error("initializeWasm() must be awaited first!");
18194 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_config(this_ptr, val);
18195 // debug statements here
18197 // struct LDKChannelHandshakeLimits UserConfig_get_channel_handshake_limits(const struct LDKUserConfig *NONNULL_PTR this_ptr);
18199 export function UserConfig_get_channel_handshake_limits(this_ptr: bigint): bigint {
18200 if(!isWasmInitialized) {
18201 throw new Error("initializeWasm() must be awaited first!");
18203 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_limits(this_ptr);
18204 return nativeResponseValue;
18206 // void UserConfig_set_channel_handshake_limits(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeLimits val);
18208 export function UserConfig_set_channel_handshake_limits(this_ptr: bigint, val: bigint): void {
18209 if(!isWasmInitialized) {
18210 throw new Error("initializeWasm() must be awaited first!");
18212 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_limits(this_ptr, val);
18213 // debug statements here
18215 // struct LDKChannelConfig UserConfig_get_channel_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
18217 export function UserConfig_get_channel_config(this_ptr: bigint): bigint {
18218 if(!isWasmInitialized) {
18219 throw new Error("initializeWasm() must be awaited first!");
18221 const nativeResponseValue = wasm.TS_UserConfig_get_channel_config(this_ptr);
18222 return nativeResponseValue;
18224 // void UserConfig_set_channel_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
18226 export function UserConfig_set_channel_config(this_ptr: bigint, val: bigint): void {
18227 if(!isWasmInitialized) {
18228 throw new Error("initializeWasm() must be awaited first!");
18230 const nativeResponseValue = wasm.TS_UserConfig_set_channel_config(this_ptr, val);
18231 // debug statements here
18233 // bool UserConfig_get_accept_forwards_to_priv_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
18235 export function UserConfig_get_accept_forwards_to_priv_channels(this_ptr: bigint): boolean {
18236 if(!isWasmInitialized) {
18237 throw new Error("initializeWasm() must be awaited first!");
18239 const nativeResponseValue = wasm.TS_UserConfig_get_accept_forwards_to_priv_channels(this_ptr);
18240 return nativeResponseValue;
18242 // void UserConfig_set_accept_forwards_to_priv_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
18244 export function UserConfig_set_accept_forwards_to_priv_channels(this_ptr: bigint, val: boolean): void {
18245 if(!isWasmInitialized) {
18246 throw new Error("initializeWasm() must be awaited first!");
18248 const nativeResponseValue = wasm.TS_UserConfig_set_accept_forwards_to_priv_channels(this_ptr, val);
18249 // debug statements here
18251 // bool UserConfig_get_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
18253 export function UserConfig_get_accept_inbound_channels(this_ptr: bigint): boolean {
18254 if(!isWasmInitialized) {
18255 throw new Error("initializeWasm() must be awaited first!");
18257 const nativeResponseValue = wasm.TS_UserConfig_get_accept_inbound_channels(this_ptr);
18258 return nativeResponseValue;
18260 // void UserConfig_set_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
18262 export function UserConfig_set_accept_inbound_channels(this_ptr: bigint, val: boolean): void {
18263 if(!isWasmInitialized) {
18264 throw new Error("initializeWasm() must be awaited first!");
18266 const nativeResponseValue = wasm.TS_UserConfig_set_accept_inbound_channels(this_ptr, val);
18267 // debug statements here
18269 // bool UserConfig_get_manually_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
18271 export function UserConfig_get_manually_accept_inbound_channels(this_ptr: bigint): boolean {
18272 if(!isWasmInitialized) {
18273 throw new Error("initializeWasm() must be awaited first!");
18275 const nativeResponseValue = wasm.TS_UserConfig_get_manually_accept_inbound_channels(this_ptr);
18276 return nativeResponseValue;
18278 // void UserConfig_set_manually_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
18280 export function UserConfig_set_manually_accept_inbound_channels(this_ptr: bigint, val: boolean): void {
18281 if(!isWasmInitialized) {
18282 throw new Error("initializeWasm() must be awaited first!");
18284 const nativeResponseValue = wasm.TS_UserConfig_set_manually_accept_inbound_channels(this_ptr, val);
18285 // debug statements here
18287 // MUST_USE_RES struct LDKUserConfig UserConfig_new(struct LDKChannelHandshakeConfig channel_handshake_config_arg, struct LDKChannelHandshakeLimits channel_handshake_limits_arg, struct LDKChannelConfig channel_config_arg, bool accept_forwards_to_priv_channels_arg, bool accept_inbound_channels_arg, bool manually_accept_inbound_channels_arg);
18289 export function UserConfig_new(channel_handshake_config_arg: bigint, channel_handshake_limits_arg: bigint, channel_config_arg: bigint, accept_forwards_to_priv_channels_arg: boolean, accept_inbound_channels_arg: boolean, manually_accept_inbound_channels_arg: boolean): bigint {
18290 if(!isWasmInitialized) {
18291 throw new Error("initializeWasm() must be awaited first!");
18293 const nativeResponseValue = wasm.TS_UserConfig_new(channel_handshake_config_arg, channel_handshake_limits_arg, channel_config_arg, accept_forwards_to_priv_channels_arg, accept_inbound_channels_arg, manually_accept_inbound_channels_arg);
18294 return nativeResponseValue;
18296 // uint64_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg);
18298 export function UserConfig_clone_ptr(arg: bigint): bigint {
18299 if(!isWasmInitialized) {
18300 throw new Error("initializeWasm() must be awaited first!");
18302 const nativeResponseValue = wasm.TS_UserConfig_clone_ptr(arg);
18303 return nativeResponseValue;
18305 // struct LDKUserConfig UserConfig_clone(const struct LDKUserConfig *NONNULL_PTR orig);
18307 export function UserConfig_clone(orig: bigint): bigint {
18308 if(!isWasmInitialized) {
18309 throw new Error("initializeWasm() must be awaited first!");
18311 const nativeResponseValue = wasm.TS_UserConfig_clone(orig);
18312 return nativeResponseValue;
18314 // MUST_USE_RES struct LDKUserConfig UserConfig_default(void);
18316 export function UserConfig_default(): bigint {
18317 if(!isWasmInitialized) {
18318 throw new Error("initializeWasm() must be awaited first!");
18320 const nativeResponseValue = wasm.TS_UserConfig_default();
18321 return nativeResponseValue;
18323 // void BestBlock_free(struct LDKBestBlock this_obj);
18325 export function BestBlock_free(this_obj: bigint): void {
18326 if(!isWasmInitialized) {
18327 throw new Error("initializeWasm() must be awaited first!");
18329 const nativeResponseValue = wasm.TS_BestBlock_free(this_obj);
18330 // debug statements here
18332 // uint64_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg);
18334 export function BestBlock_clone_ptr(arg: bigint): bigint {
18335 if(!isWasmInitialized) {
18336 throw new Error("initializeWasm() must be awaited first!");
18338 const nativeResponseValue = wasm.TS_BestBlock_clone_ptr(arg);
18339 return nativeResponseValue;
18341 // struct LDKBestBlock BestBlock_clone(const struct LDKBestBlock *NONNULL_PTR orig);
18343 export function BestBlock_clone(orig: bigint): bigint {
18344 if(!isWasmInitialized) {
18345 throw new Error("initializeWasm() must be awaited first!");
18347 const nativeResponseValue = wasm.TS_BestBlock_clone(orig);
18348 return nativeResponseValue;
18350 // MUST_USE_RES struct LDKBestBlock BestBlock_from_genesis(enum LDKNetwork network);
18352 export function BestBlock_from_genesis(network: Network): bigint {
18353 if(!isWasmInitialized) {
18354 throw new Error("initializeWasm() must be awaited first!");
18356 const nativeResponseValue = wasm.TS_BestBlock_from_genesis(network);
18357 return nativeResponseValue;
18359 // MUST_USE_RES struct LDKBestBlock BestBlock_new(struct LDKThirtyTwoBytes block_hash, uint32_t height);
18361 export function BestBlock_new(block_hash: number, height: number): bigint {
18362 if(!isWasmInitialized) {
18363 throw new Error("initializeWasm() must be awaited first!");
18365 const nativeResponseValue = wasm.TS_BestBlock_new(block_hash, height);
18366 return nativeResponseValue;
18368 // MUST_USE_RES struct LDKThirtyTwoBytes BestBlock_block_hash(const struct LDKBestBlock *NONNULL_PTR this_arg);
18370 export function BestBlock_block_hash(this_arg: bigint): number {
18371 if(!isWasmInitialized) {
18372 throw new Error("initializeWasm() must be awaited first!");
18374 const nativeResponseValue = wasm.TS_BestBlock_block_hash(this_arg);
18375 return nativeResponseValue;
18377 // MUST_USE_RES uint32_t BestBlock_height(const struct LDKBestBlock *NONNULL_PTR this_arg);
18379 export function BestBlock_height(this_arg: bigint): number {
18380 if(!isWasmInitialized) {
18381 throw new Error("initializeWasm() must be awaited first!");
18383 const nativeResponseValue = wasm.TS_BestBlock_height(this_arg);
18384 return nativeResponseValue;
18386 // enum LDKAccessError AccessError_clone(const enum LDKAccessError *NONNULL_PTR orig);
18388 export function AccessError_clone(orig: bigint): AccessError {
18389 if(!isWasmInitialized) {
18390 throw new Error("initializeWasm() must be awaited first!");
18392 const nativeResponseValue = wasm.TS_AccessError_clone(orig);
18393 return nativeResponseValue;
18395 // enum LDKAccessError AccessError_unknown_chain(void);
18397 export function AccessError_unknown_chain(): AccessError {
18398 if(!isWasmInitialized) {
18399 throw new Error("initializeWasm() must be awaited first!");
18401 const nativeResponseValue = wasm.TS_AccessError_unknown_chain();
18402 return nativeResponseValue;
18404 // enum LDKAccessError AccessError_unknown_tx(void);
18406 export function AccessError_unknown_tx(): AccessError {
18407 if(!isWasmInitialized) {
18408 throw new Error("initializeWasm() must be awaited first!");
18410 const nativeResponseValue = wasm.TS_AccessError_unknown_tx();
18411 return nativeResponseValue;
18413 // void Access_free(struct LDKAccess this_ptr);
18415 export function Access_free(this_ptr: bigint): void {
18416 if(!isWasmInitialized) {
18417 throw new Error("initializeWasm() must be awaited first!");
18419 const nativeResponseValue = wasm.TS_Access_free(this_ptr);
18420 // debug statements here
18422 // void Listen_free(struct LDKListen this_ptr);
18424 export function Listen_free(this_ptr: bigint): void {
18425 if(!isWasmInitialized) {
18426 throw new Error("initializeWasm() must be awaited first!");
18428 const nativeResponseValue = wasm.TS_Listen_free(this_ptr);
18429 // debug statements here
18431 // void Confirm_free(struct LDKConfirm this_ptr);
18433 export function Confirm_free(this_ptr: bigint): void {
18434 if(!isWasmInitialized) {
18435 throw new Error("initializeWasm() must be awaited first!");
18437 const nativeResponseValue = wasm.TS_Confirm_free(this_ptr);
18438 // debug statements here
18440 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_clone(const enum LDKChannelMonitorUpdateErr *NONNULL_PTR orig);
18442 export function ChannelMonitorUpdateErr_clone(orig: bigint): ChannelMonitorUpdateErr {
18443 if(!isWasmInitialized) {
18444 throw new Error("initializeWasm() must be awaited first!");
18446 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_clone(orig);
18447 return nativeResponseValue;
18449 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_temporary_failure(void);
18451 export function ChannelMonitorUpdateErr_temporary_failure(): ChannelMonitorUpdateErr {
18452 if(!isWasmInitialized) {
18453 throw new Error("initializeWasm() must be awaited first!");
18455 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_temporary_failure();
18456 return nativeResponseValue;
18458 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_permanent_failure(void);
18460 export function ChannelMonitorUpdateErr_permanent_failure(): ChannelMonitorUpdateErr {
18461 if(!isWasmInitialized) {
18462 throw new Error("initializeWasm() must be awaited first!");
18464 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_permanent_failure();
18465 return nativeResponseValue;
18467 // void Watch_free(struct LDKWatch this_ptr);
18469 export function Watch_free(this_ptr: bigint): void {
18470 if(!isWasmInitialized) {
18471 throw new Error("initializeWasm() must be awaited first!");
18473 const nativeResponseValue = wasm.TS_Watch_free(this_ptr);
18474 // debug statements here
18476 // void Filter_free(struct LDKFilter this_ptr);
18478 export function Filter_free(this_ptr: bigint): void {
18479 if(!isWasmInitialized) {
18480 throw new Error("initializeWasm() must be awaited first!");
18482 const nativeResponseValue = wasm.TS_Filter_free(this_ptr);
18483 // debug statements here
18485 // void WatchedOutput_free(struct LDKWatchedOutput this_obj);
18487 export function WatchedOutput_free(this_obj: bigint): void {
18488 if(!isWasmInitialized) {
18489 throw new Error("initializeWasm() must be awaited first!");
18491 const nativeResponseValue = wasm.TS_WatchedOutput_free(this_obj);
18492 // debug statements here
18494 // struct LDKThirtyTwoBytes WatchedOutput_get_block_hash(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
18496 export function WatchedOutput_get_block_hash(this_ptr: bigint): number {
18497 if(!isWasmInitialized) {
18498 throw new Error("initializeWasm() must be awaited first!");
18500 const nativeResponseValue = wasm.TS_WatchedOutput_get_block_hash(this_ptr);
18501 return nativeResponseValue;
18503 // void WatchedOutput_set_block_hash(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18505 export function WatchedOutput_set_block_hash(this_ptr: bigint, val: number): void {
18506 if(!isWasmInitialized) {
18507 throw new Error("initializeWasm() must be awaited first!");
18509 const nativeResponseValue = wasm.TS_WatchedOutput_set_block_hash(this_ptr, val);
18510 // debug statements here
18512 // struct LDKOutPoint WatchedOutput_get_outpoint(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
18514 export function WatchedOutput_get_outpoint(this_ptr: bigint): bigint {
18515 if(!isWasmInitialized) {
18516 throw new Error("initializeWasm() must be awaited first!");
18518 const nativeResponseValue = wasm.TS_WatchedOutput_get_outpoint(this_ptr);
18519 return nativeResponseValue;
18521 // void WatchedOutput_set_outpoint(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
18523 export function WatchedOutput_set_outpoint(this_ptr: bigint, val: bigint): void {
18524 if(!isWasmInitialized) {
18525 throw new Error("initializeWasm() must be awaited first!");
18527 const nativeResponseValue = wasm.TS_WatchedOutput_set_outpoint(this_ptr, val);
18528 // debug statements here
18530 // struct LDKu8slice WatchedOutput_get_script_pubkey(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
18532 export function WatchedOutput_get_script_pubkey(this_ptr: bigint): number {
18533 if(!isWasmInitialized) {
18534 throw new Error("initializeWasm() must be awaited first!");
18536 const nativeResponseValue = wasm.TS_WatchedOutput_get_script_pubkey(this_ptr);
18537 return nativeResponseValue;
18539 // void WatchedOutput_set_script_pubkey(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
18541 export function WatchedOutput_set_script_pubkey(this_ptr: bigint, val: number): void {
18542 if(!isWasmInitialized) {
18543 throw new Error("initializeWasm() must be awaited first!");
18545 const nativeResponseValue = wasm.TS_WatchedOutput_set_script_pubkey(this_ptr, val);
18546 // debug statements here
18548 // MUST_USE_RES struct LDKWatchedOutput WatchedOutput_new(struct LDKThirtyTwoBytes block_hash_arg, struct LDKOutPoint outpoint_arg, struct LDKCVec_u8Z script_pubkey_arg);
18550 export function WatchedOutput_new(block_hash_arg: number, outpoint_arg: bigint, script_pubkey_arg: number): bigint {
18551 if(!isWasmInitialized) {
18552 throw new Error("initializeWasm() must be awaited first!");
18554 const nativeResponseValue = wasm.TS_WatchedOutput_new(block_hash_arg, outpoint_arg, script_pubkey_arg);
18555 return nativeResponseValue;
18557 // uint64_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg);
18559 export function WatchedOutput_clone_ptr(arg: bigint): bigint {
18560 if(!isWasmInitialized) {
18561 throw new Error("initializeWasm() must be awaited first!");
18563 const nativeResponseValue = wasm.TS_WatchedOutput_clone_ptr(arg);
18564 return nativeResponseValue;
18566 // struct LDKWatchedOutput WatchedOutput_clone(const struct LDKWatchedOutput *NONNULL_PTR orig);
18568 export function WatchedOutput_clone(orig: bigint): bigint {
18569 if(!isWasmInitialized) {
18570 throw new Error("initializeWasm() must be awaited first!");
18572 const nativeResponseValue = wasm.TS_WatchedOutput_clone(orig);
18573 return nativeResponseValue;
18575 // uint64_t WatchedOutput_hash(const struct LDKWatchedOutput *NONNULL_PTR o);
18577 export function WatchedOutput_hash(o: bigint): bigint {
18578 if(!isWasmInitialized) {
18579 throw new Error("initializeWasm() must be awaited first!");
18581 const nativeResponseValue = wasm.TS_WatchedOutput_hash(o);
18582 return nativeResponseValue;
18584 // void BroadcasterInterface_free(struct LDKBroadcasterInterface this_ptr);
18586 export function BroadcasterInterface_free(this_ptr: bigint): void {
18587 if(!isWasmInitialized) {
18588 throw new Error("initializeWasm() must be awaited first!");
18590 const nativeResponseValue = wasm.TS_BroadcasterInterface_free(this_ptr);
18591 // debug statements here
18593 // enum LDKConfirmationTarget ConfirmationTarget_clone(const enum LDKConfirmationTarget *NONNULL_PTR orig);
18595 export function ConfirmationTarget_clone(orig: bigint): ConfirmationTarget {
18596 if(!isWasmInitialized) {
18597 throw new Error("initializeWasm() must be awaited first!");
18599 const nativeResponseValue = wasm.TS_ConfirmationTarget_clone(orig);
18600 return nativeResponseValue;
18602 // enum LDKConfirmationTarget ConfirmationTarget_background(void);
18604 export function ConfirmationTarget_background(): ConfirmationTarget {
18605 if(!isWasmInitialized) {
18606 throw new Error("initializeWasm() must be awaited first!");
18608 const nativeResponseValue = wasm.TS_ConfirmationTarget_background();
18609 return nativeResponseValue;
18611 // enum LDKConfirmationTarget ConfirmationTarget_normal(void);
18613 export function ConfirmationTarget_normal(): ConfirmationTarget {
18614 if(!isWasmInitialized) {
18615 throw new Error("initializeWasm() must be awaited first!");
18617 const nativeResponseValue = wasm.TS_ConfirmationTarget_normal();
18618 return nativeResponseValue;
18620 // enum LDKConfirmationTarget ConfirmationTarget_high_priority(void);
18622 export function ConfirmationTarget_high_priority(): ConfirmationTarget {
18623 if(!isWasmInitialized) {
18624 throw new Error("initializeWasm() must be awaited first!");
18626 const nativeResponseValue = wasm.TS_ConfirmationTarget_high_priority();
18627 return nativeResponseValue;
18629 // bool ConfirmationTarget_eq(const enum LDKConfirmationTarget *NONNULL_PTR a, const enum LDKConfirmationTarget *NONNULL_PTR b);
18631 export function ConfirmationTarget_eq(a: bigint, b: bigint): boolean {
18632 if(!isWasmInitialized) {
18633 throw new Error("initializeWasm() must be awaited first!");
18635 const nativeResponseValue = wasm.TS_ConfirmationTarget_eq(a, b);
18636 return nativeResponseValue;
18638 // void FeeEstimator_free(struct LDKFeeEstimator this_ptr);
18640 export function FeeEstimator_free(this_ptr: bigint): void {
18641 if(!isWasmInitialized) {
18642 throw new Error("initializeWasm() must be awaited first!");
18644 const nativeResponseValue = wasm.TS_FeeEstimator_free(this_ptr);
18645 // debug statements here
18647 // void MonitorUpdateId_free(struct LDKMonitorUpdateId this_obj);
18649 export function MonitorUpdateId_free(this_obj: bigint): void {
18650 if(!isWasmInitialized) {
18651 throw new Error("initializeWasm() must be awaited first!");
18653 const nativeResponseValue = wasm.TS_MonitorUpdateId_free(this_obj);
18654 // debug statements here
18656 // uint64_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg);
18658 export function MonitorUpdateId_clone_ptr(arg: bigint): bigint {
18659 if(!isWasmInitialized) {
18660 throw new Error("initializeWasm() must be awaited first!");
18662 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone_ptr(arg);
18663 return nativeResponseValue;
18665 // struct LDKMonitorUpdateId MonitorUpdateId_clone(const struct LDKMonitorUpdateId *NONNULL_PTR orig);
18667 export function MonitorUpdateId_clone(orig: bigint): bigint {
18668 if(!isWasmInitialized) {
18669 throw new Error("initializeWasm() must be awaited first!");
18671 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone(orig);
18672 return nativeResponseValue;
18674 // uint64_t MonitorUpdateId_hash(const struct LDKMonitorUpdateId *NONNULL_PTR o);
18676 export function MonitorUpdateId_hash(o: bigint): bigint {
18677 if(!isWasmInitialized) {
18678 throw new Error("initializeWasm() must be awaited first!");
18680 const nativeResponseValue = wasm.TS_MonitorUpdateId_hash(o);
18681 return nativeResponseValue;
18683 // bool MonitorUpdateId_eq(const struct LDKMonitorUpdateId *NONNULL_PTR a, const struct LDKMonitorUpdateId *NONNULL_PTR b);
18685 export function MonitorUpdateId_eq(a: bigint, b: bigint): boolean {
18686 if(!isWasmInitialized) {
18687 throw new Error("initializeWasm() must be awaited first!");
18689 const nativeResponseValue = wasm.TS_MonitorUpdateId_eq(a, b);
18690 return nativeResponseValue;
18692 // void Persist_free(struct LDKPersist this_ptr);
18694 export function Persist_free(this_ptr: bigint): void {
18695 if(!isWasmInitialized) {
18696 throw new Error("initializeWasm() must be awaited first!");
18698 const nativeResponseValue = wasm.TS_Persist_free(this_ptr);
18699 // debug statements here
18701 // void LockedChannelMonitor_free(struct LDKLockedChannelMonitor this_obj);
18703 export function LockedChannelMonitor_free(this_obj: bigint): void {
18704 if(!isWasmInitialized) {
18705 throw new Error("initializeWasm() must be awaited first!");
18707 const nativeResponseValue = wasm.TS_LockedChannelMonitor_free(this_obj);
18708 // debug statements here
18710 // void ChainMonitor_free(struct LDKChainMonitor this_obj);
18712 export function ChainMonitor_free(this_obj: bigint): void {
18713 if(!isWasmInitialized) {
18714 throw new Error("initializeWasm() must be awaited first!");
18716 const nativeResponseValue = wasm.TS_ChainMonitor_free(this_obj);
18717 // debug statements here
18719 // MUST_USE_RES struct LDKChainMonitor ChainMonitor_new(struct LDKCOption_FilterZ chain_source, struct LDKBroadcasterInterface broadcaster, struct LDKLogger logger, struct LDKFeeEstimator feeest, struct LDKPersist persister);
18721 export function ChainMonitor_new(chain_source: bigint, broadcaster: bigint, logger: bigint, feeest: bigint, persister: bigint): bigint {
18722 if(!isWasmInitialized) {
18723 throw new Error("initializeWasm() must be awaited first!");
18725 const nativeResponseValue = wasm.TS_ChainMonitor_new(chain_source, broadcaster, logger, feeest, persister);
18726 return nativeResponseValue;
18728 // MUST_USE_RES struct LDKCVec_BalanceZ ChainMonitor_get_claimable_balances(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKCVec_ChannelDetailsZ ignored_channels);
18730 export function ChainMonitor_get_claimable_balances(this_arg: bigint, ignored_channels: number): number {
18731 if(!isWasmInitialized) {
18732 throw new Error("initializeWasm() must be awaited first!");
18734 const nativeResponseValue = wasm.TS_ChainMonitor_get_claimable_balances(this_arg, ignored_channels);
18735 return nativeResponseValue;
18737 // MUST_USE_RES struct LDKCResult_LockedChannelMonitorNoneZ ChainMonitor_get_monitor(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo);
18739 export function ChainMonitor_get_monitor(this_arg: bigint, funding_txo: bigint): bigint {
18740 if(!isWasmInitialized) {
18741 throw new Error("initializeWasm() must be awaited first!");
18743 const nativeResponseValue = wasm.TS_ChainMonitor_get_monitor(this_arg, funding_txo);
18744 return nativeResponseValue;
18746 // MUST_USE_RES struct LDKCVec_OutPointZ ChainMonitor_list_monitors(const struct LDKChainMonitor *NONNULL_PTR this_arg);
18748 export function ChainMonitor_list_monitors(this_arg: bigint): number {
18749 if(!isWasmInitialized) {
18750 throw new Error("initializeWasm() must be awaited first!");
18752 const nativeResponseValue = wasm.TS_ChainMonitor_list_monitors(this_arg);
18753 return nativeResponseValue;
18755 // 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);
18757 export function ChainMonitor_channel_monitor_updated(this_arg: bigint, funding_txo: bigint, completed_update_id: bigint): bigint {
18758 if(!isWasmInitialized) {
18759 throw new Error("initializeWasm() must be awaited first!");
18761 const nativeResponseValue = wasm.TS_ChainMonitor_channel_monitor_updated(this_arg, funding_txo, completed_update_id);
18762 return nativeResponseValue;
18764 // struct LDKListen ChainMonitor_as_Listen(const struct LDKChainMonitor *NONNULL_PTR this_arg);
18766 export function ChainMonitor_as_Listen(this_arg: bigint): bigint {
18767 if(!isWasmInitialized) {
18768 throw new Error("initializeWasm() must be awaited first!");
18770 const nativeResponseValue = wasm.TS_ChainMonitor_as_Listen(this_arg);
18771 return nativeResponseValue;
18773 // struct LDKConfirm ChainMonitor_as_Confirm(const struct LDKChainMonitor *NONNULL_PTR this_arg);
18775 export function ChainMonitor_as_Confirm(this_arg: bigint): bigint {
18776 if(!isWasmInitialized) {
18777 throw new Error("initializeWasm() must be awaited first!");
18779 const nativeResponseValue = wasm.TS_ChainMonitor_as_Confirm(this_arg);
18780 return nativeResponseValue;
18782 // struct LDKWatch ChainMonitor_as_Watch(const struct LDKChainMonitor *NONNULL_PTR this_arg);
18784 export function ChainMonitor_as_Watch(this_arg: bigint): bigint {
18785 if(!isWasmInitialized) {
18786 throw new Error("initializeWasm() must be awaited first!");
18788 const nativeResponseValue = wasm.TS_ChainMonitor_as_Watch(this_arg);
18789 return nativeResponseValue;
18791 // struct LDKEventsProvider ChainMonitor_as_EventsProvider(const struct LDKChainMonitor *NONNULL_PTR this_arg);
18793 export function ChainMonitor_as_EventsProvider(this_arg: bigint): bigint {
18794 if(!isWasmInitialized) {
18795 throw new Error("initializeWasm() must be awaited first!");
18797 const nativeResponseValue = wasm.TS_ChainMonitor_as_EventsProvider(this_arg);
18798 return nativeResponseValue;
18800 // void ChannelMonitorUpdate_free(struct LDKChannelMonitorUpdate this_obj);
18802 export function ChannelMonitorUpdate_free(this_obj: bigint): void {
18803 if(!isWasmInitialized) {
18804 throw new Error("initializeWasm() must be awaited first!");
18806 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_free(this_obj);
18807 // debug statements here
18809 // uint64_t ChannelMonitorUpdate_get_update_id(const struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr);
18811 export function ChannelMonitorUpdate_get_update_id(this_ptr: bigint): bigint {
18812 if(!isWasmInitialized) {
18813 throw new Error("initializeWasm() must be awaited first!");
18815 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_get_update_id(this_ptr);
18816 return nativeResponseValue;
18818 // void ChannelMonitorUpdate_set_update_id(struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr, uint64_t val);
18820 export function ChannelMonitorUpdate_set_update_id(this_ptr: bigint, val: bigint): void {
18821 if(!isWasmInitialized) {
18822 throw new Error("initializeWasm() must be awaited first!");
18824 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_set_update_id(this_ptr, val);
18825 // debug statements here
18827 // uint64_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg);
18829 export function ChannelMonitorUpdate_clone_ptr(arg: bigint): bigint {
18830 if(!isWasmInitialized) {
18831 throw new Error("initializeWasm() must be awaited first!");
18833 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone_ptr(arg);
18834 return nativeResponseValue;
18836 // struct LDKChannelMonitorUpdate ChannelMonitorUpdate_clone(const struct LDKChannelMonitorUpdate *NONNULL_PTR orig);
18838 export function ChannelMonitorUpdate_clone(orig: bigint): bigint {
18839 if(!isWasmInitialized) {
18840 throw new Error("initializeWasm() must be awaited first!");
18842 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone(orig);
18843 return nativeResponseValue;
18845 // struct LDKCVec_u8Z ChannelMonitorUpdate_write(const struct LDKChannelMonitorUpdate *NONNULL_PTR obj);
18847 export function ChannelMonitorUpdate_write(obj: bigint): number {
18848 if(!isWasmInitialized) {
18849 throw new Error("initializeWasm() must be awaited first!");
18851 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_write(obj);
18852 return nativeResponseValue;
18854 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ ChannelMonitorUpdate_read(struct LDKu8slice ser);
18856 export function ChannelMonitorUpdate_read(ser: number): bigint {
18857 if(!isWasmInitialized) {
18858 throw new Error("initializeWasm() must be awaited first!");
18860 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_read(ser);
18861 return nativeResponseValue;
18863 // void MonitorEvent_free(struct LDKMonitorEvent this_ptr);
18865 export function MonitorEvent_free(this_ptr: bigint): void {
18866 if(!isWasmInitialized) {
18867 throw new Error("initializeWasm() must be awaited first!");
18869 const nativeResponseValue = wasm.TS_MonitorEvent_free(this_ptr);
18870 // debug statements here
18872 // uint64_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg);
18874 export function MonitorEvent_clone_ptr(arg: bigint): bigint {
18875 if(!isWasmInitialized) {
18876 throw new Error("initializeWasm() must be awaited first!");
18878 const nativeResponseValue = wasm.TS_MonitorEvent_clone_ptr(arg);
18879 return nativeResponseValue;
18881 // struct LDKMonitorEvent MonitorEvent_clone(const struct LDKMonitorEvent *NONNULL_PTR orig);
18883 export function MonitorEvent_clone(orig: bigint): bigint {
18884 if(!isWasmInitialized) {
18885 throw new Error("initializeWasm() must be awaited first!");
18887 const nativeResponseValue = wasm.TS_MonitorEvent_clone(orig);
18888 return nativeResponseValue;
18890 // struct LDKMonitorEvent MonitorEvent_htlcevent(struct LDKHTLCUpdate a);
18892 export function MonitorEvent_htlcevent(a: bigint): bigint {
18893 if(!isWasmInitialized) {
18894 throw new Error("initializeWasm() must be awaited first!");
18896 const nativeResponseValue = wasm.TS_MonitorEvent_htlcevent(a);
18897 return nativeResponseValue;
18899 // struct LDKMonitorEvent MonitorEvent_commitment_tx_confirmed(struct LDKOutPoint a);
18901 export function MonitorEvent_commitment_tx_confirmed(a: bigint): bigint {
18902 if(!isWasmInitialized) {
18903 throw new Error("initializeWasm() must be awaited first!");
18905 const nativeResponseValue = wasm.TS_MonitorEvent_commitment_tx_confirmed(a);
18906 return nativeResponseValue;
18908 // struct LDKMonitorEvent MonitorEvent_update_completed(struct LDKOutPoint funding_txo, uint64_t monitor_update_id);
18910 export function MonitorEvent_update_completed(funding_txo: bigint, monitor_update_id: bigint): bigint {
18911 if(!isWasmInitialized) {
18912 throw new Error("initializeWasm() must be awaited first!");
18914 const nativeResponseValue = wasm.TS_MonitorEvent_update_completed(funding_txo, monitor_update_id);
18915 return nativeResponseValue;
18917 // struct LDKMonitorEvent MonitorEvent_update_failed(struct LDKOutPoint a);
18919 export function MonitorEvent_update_failed(a: bigint): bigint {
18920 if(!isWasmInitialized) {
18921 throw new Error("initializeWasm() must be awaited first!");
18923 const nativeResponseValue = wasm.TS_MonitorEvent_update_failed(a);
18924 return nativeResponseValue;
18926 // struct LDKCVec_u8Z MonitorEvent_write(const struct LDKMonitorEvent *NONNULL_PTR obj);
18928 export function MonitorEvent_write(obj: bigint): number {
18929 if(!isWasmInitialized) {
18930 throw new Error("initializeWasm() must be awaited first!");
18932 const nativeResponseValue = wasm.TS_MonitorEvent_write(obj);
18933 return nativeResponseValue;
18935 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ MonitorEvent_read(struct LDKu8slice ser);
18937 export function MonitorEvent_read(ser: number): bigint {
18938 if(!isWasmInitialized) {
18939 throw new Error("initializeWasm() must be awaited first!");
18941 const nativeResponseValue = wasm.TS_MonitorEvent_read(ser);
18942 return nativeResponseValue;
18944 // void HTLCUpdate_free(struct LDKHTLCUpdate this_obj);
18946 export function HTLCUpdate_free(this_obj: bigint): void {
18947 if(!isWasmInitialized) {
18948 throw new Error("initializeWasm() must be awaited first!");
18950 const nativeResponseValue = wasm.TS_HTLCUpdate_free(this_obj);
18951 // debug statements here
18953 // uint64_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg);
18955 export function HTLCUpdate_clone_ptr(arg: bigint): bigint {
18956 if(!isWasmInitialized) {
18957 throw new Error("initializeWasm() must be awaited first!");
18959 const nativeResponseValue = wasm.TS_HTLCUpdate_clone_ptr(arg);
18960 return nativeResponseValue;
18962 // struct LDKHTLCUpdate HTLCUpdate_clone(const struct LDKHTLCUpdate *NONNULL_PTR orig);
18964 export function HTLCUpdate_clone(orig: bigint): bigint {
18965 if(!isWasmInitialized) {
18966 throw new Error("initializeWasm() must be awaited first!");
18968 const nativeResponseValue = wasm.TS_HTLCUpdate_clone(orig);
18969 return nativeResponseValue;
18971 // struct LDKCVec_u8Z HTLCUpdate_write(const struct LDKHTLCUpdate *NONNULL_PTR obj);
18973 export function HTLCUpdate_write(obj: bigint): number {
18974 if(!isWasmInitialized) {
18975 throw new Error("initializeWasm() must be awaited first!");
18977 const nativeResponseValue = wasm.TS_HTLCUpdate_write(obj);
18978 return nativeResponseValue;
18980 // struct LDKCResult_HTLCUpdateDecodeErrorZ HTLCUpdate_read(struct LDKu8slice ser);
18982 export function HTLCUpdate_read(ser: number): bigint {
18983 if(!isWasmInitialized) {
18984 throw new Error("initializeWasm() must be awaited first!");
18986 const nativeResponseValue = wasm.TS_HTLCUpdate_read(ser);
18987 return nativeResponseValue;
18989 // void Balance_free(struct LDKBalance this_ptr);
18991 export function Balance_free(this_ptr: bigint): void {
18992 if(!isWasmInitialized) {
18993 throw new Error("initializeWasm() must be awaited first!");
18995 const nativeResponseValue = wasm.TS_Balance_free(this_ptr);
18996 // debug statements here
18998 // uint64_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg);
19000 export function Balance_clone_ptr(arg: bigint): bigint {
19001 if(!isWasmInitialized) {
19002 throw new Error("initializeWasm() must be awaited first!");
19004 const nativeResponseValue = wasm.TS_Balance_clone_ptr(arg);
19005 return nativeResponseValue;
19007 // struct LDKBalance Balance_clone(const struct LDKBalance *NONNULL_PTR orig);
19009 export function Balance_clone(orig: bigint): bigint {
19010 if(!isWasmInitialized) {
19011 throw new Error("initializeWasm() must be awaited first!");
19013 const nativeResponseValue = wasm.TS_Balance_clone(orig);
19014 return nativeResponseValue;
19016 // struct LDKBalance Balance_claimable_on_channel_close(uint64_t claimable_amount_satoshis);
19018 export function Balance_claimable_on_channel_close(claimable_amount_satoshis: bigint): bigint {
19019 if(!isWasmInitialized) {
19020 throw new Error("initializeWasm() must be awaited first!");
19022 const nativeResponseValue = wasm.TS_Balance_claimable_on_channel_close(claimable_amount_satoshis);
19023 return nativeResponseValue;
19025 // struct LDKBalance Balance_claimable_awaiting_confirmations(uint64_t claimable_amount_satoshis, uint32_t confirmation_height);
19027 export function Balance_claimable_awaiting_confirmations(claimable_amount_satoshis: bigint, confirmation_height: number): bigint {
19028 if(!isWasmInitialized) {
19029 throw new Error("initializeWasm() must be awaited first!");
19031 const nativeResponseValue = wasm.TS_Balance_claimable_awaiting_confirmations(claimable_amount_satoshis, confirmation_height);
19032 return nativeResponseValue;
19034 // struct LDKBalance Balance_contentious_claimable(uint64_t claimable_amount_satoshis, uint32_t timeout_height);
19036 export function Balance_contentious_claimable(claimable_amount_satoshis: bigint, timeout_height: number): bigint {
19037 if(!isWasmInitialized) {
19038 throw new Error("initializeWasm() must be awaited first!");
19040 const nativeResponseValue = wasm.TS_Balance_contentious_claimable(claimable_amount_satoshis, timeout_height);
19041 return nativeResponseValue;
19043 // struct LDKBalance Balance_maybe_timeout_claimable_htlc(uint64_t claimable_amount_satoshis, uint32_t claimable_height);
19045 export function Balance_maybe_timeout_claimable_htlc(claimable_amount_satoshis: bigint, claimable_height: number): bigint {
19046 if(!isWasmInitialized) {
19047 throw new Error("initializeWasm() must be awaited first!");
19049 const nativeResponseValue = wasm.TS_Balance_maybe_timeout_claimable_htlc(claimable_amount_satoshis, claimable_height);
19050 return nativeResponseValue;
19052 // struct LDKBalance Balance_maybe_preimage_claimable_htlc(uint64_t claimable_amount_satoshis, uint32_t expiry_height);
19054 export function Balance_maybe_preimage_claimable_htlc(claimable_amount_satoshis: bigint, expiry_height: number): bigint {
19055 if(!isWasmInitialized) {
19056 throw new Error("initializeWasm() must be awaited first!");
19058 const nativeResponseValue = wasm.TS_Balance_maybe_preimage_claimable_htlc(claimable_amount_satoshis, expiry_height);
19059 return nativeResponseValue;
19061 // struct LDKBalance Balance_counterparty_revoked_output_claimable(uint64_t claimable_amount_satoshis);
19063 export function Balance_counterparty_revoked_output_claimable(claimable_amount_satoshis: bigint): bigint {
19064 if(!isWasmInitialized) {
19065 throw new Error("initializeWasm() must be awaited first!");
19067 const nativeResponseValue = wasm.TS_Balance_counterparty_revoked_output_claimable(claimable_amount_satoshis);
19068 return nativeResponseValue;
19070 // bool Balance_eq(const struct LDKBalance *NONNULL_PTR a, const struct LDKBalance *NONNULL_PTR b);
19072 export function Balance_eq(a: bigint, b: bigint): boolean {
19073 if(!isWasmInitialized) {
19074 throw new Error("initializeWasm() must be awaited first!");
19076 const nativeResponseValue = wasm.TS_Balance_eq(a, b);
19077 return nativeResponseValue;
19079 // void ChannelMonitor_free(struct LDKChannelMonitor this_obj);
19081 export function ChannelMonitor_free(this_obj: bigint): void {
19082 if(!isWasmInitialized) {
19083 throw new Error("initializeWasm() must be awaited first!");
19085 const nativeResponseValue = wasm.TS_ChannelMonitor_free(this_obj);
19086 // debug statements here
19088 // uint64_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg);
19090 export function ChannelMonitor_clone_ptr(arg: bigint): bigint {
19091 if(!isWasmInitialized) {
19092 throw new Error("initializeWasm() must be awaited first!");
19094 const nativeResponseValue = wasm.TS_ChannelMonitor_clone_ptr(arg);
19095 return nativeResponseValue;
19097 // struct LDKChannelMonitor ChannelMonitor_clone(const struct LDKChannelMonitor *NONNULL_PTR orig);
19099 export function ChannelMonitor_clone(orig: bigint): bigint {
19100 if(!isWasmInitialized) {
19101 throw new Error("initializeWasm() must be awaited first!");
19103 const nativeResponseValue = wasm.TS_ChannelMonitor_clone(orig);
19104 return nativeResponseValue;
19106 // struct LDKCVec_u8Z ChannelMonitor_write(const struct LDKChannelMonitor *NONNULL_PTR obj);
19108 export function ChannelMonitor_write(obj: bigint): number {
19109 if(!isWasmInitialized) {
19110 throw new Error("initializeWasm() must be awaited first!");
19112 const nativeResponseValue = wasm.TS_ChannelMonitor_write(obj);
19113 return nativeResponseValue;
19115 // 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, struct LDKFeeEstimator fee_estimator, const struct LDKLogger *NONNULL_PTR logger);
19117 export function ChannelMonitor_update_monitor(this_arg: bigint, updates: bigint, broadcaster: bigint, fee_estimator: bigint, logger: bigint): bigint {
19118 if(!isWasmInitialized) {
19119 throw new Error("initializeWasm() must be awaited first!");
19121 const nativeResponseValue = wasm.TS_ChannelMonitor_update_monitor(this_arg, updates, broadcaster, fee_estimator, logger);
19122 return nativeResponseValue;
19124 // MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
19126 export function ChannelMonitor_get_latest_update_id(this_arg: bigint): bigint {
19127 if(!isWasmInitialized) {
19128 throw new Error("initializeWasm() must be awaited first!");
19130 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_update_id(this_arg);
19131 return nativeResponseValue;
19133 // MUST_USE_RES struct LDKC2Tuple_OutPointScriptZ ChannelMonitor_get_funding_txo(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
19135 export function ChannelMonitor_get_funding_txo(this_arg: bigint): bigint {
19136 if(!isWasmInitialized) {
19137 throw new Error("initializeWasm() must be awaited first!");
19139 const nativeResponseValue = wasm.TS_ChannelMonitor_get_funding_txo(this_arg);
19140 return nativeResponseValue;
19142 // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ChannelMonitor_get_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
19144 export function ChannelMonitor_get_outputs_to_watch(this_arg: bigint): number {
19145 if(!isWasmInitialized) {
19146 throw new Error("initializeWasm() must be awaited first!");
19148 const nativeResponseValue = wasm.TS_ChannelMonitor_get_outputs_to_watch(this_arg);
19149 return nativeResponseValue;
19151 // void ChannelMonitor_load_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKFilter *NONNULL_PTR filter);
19153 export function ChannelMonitor_load_outputs_to_watch(this_arg: bigint, filter: bigint): void {
19154 if(!isWasmInitialized) {
19155 throw new Error("initializeWasm() must be awaited first!");
19157 const nativeResponseValue = wasm.TS_ChannelMonitor_load_outputs_to_watch(this_arg, filter);
19158 // debug statements here
19160 // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
19162 export function ChannelMonitor_get_and_clear_pending_monitor_events(this_arg: bigint): number {
19163 if(!isWasmInitialized) {
19164 throw new Error("initializeWasm() must be awaited first!");
19166 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_monitor_events(this_arg);
19167 return nativeResponseValue;
19169 // MUST_USE_RES struct LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
19171 export function ChannelMonitor_get_and_clear_pending_events(this_arg: bigint): number {
19172 if(!isWasmInitialized) {
19173 throw new Error("initializeWasm() must be awaited first!");
19175 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_events(this_arg);
19176 return nativeResponseValue;
19178 // MUST_USE_RES struct LDKPublicKey ChannelMonitor_get_counterparty_node_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
19180 export function ChannelMonitor_get_counterparty_node_id(this_arg: bigint): number {
19181 if(!isWasmInitialized) {
19182 throw new Error("initializeWasm() must be awaited first!");
19184 const nativeResponseValue = wasm.TS_ChannelMonitor_get_counterparty_node_id(this_arg);
19185 return nativeResponseValue;
19187 // 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);
19189 export function ChannelMonitor_get_latest_holder_commitment_txn(this_arg: bigint, logger: bigint): number {
19190 if(!isWasmInitialized) {
19191 throw new Error("initializeWasm() must be awaited first!");
19193 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_holder_commitment_txn(this_arg, logger);
19194 return nativeResponseValue;
19196 // 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);
19198 export function ChannelMonitor_block_connected(this_arg: bigint, header: number, txdata: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
19199 if(!isWasmInitialized) {
19200 throw new Error("initializeWasm() must be awaited first!");
19202 const nativeResponseValue = wasm.TS_ChannelMonitor_block_connected(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
19203 return nativeResponseValue;
19205 // 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);
19207 export function ChannelMonitor_block_disconnected(this_arg: bigint, header: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
19208 if(!isWasmInitialized) {
19209 throw new Error("initializeWasm() must be awaited first!");
19211 const nativeResponseValue = wasm.TS_ChannelMonitor_block_disconnected(this_arg, header, height, broadcaster, fee_estimator, logger);
19212 // debug statements here
19214 // 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);
19216 export function ChannelMonitor_transactions_confirmed(this_arg: bigint, header: number, txdata: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
19217 if(!isWasmInitialized) {
19218 throw new Error("initializeWasm() must be awaited first!");
19220 const nativeResponseValue = wasm.TS_ChannelMonitor_transactions_confirmed(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
19221 return nativeResponseValue;
19223 // 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);
19225 export function ChannelMonitor_transaction_unconfirmed(this_arg: bigint, txid: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
19226 if(!isWasmInitialized) {
19227 throw new Error("initializeWasm() must be awaited first!");
19229 const nativeResponseValue = wasm.TS_ChannelMonitor_transaction_unconfirmed(this_arg, txid, broadcaster, fee_estimator, logger);
19230 // debug statements here
19232 // 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);
19234 export function ChannelMonitor_best_block_updated(this_arg: bigint, header: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
19235 if(!isWasmInitialized) {
19236 throw new Error("initializeWasm() must be awaited first!");
19238 const nativeResponseValue = wasm.TS_ChannelMonitor_best_block_updated(this_arg, header, height, broadcaster, fee_estimator, logger);
19239 return nativeResponseValue;
19241 // MUST_USE_RES struct LDKCVec_TxidZ ChannelMonitor_get_relevant_txids(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
19243 export function ChannelMonitor_get_relevant_txids(this_arg: bigint): number {
19244 if(!isWasmInitialized) {
19245 throw new Error("initializeWasm() must be awaited first!");
19247 const nativeResponseValue = wasm.TS_ChannelMonitor_get_relevant_txids(this_arg);
19248 return nativeResponseValue;
19250 // MUST_USE_RES struct LDKBestBlock ChannelMonitor_current_best_block(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
19252 export function ChannelMonitor_current_best_block(this_arg: bigint): bigint {
19253 if(!isWasmInitialized) {
19254 throw new Error("initializeWasm() must be awaited first!");
19256 const nativeResponseValue = wasm.TS_ChannelMonitor_current_best_block(this_arg);
19257 return nativeResponseValue;
19259 // MUST_USE_RES struct LDKCVec_BalanceZ ChannelMonitor_get_claimable_balances(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
19261 export function ChannelMonitor_get_claimable_balances(this_arg: bigint): number {
19262 if(!isWasmInitialized) {
19263 throw new Error("initializeWasm() must be awaited first!");
19265 const nativeResponseValue = wasm.TS_ChannelMonitor_get_claimable_balances(this_arg);
19266 return nativeResponseValue;
19268 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ C2Tuple_BlockHashChannelMonitorZ_read(struct LDKu8slice ser, const struct LDKKeysInterface *NONNULL_PTR arg);
19270 export function C2Tuple_BlockHashChannelMonitorZ_read(ser: number, arg: bigint): bigint {
19271 if(!isWasmInitialized) {
19272 throw new Error("initializeWasm() must be awaited first!");
19274 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_read(ser, arg);
19275 return nativeResponseValue;
19277 // void OutPoint_free(struct LDKOutPoint this_obj);
19279 export function OutPoint_free(this_obj: bigint): void {
19280 if(!isWasmInitialized) {
19281 throw new Error("initializeWasm() must be awaited first!");
19283 const nativeResponseValue = wasm.TS_OutPoint_free(this_obj);
19284 // debug statements here
19286 // const uint8_t (*OutPoint_get_txid(const struct LDKOutPoint *NONNULL_PTR this_ptr))[32];
19288 export function OutPoint_get_txid(this_ptr: bigint): number {
19289 if(!isWasmInitialized) {
19290 throw new Error("initializeWasm() must be awaited first!");
19292 const nativeResponseValue = wasm.TS_OutPoint_get_txid(this_ptr);
19293 return nativeResponseValue;
19295 // void OutPoint_set_txid(struct LDKOutPoint *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19297 export function OutPoint_set_txid(this_ptr: bigint, val: number): void {
19298 if(!isWasmInitialized) {
19299 throw new Error("initializeWasm() must be awaited first!");
19301 const nativeResponseValue = wasm.TS_OutPoint_set_txid(this_ptr, val);
19302 // debug statements here
19304 // uint16_t OutPoint_get_index(const struct LDKOutPoint *NONNULL_PTR this_ptr);
19306 export function OutPoint_get_index(this_ptr: bigint): number {
19307 if(!isWasmInitialized) {
19308 throw new Error("initializeWasm() must be awaited first!");
19310 const nativeResponseValue = wasm.TS_OutPoint_get_index(this_ptr);
19311 return nativeResponseValue;
19313 // void OutPoint_set_index(struct LDKOutPoint *NONNULL_PTR this_ptr, uint16_t val);
19315 export function OutPoint_set_index(this_ptr: bigint, val: number): void {
19316 if(!isWasmInitialized) {
19317 throw new Error("initializeWasm() must be awaited first!");
19319 const nativeResponseValue = wasm.TS_OutPoint_set_index(this_ptr, val);
19320 // debug statements here
19322 // MUST_USE_RES struct LDKOutPoint OutPoint_new(struct LDKThirtyTwoBytes txid_arg, uint16_t index_arg);
19324 export function OutPoint_new(txid_arg: number, index_arg: number): bigint {
19325 if(!isWasmInitialized) {
19326 throw new Error("initializeWasm() must be awaited first!");
19328 const nativeResponseValue = wasm.TS_OutPoint_new(txid_arg, index_arg);
19329 return nativeResponseValue;
19331 // uint64_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg);
19333 export function OutPoint_clone_ptr(arg: bigint): bigint {
19334 if(!isWasmInitialized) {
19335 throw new Error("initializeWasm() must be awaited first!");
19337 const nativeResponseValue = wasm.TS_OutPoint_clone_ptr(arg);
19338 return nativeResponseValue;
19340 // struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig);
19342 export function OutPoint_clone(orig: bigint): bigint {
19343 if(!isWasmInitialized) {
19344 throw new Error("initializeWasm() must be awaited first!");
19346 const nativeResponseValue = wasm.TS_OutPoint_clone(orig);
19347 return nativeResponseValue;
19349 // bool OutPoint_eq(const struct LDKOutPoint *NONNULL_PTR a, const struct LDKOutPoint *NONNULL_PTR b);
19351 export function OutPoint_eq(a: bigint, b: bigint): boolean {
19352 if(!isWasmInitialized) {
19353 throw new Error("initializeWasm() must be awaited first!");
19355 const nativeResponseValue = wasm.TS_OutPoint_eq(a, b);
19356 return nativeResponseValue;
19358 // uint64_t OutPoint_hash(const struct LDKOutPoint *NONNULL_PTR o);
19360 export function OutPoint_hash(o: bigint): bigint {
19361 if(!isWasmInitialized) {
19362 throw new Error("initializeWasm() must be awaited first!");
19364 const nativeResponseValue = wasm.TS_OutPoint_hash(o);
19365 return nativeResponseValue;
19367 // MUST_USE_RES struct LDKThirtyTwoBytes OutPoint_to_channel_id(const struct LDKOutPoint *NONNULL_PTR this_arg);
19369 export function OutPoint_to_channel_id(this_arg: bigint): number {
19370 if(!isWasmInitialized) {
19371 throw new Error("initializeWasm() must be awaited first!");
19373 const nativeResponseValue = wasm.TS_OutPoint_to_channel_id(this_arg);
19374 return nativeResponseValue;
19376 // struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj);
19378 export function OutPoint_write(obj: bigint): number {
19379 if(!isWasmInitialized) {
19380 throw new Error("initializeWasm() must be awaited first!");
19382 const nativeResponseValue = wasm.TS_OutPoint_write(obj);
19383 return nativeResponseValue;
19385 // struct LDKCResult_OutPointDecodeErrorZ OutPoint_read(struct LDKu8slice ser);
19387 export function OutPoint_read(ser: number): bigint {
19388 if(!isWasmInitialized) {
19389 throw new Error("initializeWasm() must be awaited first!");
19391 const nativeResponseValue = wasm.TS_OutPoint_read(ser);
19392 return nativeResponseValue;
19394 // void DelayedPaymentOutputDescriptor_free(struct LDKDelayedPaymentOutputDescriptor this_obj);
19396 export function DelayedPaymentOutputDescriptor_free(this_obj: bigint): void {
19397 if(!isWasmInitialized) {
19398 throw new Error("initializeWasm() must be awaited first!");
19400 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_free(this_obj);
19401 // debug statements here
19403 // struct LDKOutPoint DelayedPaymentOutputDescriptor_get_outpoint(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
19405 export function DelayedPaymentOutputDescriptor_get_outpoint(this_ptr: bigint): bigint {
19406 if(!isWasmInitialized) {
19407 throw new Error("initializeWasm() must be awaited first!");
19409 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_outpoint(this_ptr);
19410 return nativeResponseValue;
19412 // void DelayedPaymentOutputDescriptor_set_outpoint(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
19414 export function DelayedPaymentOutputDescriptor_set_outpoint(this_ptr: bigint, val: bigint): void {
19415 if(!isWasmInitialized) {
19416 throw new Error("initializeWasm() must be awaited first!");
19418 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_outpoint(this_ptr, val);
19419 // debug statements here
19421 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_per_commitment_point(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
19423 export function DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr: bigint): number {
19424 if(!isWasmInitialized) {
19425 throw new Error("initializeWasm() must be awaited first!");
19427 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr);
19428 return nativeResponseValue;
19430 // void DelayedPaymentOutputDescriptor_set_per_commitment_point(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19432 export function DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr: bigint, val: number): void {
19433 if(!isWasmInitialized) {
19434 throw new Error("initializeWasm() must be awaited first!");
19436 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr, val);
19437 // debug statements here
19439 // uint16_t DelayedPaymentOutputDescriptor_get_to_self_delay(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
19441 export function DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr: bigint): number {
19442 if(!isWasmInitialized) {
19443 throw new Error("initializeWasm() must be awaited first!");
19445 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr);
19446 return nativeResponseValue;
19448 // void DelayedPaymentOutputDescriptor_set_to_self_delay(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint16_t val);
19450 export function DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr: bigint, val: number): void {
19451 if(!isWasmInitialized) {
19452 throw new Error("initializeWasm() must be awaited first!");
19454 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr, val);
19455 // debug statements here
19457 // struct LDKTxOut DelayedPaymentOutputDescriptor_get_output(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
19459 export function DelayedPaymentOutputDescriptor_get_output(this_ptr: bigint): bigint {
19460 if(!isWasmInitialized) {
19461 throw new Error("initializeWasm() must be awaited first!");
19463 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_output(this_ptr);
19464 return nativeResponseValue;
19466 // void DelayedPaymentOutputDescriptor_set_output(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
19468 export function DelayedPaymentOutputDescriptor_set_output(this_ptr: bigint, val: bigint): void {
19469 if(!isWasmInitialized) {
19470 throw new Error("initializeWasm() must be awaited first!");
19472 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_output(this_ptr, val);
19473 // debug statements here
19475 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_revocation_pubkey(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
19477 export function DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr: bigint): number {
19478 if(!isWasmInitialized) {
19479 throw new Error("initializeWasm() must be awaited first!");
19481 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr);
19482 return nativeResponseValue;
19484 // void DelayedPaymentOutputDescriptor_set_revocation_pubkey(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19486 export function DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr: bigint, val: number): void {
19487 if(!isWasmInitialized) {
19488 throw new Error("initializeWasm() must be awaited first!");
19490 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr, val);
19491 // debug statements here
19493 // const uint8_t (*DelayedPaymentOutputDescriptor_get_channel_keys_id(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
19495 export function DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr: bigint): number {
19496 if(!isWasmInitialized) {
19497 throw new Error("initializeWasm() must be awaited first!");
19499 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
19500 return nativeResponseValue;
19502 // void DelayedPaymentOutputDescriptor_set_channel_keys_id(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19504 export function DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr: bigint, val: number): void {
19505 if(!isWasmInitialized) {
19506 throw new Error("initializeWasm() must be awaited first!");
19508 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
19509 // debug statements here
19511 // uint64_t DelayedPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
19513 export function DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: bigint): bigint {
19514 if(!isWasmInitialized) {
19515 throw new Error("initializeWasm() must be awaited first!");
19517 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
19518 return nativeResponseValue;
19520 // void DelayedPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
19522 export function DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
19523 if(!isWasmInitialized) {
19524 throw new Error("initializeWasm() must be awaited first!");
19526 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
19527 // debug statements here
19529 // 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);
19531 export function DelayedPaymentOutputDescriptor_new(outpoint_arg: bigint, per_commitment_point_arg: number, to_self_delay_arg: number, output_arg: bigint, revocation_pubkey_arg: number, channel_keys_id_arg: number, channel_value_satoshis_arg: bigint): bigint {
19532 if(!isWasmInitialized) {
19533 throw new Error("initializeWasm() must be awaited first!");
19535 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);
19536 return nativeResponseValue;
19538 // uint64_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg);
19540 export function DelayedPaymentOutputDescriptor_clone_ptr(arg: bigint): bigint {
19541 if(!isWasmInitialized) {
19542 throw new Error("initializeWasm() must be awaited first!");
19544 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone_ptr(arg);
19545 return nativeResponseValue;
19547 // struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_clone(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR orig);
19549 export function DelayedPaymentOutputDescriptor_clone(orig: bigint): bigint {
19550 if(!isWasmInitialized) {
19551 throw new Error("initializeWasm() must be awaited first!");
19553 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone(orig);
19554 return nativeResponseValue;
19556 // struct LDKCVec_u8Z DelayedPaymentOutputDescriptor_write(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR obj);
19558 export function DelayedPaymentOutputDescriptor_write(obj: bigint): number {
19559 if(!isWasmInitialized) {
19560 throw new Error("initializeWasm() must be awaited first!");
19562 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_write(obj);
19563 return nativeResponseValue;
19565 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ DelayedPaymentOutputDescriptor_read(struct LDKu8slice ser);
19567 export function DelayedPaymentOutputDescriptor_read(ser: number): bigint {
19568 if(!isWasmInitialized) {
19569 throw new Error("initializeWasm() must be awaited first!");
19571 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_read(ser);
19572 return nativeResponseValue;
19574 // void StaticPaymentOutputDescriptor_free(struct LDKStaticPaymentOutputDescriptor this_obj);
19576 export function StaticPaymentOutputDescriptor_free(this_obj: bigint): void {
19577 if(!isWasmInitialized) {
19578 throw new Error("initializeWasm() must be awaited first!");
19580 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_free(this_obj);
19581 // debug statements here
19583 // struct LDKOutPoint StaticPaymentOutputDescriptor_get_outpoint(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
19585 export function StaticPaymentOutputDescriptor_get_outpoint(this_ptr: bigint): bigint {
19586 if(!isWasmInitialized) {
19587 throw new Error("initializeWasm() must be awaited first!");
19589 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_outpoint(this_ptr);
19590 return nativeResponseValue;
19592 // void StaticPaymentOutputDescriptor_set_outpoint(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
19594 export function StaticPaymentOutputDescriptor_set_outpoint(this_ptr: bigint, val: bigint): void {
19595 if(!isWasmInitialized) {
19596 throw new Error("initializeWasm() must be awaited first!");
19598 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_outpoint(this_ptr, val);
19599 // debug statements here
19601 // struct LDKTxOut StaticPaymentOutputDescriptor_get_output(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
19603 export function StaticPaymentOutputDescriptor_get_output(this_ptr: bigint): bigint {
19604 if(!isWasmInitialized) {
19605 throw new Error("initializeWasm() must be awaited first!");
19607 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_output(this_ptr);
19608 return nativeResponseValue;
19610 // void StaticPaymentOutputDescriptor_set_output(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
19612 export function StaticPaymentOutputDescriptor_set_output(this_ptr: bigint, val: bigint): void {
19613 if(!isWasmInitialized) {
19614 throw new Error("initializeWasm() must be awaited first!");
19616 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_output(this_ptr, val);
19617 // debug statements here
19619 // const uint8_t (*StaticPaymentOutputDescriptor_get_channel_keys_id(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
19621 export function StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr: bigint): number {
19622 if(!isWasmInitialized) {
19623 throw new Error("initializeWasm() must be awaited first!");
19625 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
19626 return nativeResponseValue;
19628 // void StaticPaymentOutputDescriptor_set_channel_keys_id(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19630 export function StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr: bigint, val: number): void {
19631 if(!isWasmInitialized) {
19632 throw new Error("initializeWasm() must be awaited first!");
19634 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
19635 // debug statements here
19637 // uint64_t StaticPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
19639 export function StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: bigint): bigint {
19640 if(!isWasmInitialized) {
19641 throw new Error("initializeWasm() must be awaited first!");
19643 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
19644 return nativeResponseValue;
19646 // void StaticPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
19648 export function StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
19649 if(!isWasmInitialized) {
19650 throw new Error("initializeWasm() must be awaited first!");
19652 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
19653 // debug statements here
19655 // 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);
19657 export function StaticPaymentOutputDescriptor_new(outpoint_arg: bigint, output_arg: bigint, channel_keys_id_arg: number, channel_value_satoshis_arg: bigint): bigint {
19658 if(!isWasmInitialized) {
19659 throw new Error("initializeWasm() must be awaited first!");
19661 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_new(outpoint_arg, output_arg, channel_keys_id_arg, channel_value_satoshis_arg);
19662 return nativeResponseValue;
19664 // uint64_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg);
19666 export function StaticPaymentOutputDescriptor_clone_ptr(arg: bigint): bigint {
19667 if(!isWasmInitialized) {
19668 throw new Error("initializeWasm() must be awaited first!");
19670 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone_ptr(arg);
19671 return nativeResponseValue;
19673 // struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_clone(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR orig);
19675 export function StaticPaymentOutputDescriptor_clone(orig: bigint): bigint {
19676 if(!isWasmInitialized) {
19677 throw new Error("initializeWasm() must be awaited first!");
19679 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone(orig);
19680 return nativeResponseValue;
19682 // struct LDKCVec_u8Z StaticPaymentOutputDescriptor_write(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR obj);
19684 export function StaticPaymentOutputDescriptor_write(obj: bigint): number {
19685 if(!isWasmInitialized) {
19686 throw new Error("initializeWasm() must be awaited first!");
19688 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_write(obj);
19689 return nativeResponseValue;
19691 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ StaticPaymentOutputDescriptor_read(struct LDKu8slice ser);
19693 export function StaticPaymentOutputDescriptor_read(ser: number): bigint {
19694 if(!isWasmInitialized) {
19695 throw new Error("initializeWasm() must be awaited first!");
19697 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_read(ser);
19698 return nativeResponseValue;
19700 // void SpendableOutputDescriptor_free(struct LDKSpendableOutputDescriptor this_ptr);
19702 export function SpendableOutputDescriptor_free(this_ptr: bigint): void {
19703 if(!isWasmInitialized) {
19704 throw new Error("initializeWasm() must be awaited first!");
19706 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_free(this_ptr);
19707 // debug statements here
19709 // uint64_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg);
19711 export function SpendableOutputDescriptor_clone_ptr(arg: bigint): bigint {
19712 if(!isWasmInitialized) {
19713 throw new Error("initializeWasm() must be awaited first!");
19715 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone_ptr(arg);
19716 return nativeResponseValue;
19718 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_clone(const struct LDKSpendableOutputDescriptor *NONNULL_PTR orig);
19720 export function SpendableOutputDescriptor_clone(orig: bigint): bigint {
19721 if(!isWasmInitialized) {
19722 throw new Error("initializeWasm() must be awaited first!");
19724 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone(orig);
19725 return nativeResponseValue;
19727 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_output(struct LDKOutPoint outpoint, struct LDKTxOut output);
19729 export function SpendableOutputDescriptor_static_output(outpoint: bigint, output: bigint): bigint {
19730 if(!isWasmInitialized) {
19731 throw new Error("initializeWasm() must be awaited first!");
19733 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_output(outpoint, output);
19734 return nativeResponseValue;
19736 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_delayed_payment_output(struct LDKDelayedPaymentOutputDescriptor a);
19738 export function SpendableOutputDescriptor_delayed_payment_output(a: bigint): bigint {
19739 if(!isWasmInitialized) {
19740 throw new Error("initializeWasm() must be awaited first!");
19742 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_delayed_payment_output(a);
19743 return nativeResponseValue;
19745 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_payment_output(struct LDKStaticPaymentOutputDescriptor a);
19747 export function SpendableOutputDescriptor_static_payment_output(a: bigint): bigint {
19748 if(!isWasmInitialized) {
19749 throw new Error("initializeWasm() must be awaited first!");
19751 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_payment_output(a);
19752 return nativeResponseValue;
19754 // struct LDKCVec_u8Z SpendableOutputDescriptor_write(const struct LDKSpendableOutputDescriptor *NONNULL_PTR obj);
19756 export function SpendableOutputDescriptor_write(obj: bigint): number {
19757 if(!isWasmInitialized) {
19758 throw new Error("initializeWasm() must be awaited first!");
19760 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_write(obj);
19761 return nativeResponseValue;
19763 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ SpendableOutputDescriptor_read(struct LDKu8slice ser);
19765 export function SpendableOutputDescriptor_read(ser: number): bigint {
19766 if(!isWasmInitialized) {
19767 throw new Error("initializeWasm() must be awaited first!");
19769 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_read(ser);
19770 return nativeResponseValue;
19772 // void BaseSign_free(struct LDKBaseSign this_ptr);
19774 export function BaseSign_free(this_ptr: bigint): void {
19775 if(!isWasmInitialized) {
19776 throw new Error("initializeWasm() must be awaited first!");
19778 const nativeResponseValue = wasm.TS_BaseSign_free(this_ptr);
19779 // debug statements here
19781 // uint64_t Sign_clone_ptr(LDKSign *NONNULL_PTR arg);
19783 export function Sign_clone_ptr(arg: bigint): bigint {
19784 if(!isWasmInitialized) {
19785 throw new Error("initializeWasm() must be awaited first!");
19787 const nativeResponseValue = wasm.TS_Sign_clone_ptr(arg);
19788 return nativeResponseValue;
19790 // struct LDKSign Sign_clone(const struct LDKSign *NONNULL_PTR orig);
19792 export function Sign_clone(orig: bigint): bigint {
19793 if(!isWasmInitialized) {
19794 throw new Error("initializeWasm() must be awaited first!");
19796 const nativeResponseValue = wasm.TS_Sign_clone(orig);
19797 return nativeResponseValue;
19799 // void Sign_free(struct LDKSign this_ptr);
19801 export function Sign_free(this_ptr: bigint): void {
19802 if(!isWasmInitialized) {
19803 throw new Error("initializeWasm() must be awaited first!");
19805 const nativeResponseValue = wasm.TS_Sign_free(this_ptr);
19806 // debug statements here
19808 // enum LDKRecipient Recipient_clone(const enum LDKRecipient *NONNULL_PTR orig);
19810 export function Recipient_clone(orig: bigint): Recipient {
19811 if(!isWasmInitialized) {
19812 throw new Error("initializeWasm() must be awaited first!");
19814 const nativeResponseValue = wasm.TS_Recipient_clone(orig);
19815 return nativeResponseValue;
19817 // enum LDKRecipient Recipient_node(void);
19819 export function Recipient_node(): Recipient {
19820 if(!isWasmInitialized) {
19821 throw new Error("initializeWasm() must be awaited first!");
19823 const nativeResponseValue = wasm.TS_Recipient_node();
19824 return nativeResponseValue;
19826 // enum LDKRecipient Recipient_phantom_node(void);
19828 export function Recipient_phantom_node(): Recipient {
19829 if(!isWasmInitialized) {
19830 throw new Error("initializeWasm() must be awaited first!");
19832 const nativeResponseValue = wasm.TS_Recipient_phantom_node();
19833 return nativeResponseValue;
19835 // void KeysInterface_free(struct LDKKeysInterface this_ptr);
19837 export function KeysInterface_free(this_ptr: bigint): void {
19838 if(!isWasmInitialized) {
19839 throw new Error("initializeWasm() must be awaited first!");
19841 const nativeResponseValue = wasm.TS_KeysInterface_free(this_ptr);
19842 // debug statements here
19844 // void InMemorySigner_free(struct LDKInMemorySigner this_obj);
19846 export function InMemorySigner_free(this_obj: bigint): void {
19847 if(!isWasmInitialized) {
19848 throw new Error("initializeWasm() must be awaited first!");
19850 const nativeResponseValue = wasm.TS_InMemorySigner_free(this_obj);
19851 // debug statements here
19853 // const uint8_t (*InMemorySigner_get_funding_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
19855 export function InMemorySigner_get_funding_key(this_ptr: bigint): number {
19856 if(!isWasmInitialized) {
19857 throw new Error("initializeWasm() must be awaited first!");
19859 const nativeResponseValue = wasm.TS_InMemorySigner_get_funding_key(this_ptr);
19860 return nativeResponseValue;
19862 // void InMemorySigner_set_funding_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
19864 export function InMemorySigner_set_funding_key(this_ptr: bigint, val: number): void {
19865 if(!isWasmInitialized) {
19866 throw new Error("initializeWasm() must be awaited first!");
19868 const nativeResponseValue = wasm.TS_InMemorySigner_set_funding_key(this_ptr, val);
19869 // debug statements here
19871 // const uint8_t (*InMemorySigner_get_revocation_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
19873 export function InMemorySigner_get_revocation_base_key(this_ptr: bigint): number {
19874 if(!isWasmInitialized) {
19875 throw new Error("initializeWasm() must be awaited first!");
19877 const nativeResponseValue = wasm.TS_InMemorySigner_get_revocation_base_key(this_ptr);
19878 return nativeResponseValue;
19880 // void InMemorySigner_set_revocation_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
19882 export function InMemorySigner_set_revocation_base_key(this_ptr: bigint, val: number): void {
19883 if(!isWasmInitialized) {
19884 throw new Error("initializeWasm() must be awaited first!");
19886 const nativeResponseValue = wasm.TS_InMemorySigner_set_revocation_base_key(this_ptr, val);
19887 // debug statements here
19889 // const uint8_t (*InMemorySigner_get_payment_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
19891 export function InMemorySigner_get_payment_key(this_ptr: bigint): number {
19892 if(!isWasmInitialized) {
19893 throw new Error("initializeWasm() must be awaited first!");
19895 const nativeResponseValue = wasm.TS_InMemorySigner_get_payment_key(this_ptr);
19896 return nativeResponseValue;
19898 // void InMemorySigner_set_payment_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
19900 export function InMemorySigner_set_payment_key(this_ptr: bigint, val: number): void {
19901 if(!isWasmInitialized) {
19902 throw new Error("initializeWasm() must be awaited first!");
19904 const nativeResponseValue = wasm.TS_InMemorySigner_set_payment_key(this_ptr, val);
19905 // debug statements here
19907 // const uint8_t (*InMemorySigner_get_delayed_payment_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
19909 export function InMemorySigner_get_delayed_payment_base_key(this_ptr: bigint): number {
19910 if(!isWasmInitialized) {
19911 throw new Error("initializeWasm() must be awaited first!");
19913 const nativeResponseValue = wasm.TS_InMemorySigner_get_delayed_payment_base_key(this_ptr);
19914 return nativeResponseValue;
19916 // void InMemorySigner_set_delayed_payment_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
19918 export function InMemorySigner_set_delayed_payment_base_key(this_ptr: bigint, val: number): void {
19919 if(!isWasmInitialized) {
19920 throw new Error("initializeWasm() must be awaited first!");
19922 const nativeResponseValue = wasm.TS_InMemorySigner_set_delayed_payment_base_key(this_ptr, val);
19923 // debug statements here
19925 // const uint8_t (*InMemorySigner_get_htlc_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
19927 export function InMemorySigner_get_htlc_base_key(this_ptr: bigint): number {
19928 if(!isWasmInitialized) {
19929 throw new Error("initializeWasm() must be awaited first!");
19931 const nativeResponseValue = wasm.TS_InMemorySigner_get_htlc_base_key(this_ptr);
19932 return nativeResponseValue;
19934 // void InMemorySigner_set_htlc_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
19936 export function InMemorySigner_set_htlc_base_key(this_ptr: bigint, val: number): void {
19937 if(!isWasmInitialized) {
19938 throw new Error("initializeWasm() must be awaited first!");
19940 const nativeResponseValue = wasm.TS_InMemorySigner_set_htlc_base_key(this_ptr, val);
19941 // debug statements here
19943 // const uint8_t (*InMemorySigner_get_commitment_seed(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
19945 export function InMemorySigner_get_commitment_seed(this_ptr: bigint): number {
19946 if(!isWasmInitialized) {
19947 throw new Error("initializeWasm() must be awaited first!");
19949 const nativeResponseValue = wasm.TS_InMemorySigner_get_commitment_seed(this_ptr);
19950 return nativeResponseValue;
19952 // void InMemorySigner_set_commitment_seed(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19954 export function InMemorySigner_set_commitment_seed(this_ptr: bigint, val: number): void {
19955 if(!isWasmInitialized) {
19956 throw new Error("initializeWasm() must be awaited first!");
19958 const nativeResponseValue = wasm.TS_InMemorySigner_set_commitment_seed(this_ptr, val);
19959 // debug statements here
19961 // uint64_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg);
19963 export function InMemorySigner_clone_ptr(arg: bigint): bigint {
19964 if(!isWasmInitialized) {
19965 throw new Error("initializeWasm() must be awaited first!");
19967 const nativeResponseValue = wasm.TS_InMemorySigner_clone_ptr(arg);
19968 return nativeResponseValue;
19970 // struct LDKInMemorySigner InMemorySigner_clone(const struct LDKInMemorySigner *NONNULL_PTR orig);
19972 export function InMemorySigner_clone(orig: bigint): bigint {
19973 if(!isWasmInitialized) {
19974 throw new Error("initializeWasm() must be awaited first!");
19976 const nativeResponseValue = wasm.TS_InMemorySigner_clone(orig);
19977 return nativeResponseValue;
19979 // 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);
19981 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): bigint {
19982 if(!isWasmInitialized) {
19983 throw new Error("initializeWasm() must be awaited first!");
19985 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);
19986 return nativeResponseValue;
19988 // MUST_USE_RES struct LDKChannelPublicKeys InMemorySigner_counterparty_pubkeys(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19990 export function InMemorySigner_counterparty_pubkeys(this_arg: bigint): bigint {
19991 if(!isWasmInitialized) {
19992 throw new Error("initializeWasm() must be awaited first!");
19994 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_pubkeys(this_arg);
19995 return nativeResponseValue;
19997 // MUST_USE_RES uint16_t InMemorySigner_counterparty_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19999 export function InMemorySigner_counterparty_selected_contest_delay(this_arg: bigint): number {
20000 if(!isWasmInitialized) {
20001 throw new Error("initializeWasm() must be awaited first!");
20003 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_selected_contest_delay(this_arg);
20004 return nativeResponseValue;
20006 // MUST_USE_RES uint16_t InMemorySigner_holder_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
20008 export function InMemorySigner_holder_selected_contest_delay(this_arg: bigint): number {
20009 if(!isWasmInitialized) {
20010 throw new Error("initializeWasm() must be awaited first!");
20012 const nativeResponseValue = wasm.TS_InMemorySigner_holder_selected_contest_delay(this_arg);
20013 return nativeResponseValue;
20015 // MUST_USE_RES bool InMemorySigner_is_outbound(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
20017 export function InMemorySigner_is_outbound(this_arg: bigint): boolean {
20018 if(!isWasmInitialized) {
20019 throw new Error("initializeWasm() must be awaited first!");
20021 const nativeResponseValue = wasm.TS_InMemorySigner_is_outbound(this_arg);
20022 return nativeResponseValue;
20024 // MUST_USE_RES struct LDKOutPoint InMemorySigner_funding_outpoint(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
20026 export function InMemorySigner_funding_outpoint(this_arg: bigint): bigint {
20027 if(!isWasmInitialized) {
20028 throw new Error("initializeWasm() must be awaited first!");
20030 const nativeResponseValue = wasm.TS_InMemorySigner_funding_outpoint(this_arg);
20031 return nativeResponseValue;
20033 // MUST_USE_RES struct LDKChannelTransactionParameters InMemorySigner_get_channel_parameters(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
20035 export function InMemorySigner_get_channel_parameters(this_arg: bigint): bigint {
20036 if(!isWasmInitialized) {
20037 throw new Error("initializeWasm() must be awaited first!");
20039 const nativeResponseValue = wasm.TS_InMemorySigner_get_channel_parameters(this_arg);
20040 return nativeResponseValue;
20042 // MUST_USE_RES bool InMemorySigner_opt_anchors(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
20044 export function InMemorySigner_opt_anchors(this_arg: bigint): boolean {
20045 if(!isWasmInitialized) {
20046 throw new Error("initializeWasm() must be awaited first!");
20048 const nativeResponseValue = wasm.TS_InMemorySigner_opt_anchors(this_arg);
20049 return nativeResponseValue;
20051 // 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);
20053 export function InMemorySigner_sign_counterparty_payment_input(this_arg: bigint, spend_tx: number, input_idx: number, descriptor: bigint): bigint {
20054 if(!isWasmInitialized) {
20055 throw new Error("initializeWasm() must be awaited first!");
20057 const nativeResponseValue = wasm.TS_InMemorySigner_sign_counterparty_payment_input(this_arg, spend_tx, input_idx, descriptor);
20058 return nativeResponseValue;
20060 // 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);
20062 export function InMemorySigner_sign_dynamic_p2wsh_input(this_arg: bigint, spend_tx: number, input_idx: number, descriptor: bigint): bigint {
20063 if(!isWasmInitialized) {
20064 throw new Error("initializeWasm() must be awaited first!");
20066 const nativeResponseValue = wasm.TS_InMemorySigner_sign_dynamic_p2wsh_input(this_arg, spend_tx, input_idx, descriptor);
20067 return nativeResponseValue;
20069 // struct LDKBaseSign InMemorySigner_as_BaseSign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
20071 export function InMemorySigner_as_BaseSign(this_arg: bigint): bigint {
20072 if(!isWasmInitialized) {
20073 throw new Error("initializeWasm() must be awaited first!");
20075 const nativeResponseValue = wasm.TS_InMemorySigner_as_BaseSign(this_arg);
20076 return nativeResponseValue;
20078 // struct LDKSign InMemorySigner_as_Sign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
20080 export function InMemorySigner_as_Sign(this_arg: bigint): bigint {
20081 if(!isWasmInitialized) {
20082 throw new Error("initializeWasm() must be awaited first!");
20084 const nativeResponseValue = wasm.TS_InMemorySigner_as_Sign(this_arg);
20085 return nativeResponseValue;
20087 // struct LDKCVec_u8Z InMemorySigner_write(const struct LDKInMemorySigner *NONNULL_PTR obj);
20089 export function InMemorySigner_write(obj: bigint): number {
20090 if(!isWasmInitialized) {
20091 throw new Error("initializeWasm() must be awaited first!");
20093 const nativeResponseValue = wasm.TS_InMemorySigner_write(obj);
20094 return nativeResponseValue;
20096 // struct LDKCResult_InMemorySignerDecodeErrorZ InMemorySigner_read(struct LDKu8slice ser, struct LDKSecretKey arg);
20098 export function InMemorySigner_read(ser: number, arg: number): bigint {
20099 if(!isWasmInitialized) {
20100 throw new Error("initializeWasm() must be awaited first!");
20102 const nativeResponseValue = wasm.TS_InMemorySigner_read(ser, arg);
20103 return nativeResponseValue;
20105 // void KeysManager_free(struct LDKKeysManager this_obj);
20107 export function KeysManager_free(this_obj: bigint): void {
20108 if(!isWasmInitialized) {
20109 throw new Error("initializeWasm() must be awaited first!");
20111 const nativeResponseValue = wasm.TS_KeysManager_free(this_obj);
20112 // debug statements here
20114 // MUST_USE_RES struct LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], uint64_t starting_time_secs, uint32_t starting_time_nanos);
20116 export function KeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number): bigint {
20117 if(!isWasmInitialized) {
20118 throw new Error("initializeWasm() must be awaited first!");
20120 const nativeResponseValue = wasm.TS_KeysManager_new(seed, starting_time_secs, starting_time_nanos);
20121 return nativeResponseValue;
20123 // 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]);
20125 export function KeysManager_derive_channel_keys(this_arg: bigint, channel_value_satoshis: bigint, params: number): bigint {
20126 if(!isWasmInitialized) {
20127 throw new Error("initializeWasm() must be awaited first!");
20129 const nativeResponseValue = wasm.TS_KeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
20130 return nativeResponseValue;
20132 // 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);
20134 export function KeysManager_spend_spendable_outputs(this_arg: bigint, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): bigint {
20135 if(!isWasmInitialized) {
20136 throw new Error("initializeWasm() must be awaited first!");
20138 const nativeResponseValue = wasm.TS_KeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
20139 return nativeResponseValue;
20141 // struct LDKKeysInterface KeysManager_as_KeysInterface(const struct LDKKeysManager *NONNULL_PTR this_arg);
20143 export function KeysManager_as_KeysInterface(this_arg: bigint): bigint {
20144 if(!isWasmInitialized) {
20145 throw new Error("initializeWasm() must be awaited first!");
20147 const nativeResponseValue = wasm.TS_KeysManager_as_KeysInterface(this_arg);
20148 return nativeResponseValue;
20150 // void PhantomKeysManager_free(struct LDKPhantomKeysManager this_obj);
20152 export function PhantomKeysManager_free(this_obj: bigint): void {
20153 if(!isWasmInitialized) {
20154 throw new Error("initializeWasm() must be awaited first!");
20156 const nativeResponseValue = wasm.TS_PhantomKeysManager_free(this_obj);
20157 // debug statements here
20159 // struct LDKKeysInterface PhantomKeysManager_as_KeysInterface(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
20161 export function PhantomKeysManager_as_KeysInterface(this_arg: bigint): bigint {
20162 if(!isWasmInitialized) {
20163 throw new Error("initializeWasm() must be awaited first!");
20165 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_KeysInterface(this_arg);
20166 return nativeResponseValue;
20168 // 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]);
20170 export function PhantomKeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number, cross_node_seed: number): bigint {
20171 if(!isWasmInitialized) {
20172 throw new Error("initializeWasm() must be awaited first!");
20174 const nativeResponseValue = wasm.TS_PhantomKeysManager_new(seed, starting_time_secs, starting_time_nanos, cross_node_seed);
20175 return nativeResponseValue;
20177 // 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);
20179 export function PhantomKeysManager_spend_spendable_outputs(this_arg: bigint, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): bigint {
20180 if(!isWasmInitialized) {
20181 throw new Error("initializeWasm() must be awaited first!");
20183 const nativeResponseValue = wasm.TS_PhantomKeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
20184 return nativeResponseValue;
20186 // 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]);
20188 export function PhantomKeysManager_derive_channel_keys(this_arg: bigint, channel_value_satoshis: bigint, params: number): bigint {
20189 if(!isWasmInitialized) {
20190 throw new Error("initializeWasm() must be awaited first!");
20192 const nativeResponseValue = wasm.TS_PhantomKeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
20193 return nativeResponseValue;
20195 // void ChannelManager_free(struct LDKChannelManager this_obj);
20197 export function ChannelManager_free(this_obj: bigint): void {
20198 if(!isWasmInitialized) {
20199 throw new Error("initializeWasm() must be awaited first!");
20201 const nativeResponseValue = wasm.TS_ChannelManager_free(this_obj);
20202 // debug statements here
20204 // void ChainParameters_free(struct LDKChainParameters this_obj);
20206 export function ChainParameters_free(this_obj: bigint): void {
20207 if(!isWasmInitialized) {
20208 throw new Error("initializeWasm() must be awaited first!");
20210 const nativeResponseValue = wasm.TS_ChainParameters_free(this_obj);
20211 // debug statements here
20213 // enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr);
20215 export function ChainParameters_get_network(this_ptr: bigint): Network {
20216 if(!isWasmInitialized) {
20217 throw new Error("initializeWasm() must be awaited first!");
20219 const nativeResponseValue = wasm.TS_ChainParameters_get_network(this_ptr);
20220 return nativeResponseValue;
20222 // void ChainParameters_set_network(struct LDKChainParameters *NONNULL_PTR this_ptr, enum LDKNetwork val);
20224 export function ChainParameters_set_network(this_ptr: bigint, val: Network): void {
20225 if(!isWasmInitialized) {
20226 throw new Error("initializeWasm() must be awaited first!");
20228 const nativeResponseValue = wasm.TS_ChainParameters_set_network(this_ptr, val);
20229 // debug statements here
20231 // struct LDKBestBlock ChainParameters_get_best_block(const struct LDKChainParameters *NONNULL_PTR this_ptr);
20233 export function ChainParameters_get_best_block(this_ptr: bigint): bigint {
20234 if(!isWasmInitialized) {
20235 throw new Error("initializeWasm() must be awaited first!");
20237 const nativeResponseValue = wasm.TS_ChainParameters_get_best_block(this_ptr);
20238 return nativeResponseValue;
20240 // void ChainParameters_set_best_block(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKBestBlock val);
20242 export function ChainParameters_set_best_block(this_ptr: bigint, val: bigint): void {
20243 if(!isWasmInitialized) {
20244 throw new Error("initializeWasm() must be awaited first!");
20246 const nativeResponseValue = wasm.TS_ChainParameters_set_best_block(this_ptr, val);
20247 // debug statements here
20249 // MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKBestBlock best_block_arg);
20251 export function ChainParameters_new(network_arg: Network, best_block_arg: bigint): bigint {
20252 if(!isWasmInitialized) {
20253 throw new Error("initializeWasm() must be awaited first!");
20255 const nativeResponseValue = wasm.TS_ChainParameters_new(network_arg, best_block_arg);
20256 return nativeResponseValue;
20258 // uint64_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg);
20260 export function ChainParameters_clone_ptr(arg: bigint): bigint {
20261 if(!isWasmInitialized) {
20262 throw new Error("initializeWasm() must be awaited first!");
20264 const nativeResponseValue = wasm.TS_ChainParameters_clone_ptr(arg);
20265 return nativeResponseValue;
20267 // struct LDKChainParameters ChainParameters_clone(const struct LDKChainParameters *NONNULL_PTR orig);
20269 export function ChainParameters_clone(orig: bigint): bigint {
20270 if(!isWasmInitialized) {
20271 throw new Error("initializeWasm() must be awaited first!");
20273 const nativeResponseValue = wasm.TS_ChainParameters_clone(orig);
20274 return nativeResponseValue;
20276 // void CounterpartyForwardingInfo_free(struct LDKCounterpartyForwardingInfo this_obj);
20278 export function CounterpartyForwardingInfo_free(this_obj: bigint): void {
20279 if(!isWasmInitialized) {
20280 throw new Error("initializeWasm() must be awaited first!");
20282 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_free(this_obj);
20283 // debug statements here
20285 // uint32_t CounterpartyForwardingInfo_get_fee_base_msat(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
20287 export function CounterpartyForwardingInfo_get_fee_base_msat(this_ptr: bigint): number {
20288 if(!isWasmInitialized) {
20289 throw new Error("initializeWasm() must be awaited first!");
20291 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_base_msat(this_ptr);
20292 return nativeResponseValue;
20294 // void CounterpartyForwardingInfo_set_fee_base_msat(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
20296 export function CounterpartyForwardingInfo_set_fee_base_msat(this_ptr: bigint, val: number): void {
20297 if(!isWasmInitialized) {
20298 throw new Error("initializeWasm() must be awaited first!");
20300 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_base_msat(this_ptr, val);
20301 // debug statements here
20303 // uint32_t CounterpartyForwardingInfo_get_fee_proportional_millionths(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
20305 export function CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr: bigint): number {
20306 if(!isWasmInitialized) {
20307 throw new Error("initializeWasm() must be awaited first!");
20309 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr);
20310 return nativeResponseValue;
20312 // void CounterpartyForwardingInfo_set_fee_proportional_millionths(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
20314 export function CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
20315 if(!isWasmInitialized) {
20316 throw new Error("initializeWasm() must be awaited first!");
20318 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr, val);
20319 // debug statements here
20321 // uint16_t CounterpartyForwardingInfo_get_cltv_expiry_delta(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
20323 export function CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
20324 if(!isWasmInitialized) {
20325 throw new Error("initializeWasm() must be awaited first!");
20327 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr);
20328 return nativeResponseValue;
20330 // void CounterpartyForwardingInfo_set_cltv_expiry_delta(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint16_t val);
20332 export function CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
20333 if(!isWasmInitialized) {
20334 throw new Error("initializeWasm() must be awaited first!");
20336 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr, val);
20337 // debug statements here
20339 // 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);
20341 export function CounterpartyForwardingInfo_new(fee_base_msat_arg: number, fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number): bigint {
20342 if(!isWasmInitialized) {
20343 throw new Error("initializeWasm() must be awaited first!");
20345 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
20346 return nativeResponseValue;
20348 // uint64_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg);
20350 export function CounterpartyForwardingInfo_clone_ptr(arg: bigint): bigint {
20351 if(!isWasmInitialized) {
20352 throw new Error("initializeWasm() must be awaited first!");
20354 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone_ptr(arg);
20355 return nativeResponseValue;
20357 // struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_clone(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR orig);
20359 export function CounterpartyForwardingInfo_clone(orig: bigint): bigint {
20360 if(!isWasmInitialized) {
20361 throw new Error("initializeWasm() must be awaited first!");
20363 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone(orig);
20364 return nativeResponseValue;
20366 // void ChannelCounterparty_free(struct LDKChannelCounterparty this_obj);
20368 export function ChannelCounterparty_free(this_obj: bigint): void {
20369 if(!isWasmInitialized) {
20370 throw new Error("initializeWasm() must be awaited first!");
20372 const nativeResponseValue = wasm.TS_ChannelCounterparty_free(this_obj);
20373 // debug statements here
20375 // struct LDKPublicKey ChannelCounterparty_get_node_id(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
20377 export function ChannelCounterparty_get_node_id(this_ptr: bigint): number {
20378 if(!isWasmInitialized) {
20379 throw new Error("initializeWasm() must be awaited first!");
20381 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_node_id(this_ptr);
20382 return nativeResponseValue;
20384 // void ChannelCounterparty_set_node_id(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20386 export function ChannelCounterparty_set_node_id(this_ptr: bigint, val: number): void {
20387 if(!isWasmInitialized) {
20388 throw new Error("initializeWasm() must be awaited first!");
20390 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_node_id(this_ptr, val);
20391 // debug statements here
20393 // struct LDKInitFeatures ChannelCounterparty_get_features(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
20395 export function ChannelCounterparty_get_features(this_ptr: bigint): bigint {
20396 if(!isWasmInitialized) {
20397 throw new Error("initializeWasm() must be awaited first!");
20399 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_features(this_ptr);
20400 return nativeResponseValue;
20402 // void ChannelCounterparty_set_features(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
20404 export function ChannelCounterparty_set_features(this_ptr: bigint, val: bigint): void {
20405 if(!isWasmInitialized) {
20406 throw new Error("initializeWasm() must be awaited first!");
20408 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_features(this_ptr, val);
20409 // debug statements here
20411 // uint64_t ChannelCounterparty_get_unspendable_punishment_reserve(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
20413 export function ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr: bigint): bigint {
20414 if(!isWasmInitialized) {
20415 throw new Error("initializeWasm() must be awaited first!");
20417 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr);
20418 return nativeResponseValue;
20420 // void ChannelCounterparty_set_unspendable_punishment_reserve(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, uint64_t val);
20422 export function ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr: bigint, val: bigint): void {
20423 if(!isWasmInitialized) {
20424 throw new Error("initializeWasm() must be awaited first!");
20426 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr, val);
20427 // debug statements here
20429 // struct LDKCounterpartyForwardingInfo ChannelCounterparty_get_forwarding_info(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
20431 export function ChannelCounterparty_get_forwarding_info(this_ptr: bigint): bigint {
20432 if(!isWasmInitialized) {
20433 throw new Error("initializeWasm() must be awaited first!");
20435 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_forwarding_info(this_ptr);
20436 return nativeResponseValue;
20438 // void ChannelCounterparty_set_forwarding_info(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCounterpartyForwardingInfo val);
20440 export function ChannelCounterparty_set_forwarding_info(this_ptr: bigint, val: bigint): void {
20441 if(!isWasmInitialized) {
20442 throw new Error("initializeWasm() must be awaited first!");
20444 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_forwarding_info(this_ptr, val);
20445 // debug statements here
20447 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_minimum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
20449 export function ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr: bigint): bigint {
20450 if(!isWasmInitialized) {
20451 throw new Error("initializeWasm() must be awaited first!");
20453 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr);
20454 return nativeResponseValue;
20456 // void ChannelCounterparty_set_outbound_htlc_minimum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
20458 export function ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
20459 if(!isWasmInitialized) {
20460 throw new Error("initializeWasm() must be awaited first!");
20462 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr, val);
20463 // debug statements here
20465 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_maximum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
20467 export function ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr: bigint): bigint {
20468 if(!isWasmInitialized) {
20469 throw new Error("initializeWasm() must be awaited first!");
20471 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr);
20472 return nativeResponseValue;
20474 // void ChannelCounterparty_set_outbound_htlc_maximum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
20476 export function ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
20477 if(!isWasmInitialized) {
20478 throw new Error("initializeWasm() must be awaited first!");
20480 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr, val);
20481 // debug statements here
20483 // MUST_USE_RES struct LDKChannelCounterparty ChannelCounterparty_new(struct LDKPublicKey node_id_arg, struct LDKInitFeatures features_arg, uint64_t unspendable_punishment_reserve_arg, struct LDKCounterpartyForwardingInfo forwarding_info_arg, struct LDKCOption_u64Z outbound_htlc_minimum_msat_arg, struct LDKCOption_u64Z outbound_htlc_maximum_msat_arg);
20485 export function ChannelCounterparty_new(node_id_arg: number, features_arg: bigint, unspendable_punishment_reserve_arg: bigint, forwarding_info_arg: bigint, outbound_htlc_minimum_msat_arg: bigint, outbound_htlc_maximum_msat_arg: bigint): bigint {
20486 if(!isWasmInitialized) {
20487 throw new Error("initializeWasm() must be awaited first!");
20489 const nativeResponseValue = wasm.TS_ChannelCounterparty_new(node_id_arg, features_arg, unspendable_punishment_reserve_arg, forwarding_info_arg, outbound_htlc_minimum_msat_arg, outbound_htlc_maximum_msat_arg);
20490 return nativeResponseValue;
20492 // uint64_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg);
20494 export function ChannelCounterparty_clone_ptr(arg: bigint): bigint {
20495 if(!isWasmInitialized) {
20496 throw new Error("initializeWasm() must be awaited first!");
20498 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone_ptr(arg);
20499 return nativeResponseValue;
20501 // struct LDKChannelCounterparty ChannelCounterparty_clone(const struct LDKChannelCounterparty *NONNULL_PTR orig);
20503 export function ChannelCounterparty_clone(orig: bigint): bigint {
20504 if(!isWasmInitialized) {
20505 throw new Error("initializeWasm() must be awaited first!");
20507 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone(orig);
20508 return nativeResponseValue;
20510 // void ChannelDetails_free(struct LDKChannelDetails this_obj);
20512 export function ChannelDetails_free(this_obj: bigint): void {
20513 if(!isWasmInitialized) {
20514 throw new Error("initializeWasm() must be awaited first!");
20516 const nativeResponseValue = wasm.TS_ChannelDetails_free(this_obj);
20517 // debug statements here
20519 // const uint8_t (*ChannelDetails_get_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr))[32];
20521 export function ChannelDetails_get_channel_id(this_ptr: bigint): number {
20522 if(!isWasmInitialized) {
20523 throw new Error("initializeWasm() must be awaited first!");
20525 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_id(this_ptr);
20526 return nativeResponseValue;
20528 // void ChannelDetails_set_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20530 export function ChannelDetails_set_channel_id(this_ptr: bigint, val: number): void {
20531 if(!isWasmInitialized) {
20532 throw new Error("initializeWasm() must be awaited first!");
20534 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_id(this_ptr, val);
20535 // debug statements here
20537 // struct LDKChannelCounterparty ChannelDetails_get_counterparty(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
20539 export function ChannelDetails_get_counterparty(this_ptr: bigint): bigint {
20540 if(!isWasmInitialized) {
20541 throw new Error("initializeWasm() must be awaited first!");
20543 const nativeResponseValue = wasm.TS_ChannelDetails_get_counterparty(this_ptr);
20544 return nativeResponseValue;
20546 // void ChannelDetails_set_counterparty(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelCounterparty val);
20548 export function ChannelDetails_set_counterparty(this_ptr: bigint, val: bigint): void {
20549 if(!isWasmInitialized) {
20550 throw new Error("initializeWasm() must be awaited first!");
20552 const nativeResponseValue = wasm.TS_ChannelDetails_set_counterparty(this_ptr, val);
20553 // debug statements here
20555 // struct LDKOutPoint ChannelDetails_get_funding_txo(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
20557 export function ChannelDetails_get_funding_txo(this_ptr: bigint): bigint {
20558 if(!isWasmInitialized) {
20559 throw new Error("initializeWasm() must be awaited first!");
20561 const nativeResponseValue = wasm.TS_ChannelDetails_get_funding_txo(this_ptr);
20562 return nativeResponseValue;
20564 // void ChannelDetails_set_funding_txo(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKOutPoint val);
20566 export function ChannelDetails_set_funding_txo(this_ptr: bigint, val: bigint): void {
20567 if(!isWasmInitialized) {
20568 throw new Error("initializeWasm() must be awaited first!");
20570 const nativeResponseValue = wasm.TS_ChannelDetails_set_funding_txo(this_ptr, val);
20571 // debug statements here
20573 // struct LDKChannelTypeFeatures ChannelDetails_get_channel_type(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
20575 export function ChannelDetails_get_channel_type(this_ptr: bigint): bigint {
20576 if(!isWasmInitialized) {
20577 throw new Error("initializeWasm() must be awaited first!");
20579 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_type(this_ptr);
20580 return nativeResponseValue;
20582 // void ChannelDetails_set_channel_type(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
20584 export function ChannelDetails_set_channel_type(this_ptr: bigint, val: bigint): void {
20585 if(!isWasmInitialized) {
20586 throw new Error("initializeWasm() must be awaited first!");
20588 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_type(this_ptr, val);
20589 // debug statements here
20591 // struct LDKCOption_u64Z ChannelDetails_get_short_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
20593 export function ChannelDetails_get_short_channel_id(this_ptr: bigint): bigint {
20594 if(!isWasmInitialized) {
20595 throw new Error("initializeWasm() must be awaited first!");
20597 const nativeResponseValue = wasm.TS_ChannelDetails_get_short_channel_id(this_ptr);
20598 return nativeResponseValue;
20600 // void ChannelDetails_set_short_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
20602 export function ChannelDetails_set_short_channel_id(this_ptr: bigint, val: bigint): void {
20603 if(!isWasmInitialized) {
20604 throw new Error("initializeWasm() must be awaited first!");
20606 const nativeResponseValue = wasm.TS_ChannelDetails_set_short_channel_id(this_ptr, val);
20607 // debug statements here
20609 // struct LDKCOption_u64Z ChannelDetails_get_outbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
20611 export function ChannelDetails_get_outbound_scid_alias(this_ptr: bigint): bigint {
20612 if(!isWasmInitialized) {
20613 throw new Error("initializeWasm() must be awaited first!");
20615 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_scid_alias(this_ptr);
20616 return nativeResponseValue;
20618 // void ChannelDetails_set_outbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
20620 export function ChannelDetails_set_outbound_scid_alias(this_ptr: bigint, val: bigint): void {
20621 if(!isWasmInitialized) {
20622 throw new Error("initializeWasm() must be awaited first!");
20624 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_scid_alias(this_ptr, val);
20625 // debug statements here
20627 // struct LDKCOption_u64Z ChannelDetails_get_inbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
20629 export function ChannelDetails_get_inbound_scid_alias(this_ptr: bigint): bigint {
20630 if(!isWasmInitialized) {
20631 throw new Error("initializeWasm() must be awaited first!");
20633 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_scid_alias(this_ptr);
20634 return nativeResponseValue;
20636 // void ChannelDetails_set_inbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
20638 export function ChannelDetails_set_inbound_scid_alias(this_ptr: bigint, val: bigint): void {
20639 if(!isWasmInitialized) {
20640 throw new Error("initializeWasm() must be awaited first!");
20642 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_scid_alias(this_ptr, val);
20643 // debug statements here
20645 // uint64_t ChannelDetails_get_channel_value_satoshis(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
20647 export function ChannelDetails_get_channel_value_satoshis(this_ptr: bigint): bigint {
20648 if(!isWasmInitialized) {
20649 throw new Error("initializeWasm() must be awaited first!");
20651 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_value_satoshis(this_ptr);
20652 return nativeResponseValue;
20654 // void ChannelDetails_set_channel_value_satoshis(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
20656 export function ChannelDetails_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
20657 if(!isWasmInitialized) {
20658 throw new Error("initializeWasm() must be awaited first!");
20660 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_value_satoshis(this_ptr, val);
20661 // debug statements here
20663 // struct LDKCOption_u64Z ChannelDetails_get_unspendable_punishment_reserve(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
20665 export function ChannelDetails_get_unspendable_punishment_reserve(this_ptr: bigint): bigint {
20666 if(!isWasmInitialized) {
20667 throw new Error("initializeWasm() must be awaited first!");
20669 const nativeResponseValue = wasm.TS_ChannelDetails_get_unspendable_punishment_reserve(this_ptr);
20670 return nativeResponseValue;
20672 // void ChannelDetails_set_unspendable_punishment_reserve(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
20674 export function ChannelDetails_set_unspendable_punishment_reserve(this_ptr: bigint, val: bigint): void {
20675 if(!isWasmInitialized) {
20676 throw new Error("initializeWasm() must be awaited first!");
20678 const nativeResponseValue = wasm.TS_ChannelDetails_set_unspendable_punishment_reserve(this_ptr, val);
20679 // debug statements here
20681 // uint64_t ChannelDetails_get_user_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
20683 export function ChannelDetails_get_user_channel_id(this_ptr: bigint): bigint {
20684 if(!isWasmInitialized) {
20685 throw new Error("initializeWasm() must be awaited first!");
20687 const nativeResponseValue = wasm.TS_ChannelDetails_get_user_channel_id(this_ptr);
20688 return nativeResponseValue;
20690 // void ChannelDetails_set_user_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
20692 export function ChannelDetails_set_user_channel_id(this_ptr: bigint, val: bigint): void {
20693 if(!isWasmInitialized) {
20694 throw new Error("initializeWasm() must be awaited first!");
20696 const nativeResponseValue = wasm.TS_ChannelDetails_set_user_channel_id(this_ptr, val);
20697 // debug statements here
20699 // uint64_t ChannelDetails_get_balance_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
20701 export function ChannelDetails_get_balance_msat(this_ptr: bigint): bigint {
20702 if(!isWasmInitialized) {
20703 throw new Error("initializeWasm() must be awaited first!");
20705 const nativeResponseValue = wasm.TS_ChannelDetails_get_balance_msat(this_ptr);
20706 return nativeResponseValue;
20708 // void ChannelDetails_set_balance_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
20710 export function ChannelDetails_set_balance_msat(this_ptr: bigint, val: bigint): void {
20711 if(!isWasmInitialized) {
20712 throw new Error("initializeWasm() must be awaited first!");
20714 const nativeResponseValue = wasm.TS_ChannelDetails_set_balance_msat(this_ptr, val);
20715 // debug statements here
20717 // uint64_t ChannelDetails_get_outbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
20719 export function ChannelDetails_get_outbound_capacity_msat(this_ptr: bigint): bigint {
20720 if(!isWasmInitialized) {
20721 throw new Error("initializeWasm() must be awaited first!");
20723 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_capacity_msat(this_ptr);
20724 return nativeResponseValue;
20726 // void ChannelDetails_set_outbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
20728 export function ChannelDetails_set_outbound_capacity_msat(this_ptr: bigint, val: bigint): void {
20729 if(!isWasmInitialized) {
20730 throw new Error("initializeWasm() must be awaited first!");
20732 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_capacity_msat(this_ptr, val);
20733 // debug statements here
20735 // uint64_t ChannelDetails_get_next_outbound_htlc_limit_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
20737 export function ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr: bigint): bigint {
20738 if(!isWasmInitialized) {
20739 throw new Error("initializeWasm() must be awaited first!");
20741 const nativeResponseValue = wasm.TS_ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr);
20742 return nativeResponseValue;
20744 // void ChannelDetails_set_next_outbound_htlc_limit_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
20746 export function ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr: bigint, val: bigint): void {
20747 if(!isWasmInitialized) {
20748 throw new Error("initializeWasm() must be awaited first!");
20750 const nativeResponseValue = wasm.TS_ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr, val);
20751 // debug statements here
20753 // uint64_t ChannelDetails_get_inbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
20755 export function ChannelDetails_get_inbound_capacity_msat(this_ptr: bigint): bigint {
20756 if(!isWasmInitialized) {
20757 throw new Error("initializeWasm() must be awaited first!");
20759 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_capacity_msat(this_ptr);
20760 return nativeResponseValue;
20762 // void ChannelDetails_set_inbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
20764 export function ChannelDetails_set_inbound_capacity_msat(this_ptr: bigint, val: bigint): void {
20765 if(!isWasmInitialized) {
20766 throw new Error("initializeWasm() must be awaited first!");
20768 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_capacity_msat(this_ptr, val);
20769 // debug statements here
20771 // struct LDKCOption_u32Z ChannelDetails_get_confirmations_required(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
20773 export function ChannelDetails_get_confirmations_required(this_ptr: bigint): bigint {
20774 if(!isWasmInitialized) {
20775 throw new Error("initializeWasm() must be awaited first!");
20777 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations_required(this_ptr);
20778 return nativeResponseValue;
20780 // void ChannelDetails_set_confirmations_required(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
20782 export function ChannelDetails_set_confirmations_required(this_ptr: bigint, val: bigint): void {
20783 if(!isWasmInitialized) {
20784 throw new Error("initializeWasm() must be awaited first!");
20786 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations_required(this_ptr, val);
20787 // debug statements here
20789 // struct LDKCOption_u16Z ChannelDetails_get_force_close_spend_delay(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
20791 export function ChannelDetails_get_force_close_spend_delay(this_ptr: bigint): bigint {
20792 if(!isWasmInitialized) {
20793 throw new Error("initializeWasm() must be awaited first!");
20795 const nativeResponseValue = wasm.TS_ChannelDetails_get_force_close_spend_delay(this_ptr);
20796 return nativeResponseValue;
20798 // void ChannelDetails_set_force_close_spend_delay(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
20800 export function ChannelDetails_set_force_close_spend_delay(this_ptr: bigint, val: bigint): void {
20801 if(!isWasmInitialized) {
20802 throw new Error("initializeWasm() must be awaited first!");
20804 const nativeResponseValue = wasm.TS_ChannelDetails_set_force_close_spend_delay(this_ptr, val);
20805 // debug statements here
20807 // bool ChannelDetails_get_is_outbound(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
20809 export function ChannelDetails_get_is_outbound(this_ptr: bigint): boolean {
20810 if(!isWasmInitialized) {
20811 throw new Error("initializeWasm() must be awaited first!");
20813 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_outbound(this_ptr);
20814 return nativeResponseValue;
20816 // void ChannelDetails_set_is_outbound(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
20818 export function ChannelDetails_set_is_outbound(this_ptr: bigint, val: boolean): void {
20819 if(!isWasmInitialized) {
20820 throw new Error("initializeWasm() must be awaited first!");
20822 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_outbound(this_ptr, val);
20823 // debug statements here
20825 // bool ChannelDetails_get_is_channel_ready(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
20827 export function ChannelDetails_get_is_channel_ready(this_ptr: bigint): boolean {
20828 if(!isWasmInitialized) {
20829 throw new Error("initializeWasm() must be awaited first!");
20831 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_channel_ready(this_ptr);
20832 return nativeResponseValue;
20834 // void ChannelDetails_set_is_channel_ready(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
20836 export function ChannelDetails_set_is_channel_ready(this_ptr: bigint, val: boolean): void {
20837 if(!isWasmInitialized) {
20838 throw new Error("initializeWasm() must be awaited first!");
20840 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_channel_ready(this_ptr, val);
20841 // debug statements here
20843 // bool ChannelDetails_get_is_usable(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
20845 export function ChannelDetails_get_is_usable(this_ptr: bigint): boolean {
20846 if(!isWasmInitialized) {
20847 throw new Error("initializeWasm() must be awaited first!");
20849 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_usable(this_ptr);
20850 return nativeResponseValue;
20852 // void ChannelDetails_set_is_usable(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
20854 export function ChannelDetails_set_is_usable(this_ptr: bigint, val: boolean): void {
20855 if(!isWasmInitialized) {
20856 throw new Error("initializeWasm() must be awaited first!");
20858 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_usable(this_ptr, val);
20859 // debug statements here
20861 // bool ChannelDetails_get_is_public(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
20863 export function ChannelDetails_get_is_public(this_ptr: bigint): boolean {
20864 if(!isWasmInitialized) {
20865 throw new Error("initializeWasm() must be awaited first!");
20867 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_public(this_ptr);
20868 return nativeResponseValue;
20870 // void ChannelDetails_set_is_public(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
20872 export function ChannelDetails_set_is_public(this_ptr: bigint, val: boolean): void {
20873 if(!isWasmInitialized) {
20874 throw new Error("initializeWasm() must be awaited first!");
20876 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_public(this_ptr, val);
20877 // debug statements here
20879 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_minimum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
20881 export function ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr: bigint): bigint {
20882 if(!isWasmInitialized) {
20883 throw new Error("initializeWasm() must be awaited first!");
20885 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr);
20886 return nativeResponseValue;
20888 // void ChannelDetails_set_inbound_htlc_minimum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
20890 export function ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
20891 if(!isWasmInitialized) {
20892 throw new Error("initializeWasm() must be awaited first!");
20894 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr, val);
20895 // debug statements here
20897 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_maximum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
20899 export function ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr: bigint): bigint {
20900 if(!isWasmInitialized) {
20901 throw new Error("initializeWasm() must be awaited first!");
20903 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr);
20904 return nativeResponseValue;
20906 // void ChannelDetails_set_inbound_htlc_maximum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
20908 export function ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
20909 if(!isWasmInitialized) {
20910 throw new Error("initializeWasm() must be awaited first!");
20912 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr, val);
20913 // debug statements here
20915 // struct LDKChannelConfig ChannelDetails_get_config(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
20917 export function ChannelDetails_get_config(this_ptr: bigint): bigint {
20918 if(!isWasmInitialized) {
20919 throw new Error("initializeWasm() must be awaited first!");
20921 const nativeResponseValue = wasm.TS_ChannelDetails_get_config(this_ptr);
20922 return nativeResponseValue;
20924 // void ChannelDetails_set_config(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
20926 export function ChannelDetails_set_config(this_ptr: bigint, val: bigint): void {
20927 if(!isWasmInitialized) {
20928 throw new Error("initializeWasm() must be awaited first!");
20930 const nativeResponseValue = wasm.TS_ChannelDetails_set_config(this_ptr, val);
20931 // debug statements here
20933 // MUST_USE_RES struct LDKChannelDetails ChannelDetails_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKChannelCounterparty counterparty_arg, struct LDKOutPoint funding_txo_arg, struct LDKChannelTypeFeatures channel_type_arg, struct LDKCOption_u64Z short_channel_id_arg, struct LDKCOption_u64Z outbound_scid_alias_arg, struct LDKCOption_u64Z inbound_scid_alias_arg, uint64_t channel_value_satoshis_arg, struct LDKCOption_u64Z unspendable_punishment_reserve_arg, uint64_t user_channel_id_arg, uint64_t balance_msat_arg, uint64_t outbound_capacity_msat_arg, uint64_t next_outbound_htlc_limit_msat_arg, uint64_t inbound_capacity_msat_arg, struct LDKCOption_u32Z confirmations_required_arg, struct LDKCOption_u16Z force_close_spend_delay_arg, bool is_outbound_arg, bool is_channel_ready_arg, bool is_usable_arg, bool is_public_arg, struct LDKCOption_u64Z inbound_htlc_minimum_msat_arg, struct LDKCOption_u64Z inbound_htlc_maximum_msat_arg, struct LDKChannelConfig config_arg);
20935 export function ChannelDetails_new(channel_id_arg: number, counterparty_arg: bigint, funding_txo_arg: bigint, channel_type_arg: bigint, short_channel_id_arg: bigint, outbound_scid_alias_arg: bigint, inbound_scid_alias_arg: bigint, channel_value_satoshis_arg: bigint, unspendable_punishment_reserve_arg: bigint, user_channel_id_arg: bigint, balance_msat_arg: bigint, outbound_capacity_msat_arg: bigint, next_outbound_htlc_limit_msat_arg: bigint, inbound_capacity_msat_arg: bigint, confirmations_required_arg: bigint, force_close_spend_delay_arg: bigint, is_outbound_arg: boolean, is_channel_ready_arg: boolean, is_usable_arg: boolean, is_public_arg: boolean, inbound_htlc_minimum_msat_arg: bigint, inbound_htlc_maximum_msat_arg: bigint, config_arg: bigint): bigint {
20936 if(!isWasmInitialized) {
20937 throw new Error("initializeWasm() must be awaited first!");
20939 const nativeResponseValue = wasm.TS_ChannelDetails_new(channel_id_arg, counterparty_arg, funding_txo_arg, channel_type_arg, short_channel_id_arg, outbound_scid_alias_arg, inbound_scid_alias_arg, channel_value_satoshis_arg, unspendable_punishment_reserve_arg, user_channel_id_arg, balance_msat_arg, outbound_capacity_msat_arg, next_outbound_htlc_limit_msat_arg, inbound_capacity_msat_arg, confirmations_required_arg, force_close_spend_delay_arg, is_outbound_arg, is_channel_ready_arg, is_usable_arg, is_public_arg, inbound_htlc_minimum_msat_arg, inbound_htlc_maximum_msat_arg, config_arg);
20940 return nativeResponseValue;
20942 // uint64_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg);
20944 export function ChannelDetails_clone_ptr(arg: bigint): bigint {
20945 if(!isWasmInitialized) {
20946 throw new Error("initializeWasm() must be awaited first!");
20948 const nativeResponseValue = wasm.TS_ChannelDetails_clone_ptr(arg);
20949 return nativeResponseValue;
20951 // struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
20953 export function ChannelDetails_clone(orig: bigint): bigint {
20954 if(!isWasmInitialized) {
20955 throw new Error("initializeWasm() must be awaited first!");
20957 const nativeResponseValue = wasm.TS_ChannelDetails_clone(orig);
20958 return nativeResponseValue;
20960 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_inbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
20962 export function ChannelDetails_get_inbound_payment_scid(this_arg: bigint): bigint {
20963 if(!isWasmInitialized) {
20964 throw new Error("initializeWasm() must be awaited first!");
20966 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_payment_scid(this_arg);
20967 return nativeResponseValue;
20969 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_outbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
20971 export function ChannelDetails_get_outbound_payment_scid(this_arg: bigint): bigint {
20972 if(!isWasmInitialized) {
20973 throw new Error("initializeWasm() must be awaited first!");
20975 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_payment_scid(this_arg);
20976 return nativeResponseValue;
20978 // void PaymentSendFailure_free(struct LDKPaymentSendFailure this_ptr);
20980 export function PaymentSendFailure_free(this_ptr: bigint): void {
20981 if(!isWasmInitialized) {
20982 throw new Error("initializeWasm() must be awaited first!");
20984 const nativeResponseValue = wasm.TS_PaymentSendFailure_free(this_ptr);
20985 // debug statements here
20987 // uint64_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg);
20989 export function PaymentSendFailure_clone_ptr(arg: bigint): bigint {
20990 if(!isWasmInitialized) {
20991 throw new Error("initializeWasm() must be awaited first!");
20993 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone_ptr(arg);
20994 return nativeResponseValue;
20996 // struct LDKPaymentSendFailure PaymentSendFailure_clone(const struct LDKPaymentSendFailure *NONNULL_PTR orig);
20998 export function PaymentSendFailure_clone(orig: bigint): bigint {
20999 if(!isWasmInitialized) {
21000 throw new Error("initializeWasm() must be awaited first!");
21002 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone(orig);
21003 return nativeResponseValue;
21005 // struct LDKPaymentSendFailure PaymentSendFailure_parameter_error(struct LDKAPIError a);
21007 export function PaymentSendFailure_parameter_error(a: bigint): bigint {
21008 if(!isWasmInitialized) {
21009 throw new Error("initializeWasm() must be awaited first!");
21011 const nativeResponseValue = wasm.TS_PaymentSendFailure_parameter_error(a);
21012 return nativeResponseValue;
21014 // struct LDKPaymentSendFailure PaymentSendFailure_path_parameter_error(struct LDKCVec_CResult_NoneAPIErrorZZ a);
21016 export function PaymentSendFailure_path_parameter_error(a: number): bigint {
21017 if(!isWasmInitialized) {
21018 throw new Error("initializeWasm() must be awaited first!");
21020 const nativeResponseValue = wasm.TS_PaymentSendFailure_path_parameter_error(a);
21021 return nativeResponseValue;
21023 // struct LDKPaymentSendFailure PaymentSendFailure_all_failed_retry_safe(struct LDKCVec_APIErrorZ a);
21025 export function PaymentSendFailure_all_failed_retry_safe(a: number): bigint {
21026 if(!isWasmInitialized) {
21027 throw new Error("initializeWasm() must be awaited first!");
21029 const nativeResponseValue = wasm.TS_PaymentSendFailure_all_failed_retry_safe(a);
21030 return nativeResponseValue;
21032 // struct LDKPaymentSendFailure PaymentSendFailure_partial_failure(struct LDKCVec_CResult_NoneAPIErrorZZ results, struct LDKRouteParameters failed_paths_retry, struct LDKThirtyTwoBytes payment_id);
21034 export function PaymentSendFailure_partial_failure(results: number, failed_paths_retry: bigint, payment_id: number): bigint {
21035 if(!isWasmInitialized) {
21036 throw new Error("initializeWasm() must be awaited first!");
21038 const nativeResponseValue = wasm.TS_PaymentSendFailure_partial_failure(results, failed_paths_retry, payment_id);
21039 return nativeResponseValue;
21041 // void PhantomRouteHints_free(struct LDKPhantomRouteHints this_obj);
21043 export function PhantomRouteHints_free(this_obj: bigint): void {
21044 if(!isWasmInitialized) {
21045 throw new Error("initializeWasm() must be awaited first!");
21047 const nativeResponseValue = wasm.TS_PhantomRouteHints_free(this_obj);
21048 // debug statements here
21050 // struct LDKCVec_ChannelDetailsZ PhantomRouteHints_get_channels(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
21052 export function PhantomRouteHints_get_channels(this_ptr: bigint): number {
21053 if(!isWasmInitialized) {
21054 throw new Error("initializeWasm() must be awaited first!");
21056 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_channels(this_ptr);
21057 return nativeResponseValue;
21059 // void PhantomRouteHints_set_channels(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKCVec_ChannelDetailsZ val);
21061 export function PhantomRouteHints_set_channels(this_ptr: bigint, val: number): void {
21062 if(!isWasmInitialized) {
21063 throw new Error("initializeWasm() must be awaited first!");
21065 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_channels(this_ptr, val);
21066 // debug statements here
21068 // uint64_t PhantomRouteHints_get_phantom_scid(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
21070 export function PhantomRouteHints_get_phantom_scid(this_ptr: bigint): bigint {
21071 if(!isWasmInitialized) {
21072 throw new Error("initializeWasm() must be awaited first!");
21074 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_phantom_scid(this_ptr);
21075 return nativeResponseValue;
21077 // void PhantomRouteHints_set_phantom_scid(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, uint64_t val);
21079 export function PhantomRouteHints_set_phantom_scid(this_ptr: bigint, val: bigint): void {
21080 if(!isWasmInitialized) {
21081 throw new Error("initializeWasm() must be awaited first!");
21083 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_phantom_scid(this_ptr, val);
21084 // debug statements here
21086 // struct LDKPublicKey PhantomRouteHints_get_real_node_pubkey(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
21088 export function PhantomRouteHints_get_real_node_pubkey(this_ptr: bigint): number {
21089 if(!isWasmInitialized) {
21090 throw new Error("initializeWasm() must be awaited first!");
21092 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_real_node_pubkey(this_ptr);
21093 return nativeResponseValue;
21095 // void PhantomRouteHints_set_real_node_pubkey(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21097 export function PhantomRouteHints_set_real_node_pubkey(this_ptr: bigint, val: number): void {
21098 if(!isWasmInitialized) {
21099 throw new Error("initializeWasm() must be awaited first!");
21101 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_real_node_pubkey(this_ptr, val);
21102 // debug statements here
21104 // MUST_USE_RES struct LDKPhantomRouteHints PhantomRouteHints_new(struct LDKCVec_ChannelDetailsZ channels_arg, uint64_t phantom_scid_arg, struct LDKPublicKey real_node_pubkey_arg);
21106 export function PhantomRouteHints_new(channels_arg: number, phantom_scid_arg: bigint, real_node_pubkey_arg: number): bigint {
21107 if(!isWasmInitialized) {
21108 throw new Error("initializeWasm() must be awaited first!");
21110 const nativeResponseValue = wasm.TS_PhantomRouteHints_new(channels_arg, phantom_scid_arg, real_node_pubkey_arg);
21111 return nativeResponseValue;
21113 // uint64_t PhantomRouteHints_clone_ptr(LDKPhantomRouteHints *NONNULL_PTR arg);
21115 export function PhantomRouteHints_clone_ptr(arg: bigint): bigint {
21116 if(!isWasmInitialized) {
21117 throw new Error("initializeWasm() must be awaited first!");
21119 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone_ptr(arg);
21120 return nativeResponseValue;
21122 // struct LDKPhantomRouteHints PhantomRouteHints_clone(const struct LDKPhantomRouteHints *NONNULL_PTR orig);
21124 export function PhantomRouteHints_clone(orig: bigint): bigint {
21125 if(!isWasmInitialized) {
21126 throw new Error("initializeWasm() must be awaited first!");
21128 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone(orig);
21129 return nativeResponseValue;
21131 // 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);
21133 export function ChannelManager_new(fee_est: bigint, chain_monitor: bigint, tx_broadcaster: bigint, logger: bigint, keys_manager: bigint, config: bigint, params: bigint): bigint {
21134 if(!isWasmInitialized) {
21135 throw new Error("initializeWasm() must be awaited first!");
21137 const nativeResponseValue = wasm.TS_ChannelManager_new(fee_est, chain_monitor, tx_broadcaster, logger, keys_manager, config, params);
21138 return nativeResponseValue;
21140 // MUST_USE_RES struct LDKUserConfig ChannelManager_get_current_default_configuration(const struct LDKChannelManager *NONNULL_PTR this_arg);
21142 export function ChannelManager_get_current_default_configuration(this_arg: bigint): bigint {
21143 if(!isWasmInitialized) {
21144 throw new Error("initializeWasm() must be awaited first!");
21146 const nativeResponseValue = wasm.TS_ChannelManager_get_current_default_configuration(this_arg);
21147 return nativeResponseValue;
21149 // 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);
21151 export function ChannelManager_create_channel(this_arg: bigint, their_network_key: number, channel_value_satoshis: bigint, push_msat: bigint, user_channel_id: bigint, override_config: bigint): bigint {
21152 if(!isWasmInitialized) {
21153 throw new Error("initializeWasm() must be awaited first!");
21155 const nativeResponseValue = wasm.TS_ChannelManager_create_channel(this_arg, their_network_key, channel_value_satoshis, push_msat, user_channel_id, override_config);
21156 return nativeResponseValue;
21158 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
21160 export function ChannelManager_list_channels(this_arg: bigint): number {
21161 if(!isWasmInitialized) {
21162 throw new Error("initializeWasm() must be awaited first!");
21164 const nativeResponseValue = wasm.TS_ChannelManager_list_channels(this_arg);
21165 return nativeResponseValue;
21167 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_usable_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
21169 export function ChannelManager_list_usable_channels(this_arg: bigint): number {
21170 if(!isWasmInitialized) {
21171 throw new Error("initializeWasm() must be awaited first!");
21173 const nativeResponseValue = wasm.TS_ChannelManager_list_usable_channels(this_arg);
21174 return nativeResponseValue;
21176 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_close_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32], struct LDKPublicKey counterparty_node_id);
21178 export function ChannelManager_close_channel(this_arg: bigint, channel_id: number, counterparty_node_id: number): bigint {
21179 if(!isWasmInitialized) {
21180 throw new Error("initializeWasm() must be awaited first!");
21182 const nativeResponseValue = wasm.TS_ChannelManager_close_channel(this_arg, channel_id, counterparty_node_id);
21183 return nativeResponseValue;
21185 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_close_channel_with_target_feerate(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32], struct LDKPublicKey counterparty_node_id, uint32_t target_feerate_sats_per_1000_weight);
21187 export function ChannelManager_close_channel_with_target_feerate(this_arg: bigint, channel_id: number, counterparty_node_id: number, target_feerate_sats_per_1000_weight: number): bigint {
21188 if(!isWasmInitialized) {
21189 throw new Error("initializeWasm() must be awaited first!");
21191 const nativeResponseValue = wasm.TS_ChannelManager_close_channel_with_target_feerate(this_arg, channel_id, counterparty_node_id, target_feerate_sats_per_1000_weight);
21192 return nativeResponseValue;
21194 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_force_close_broadcasting_latest_txn(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32], struct LDKPublicKey counterparty_node_id);
21196 export function ChannelManager_force_close_broadcasting_latest_txn(this_arg: bigint, channel_id: number, counterparty_node_id: number): bigint {
21197 if(!isWasmInitialized) {
21198 throw new Error("initializeWasm() must be awaited first!");
21200 const nativeResponseValue = wasm.TS_ChannelManager_force_close_broadcasting_latest_txn(this_arg, channel_id, counterparty_node_id);
21201 return nativeResponseValue;
21203 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_force_close_without_broadcasting_txn(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32], struct LDKPublicKey counterparty_node_id);
21205 export function ChannelManager_force_close_without_broadcasting_txn(this_arg: bigint, channel_id: number, counterparty_node_id: number): bigint {
21206 if(!isWasmInitialized) {
21207 throw new Error("initializeWasm() must be awaited first!");
21209 const nativeResponseValue = wasm.TS_ChannelManager_force_close_without_broadcasting_txn(this_arg, channel_id, counterparty_node_id);
21210 return nativeResponseValue;
21212 // void ChannelManager_force_close_all_channels_broadcasting_latest_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
21214 export function ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg: bigint): void {
21215 if(!isWasmInitialized) {
21216 throw new Error("initializeWasm() must be awaited first!");
21218 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg);
21219 // debug statements here
21221 // void ChannelManager_force_close_all_channels_without_broadcasting_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
21223 export function ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg: bigint): void {
21224 if(!isWasmInitialized) {
21225 throw new Error("initializeWasm() must be awaited first!");
21227 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg);
21228 // debug statements here
21230 // 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);
21232 export function ChannelManager_send_payment(this_arg: bigint, route: bigint, payment_hash: number, payment_secret: number): bigint {
21233 if(!isWasmInitialized) {
21234 throw new Error("initializeWasm() must be awaited first!");
21236 const nativeResponseValue = wasm.TS_ChannelManager_send_payment(this_arg, route, payment_hash, payment_secret);
21237 return nativeResponseValue;
21239 // 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);
21241 export function ChannelManager_retry_payment(this_arg: bigint, route: bigint, payment_id: number): bigint {
21242 if(!isWasmInitialized) {
21243 throw new Error("initializeWasm() must be awaited first!");
21245 const nativeResponseValue = wasm.TS_ChannelManager_retry_payment(this_arg, route, payment_id);
21246 return nativeResponseValue;
21248 // void ChannelManager_abandon_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id);
21250 export function ChannelManager_abandon_payment(this_arg: bigint, payment_id: number): void {
21251 if(!isWasmInitialized) {
21252 throw new Error("initializeWasm() must be awaited first!");
21254 const nativeResponseValue = wasm.TS_ChannelManager_abandon_payment(this_arg, payment_id);
21255 // debug statements here
21257 // 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);
21259 export function ChannelManager_send_spontaneous_payment(this_arg: bigint, route: bigint, payment_preimage: number): bigint {
21260 if(!isWasmInitialized) {
21261 throw new Error("initializeWasm() must be awaited first!");
21263 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment(this_arg, route, payment_preimage);
21264 return nativeResponseValue;
21266 // MUST_USE_RES struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ ChannelManager_send_probe(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ hops);
21268 export function ChannelManager_send_probe(this_arg: bigint, hops: number): bigint {
21269 if(!isWasmInitialized) {
21270 throw new Error("initializeWasm() must be awaited first!");
21272 const nativeResponseValue = wasm.TS_ChannelManager_send_probe(this_arg, hops);
21273 return nativeResponseValue;
21275 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_funding_transaction_generated(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*temporary_channel_id)[32], struct LDKPublicKey counterparty_node_id, struct LDKTransaction funding_transaction);
21277 export function ChannelManager_funding_transaction_generated(this_arg: bigint, temporary_channel_id: number, counterparty_node_id: number, funding_transaction: number): bigint {
21278 if(!isWasmInitialized) {
21279 throw new Error("initializeWasm() must be awaited first!");
21281 const nativeResponseValue = wasm.TS_ChannelManager_funding_transaction_generated(this_arg, temporary_channel_id, counterparty_node_id, funding_transaction);
21282 return nativeResponseValue;
21284 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_update_channel_config(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey counterparty_node_id, struct LDKCVec_ThirtyTwoBytesZ channel_ids, const struct LDKChannelConfig *NONNULL_PTR config);
21286 export function ChannelManager_update_channel_config(this_arg: bigint, counterparty_node_id: number, channel_ids: number, config: bigint): bigint {
21287 if(!isWasmInitialized) {
21288 throw new Error("initializeWasm() must be awaited first!");
21290 const nativeResponseValue = wasm.TS_ChannelManager_update_channel_config(this_arg, counterparty_node_id, channel_ids, config);
21291 return nativeResponseValue;
21293 // void ChannelManager_process_pending_htlc_forwards(const struct LDKChannelManager *NONNULL_PTR this_arg);
21295 export function ChannelManager_process_pending_htlc_forwards(this_arg: bigint): void {
21296 if(!isWasmInitialized) {
21297 throw new Error("initializeWasm() must be awaited first!");
21299 const nativeResponseValue = wasm.TS_ChannelManager_process_pending_htlc_forwards(this_arg);
21300 // debug statements here
21302 // void ChannelManager_timer_tick_occurred(const struct LDKChannelManager *NONNULL_PTR this_arg);
21304 export function ChannelManager_timer_tick_occurred(this_arg: bigint): void {
21305 if(!isWasmInitialized) {
21306 throw new Error("initializeWasm() must be awaited first!");
21308 const nativeResponseValue = wasm.TS_ChannelManager_timer_tick_occurred(this_arg);
21309 // debug statements here
21311 // void ChannelManager_fail_htlc_backwards(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
21313 export function ChannelManager_fail_htlc_backwards(this_arg: bigint, payment_hash: number): void {
21314 if(!isWasmInitialized) {
21315 throw new Error("initializeWasm() must be awaited first!");
21317 const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards(this_arg, payment_hash);
21318 // debug statements here
21320 // void ChannelManager_claim_funds(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
21322 export function ChannelManager_claim_funds(this_arg: bigint, payment_preimage: number): void {
21323 if(!isWasmInitialized) {
21324 throw new Error("initializeWasm() must be awaited first!");
21326 const nativeResponseValue = wasm.TS_ChannelManager_claim_funds(this_arg, payment_preimage);
21327 // debug statements here
21329 // MUST_USE_RES struct LDKPublicKey ChannelManager_get_our_node_id(const struct LDKChannelManager *NONNULL_PTR this_arg);
21331 export function ChannelManager_get_our_node_id(this_arg: bigint): number {
21332 if(!isWasmInitialized) {
21333 throw new Error("initializeWasm() must be awaited first!");
21335 const nativeResponseValue = wasm.TS_ChannelManager_get_our_node_id(this_arg);
21336 return nativeResponseValue;
21338 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_accept_inbound_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*temporary_channel_id)[32], struct LDKPublicKey counterparty_node_id, uint64_t user_channel_id);
21340 export function ChannelManager_accept_inbound_channel(this_arg: bigint, temporary_channel_id: number, counterparty_node_id: number, user_channel_id: bigint): bigint {
21341 if(!isWasmInitialized) {
21342 throw new Error("initializeWasm() must be awaited first!");
21344 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
21345 return nativeResponseValue;
21347 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*temporary_channel_id)[32], struct LDKPublicKey counterparty_node_id, uint64_t user_channel_id);
21349 export function ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg: bigint, temporary_channel_id: number, counterparty_node_id: number, user_channel_id: bigint): bigint {
21350 if(!isWasmInitialized) {
21351 throw new Error("initializeWasm() must be awaited first!");
21353 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
21354 return nativeResponseValue;
21356 // 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);
21358 export function ChannelManager_create_inbound_payment(this_arg: bigint, min_value_msat: bigint, invoice_expiry_delta_secs: number): bigint {
21359 if(!isWasmInitialized) {
21360 throw new Error("initializeWasm() must be awaited first!");
21362 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment(this_arg, min_value_msat, invoice_expiry_delta_secs);
21363 return nativeResponseValue;
21365 // 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);
21367 export function ChannelManager_create_inbound_payment_legacy(this_arg: bigint, min_value_msat: bigint, invoice_expiry_delta_secs: number): bigint {
21368 if(!isWasmInitialized) {
21369 throw new Error("initializeWasm() must be awaited first!");
21371 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_legacy(this_arg, min_value_msat, invoice_expiry_delta_secs);
21372 return nativeResponseValue;
21374 // 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);
21376 export function ChannelManager_create_inbound_payment_for_hash(this_arg: bigint, payment_hash: number, min_value_msat: bigint, invoice_expiry_delta_secs: number): bigint {
21377 if(!isWasmInitialized) {
21378 throw new Error("initializeWasm() must be awaited first!");
21380 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
21381 return nativeResponseValue;
21383 // 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);
21385 export function ChannelManager_create_inbound_payment_for_hash_legacy(this_arg: bigint, payment_hash: number, min_value_msat: bigint, invoice_expiry_delta_secs: number): bigint {
21386 if(!isWasmInitialized) {
21387 throw new Error("initializeWasm() must be awaited first!");
21389 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash_legacy(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
21390 return nativeResponseValue;
21392 // 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);
21394 export function ChannelManager_get_payment_preimage(this_arg: bigint, payment_hash: number, payment_secret: number): bigint {
21395 if(!isWasmInitialized) {
21396 throw new Error("initializeWasm() must be awaited first!");
21398 const nativeResponseValue = wasm.TS_ChannelManager_get_payment_preimage(this_arg, payment_hash, payment_secret);
21399 return nativeResponseValue;
21401 // MUST_USE_RES uint64_t ChannelManager_get_phantom_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
21403 export function ChannelManager_get_phantom_scid(this_arg: bigint): bigint {
21404 if(!isWasmInitialized) {
21405 throw new Error("initializeWasm() must be awaited first!");
21407 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_scid(this_arg);
21408 return nativeResponseValue;
21410 // MUST_USE_RES struct LDKPhantomRouteHints ChannelManager_get_phantom_route_hints(const struct LDKChannelManager *NONNULL_PTR this_arg);
21412 export function ChannelManager_get_phantom_route_hints(this_arg: bigint): bigint {
21413 if(!isWasmInitialized) {
21414 throw new Error("initializeWasm() must be awaited first!");
21416 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_route_hints(this_arg);
21417 return nativeResponseValue;
21419 // struct LDKMessageSendEventsProvider ChannelManager_as_MessageSendEventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
21421 export function ChannelManager_as_MessageSendEventsProvider(this_arg: bigint): bigint {
21422 if(!isWasmInitialized) {
21423 throw new Error("initializeWasm() must be awaited first!");
21425 const nativeResponseValue = wasm.TS_ChannelManager_as_MessageSendEventsProvider(this_arg);
21426 return nativeResponseValue;
21428 // struct LDKEventsProvider ChannelManager_as_EventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
21430 export function ChannelManager_as_EventsProvider(this_arg: bigint): bigint {
21431 if(!isWasmInitialized) {
21432 throw new Error("initializeWasm() must be awaited first!");
21434 const nativeResponseValue = wasm.TS_ChannelManager_as_EventsProvider(this_arg);
21435 return nativeResponseValue;
21437 // struct LDKListen ChannelManager_as_Listen(const struct LDKChannelManager *NONNULL_PTR this_arg);
21439 export function ChannelManager_as_Listen(this_arg: bigint): bigint {
21440 if(!isWasmInitialized) {
21441 throw new Error("initializeWasm() must be awaited first!");
21443 const nativeResponseValue = wasm.TS_ChannelManager_as_Listen(this_arg);
21444 return nativeResponseValue;
21446 // struct LDKConfirm ChannelManager_as_Confirm(const struct LDKChannelManager *NONNULL_PTR this_arg);
21448 export function ChannelManager_as_Confirm(this_arg: bigint): bigint {
21449 if(!isWasmInitialized) {
21450 throw new Error("initializeWasm() must be awaited first!");
21452 const nativeResponseValue = wasm.TS_ChannelManager_as_Confirm(this_arg);
21453 return nativeResponseValue;
21455 // void ChannelManager_await_persistable_update(const struct LDKChannelManager *NONNULL_PTR this_arg);
21457 export function ChannelManager_await_persistable_update(this_arg: bigint): void {
21458 if(!isWasmInitialized) {
21459 throw new Error("initializeWasm() must be awaited first!");
21461 const nativeResponseValue = wasm.TS_ChannelManager_await_persistable_update(this_arg);
21462 // debug statements here
21464 // MUST_USE_RES struct LDKFuture ChannelManager_get_persistable_update_future(const struct LDKChannelManager *NONNULL_PTR this_arg);
21466 export function ChannelManager_get_persistable_update_future(this_arg: bigint): bigint {
21467 if(!isWasmInitialized) {
21468 throw new Error("initializeWasm() must be awaited first!");
21470 const nativeResponseValue = wasm.TS_ChannelManager_get_persistable_update_future(this_arg);
21471 return nativeResponseValue;
21473 // MUST_USE_RES struct LDKBestBlock ChannelManager_current_best_block(const struct LDKChannelManager *NONNULL_PTR this_arg);
21475 export function ChannelManager_current_best_block(this_arg: bigint): bigint {
21476 if(!isWasmInitialized) {
21477 throw new Error("initializeWasm() must be awaited first!");
21479 const nativeResponseValue = wasm.TS_ChannelManager_current_best_block(this_arg);
21480 return nativeResponseValue;
21482 // struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
21484 export function ChannelManager_as_ChannelMessageHandler(this_arg: bigint): bigint {
21485 if(!isWasmInitialized) {
21486 throw new Error("initializeWasm() must be awaited first!");
21488 const nativeResponseValue = wasm.TS_ChannelManager_as_ChannelMessageHandler(this_arg);
21489 return nativeResponseValue;
21491 // struct LDKCVec_u8Z CounterpartyForwardingInfo_write(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR obj);
21493 export function CounterpartyForwardingInfo_write(obj: bigint): number {
21494 if(!isWasmInitialized) {
21495 throw new Error("initializeWasm() must be awaited first!");
21497 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_write(obj);
21498 return nativeResponseValue;
21500 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CounterpartyForwardingInfo_read(struct LDKu8slice ser);
21502 export function CounterpartyForwardingInfo_read(ser: number): bigint {
21503 if(!isWasmInitialized) {
21504 throw new Error("initializeWasm() must be awaited first!");
21506 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_read(ser);
21507 return nativeResponseValue;
21509 // struct LDKCVec_u8Z ChannelCounterparty_write(const struct LDKChannelCounterparty *NONNULL_PTR obj);
21511 export function ChannelCounterparty_write(obj: bigint): number {
21512 if(!isWasmInitialized) {
21513 throw new Error("initializeWasm() must be awaited first!");
21515 const nativeResponseValue = wasm.TS_ChannelCounterparty_write(obj);
21516 return nativeResponseValue;
21518 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ ChannelCounterparty_read(struct LDKu8slice ser);
21520 export function ChannelCounterparty_read(ser: number): bigint {
21521 if(!isWasmInitialized) {
21522 throw new Error("initializeWasm() must be awaited first!");
21524 const nativeResponseValue = wasm.TS_ChannelCounterparty_read(ser);
21525 return nativeResponseValue;
21527 // struct LDKCVec_u8Z ChannelDetails_write(const struct LDKChannelDetails *NONNULL_PTR obj);
21529 export function ChannelDetails_write(obj: bigint): number {
21530 if(!isWasmInitialized) {
21531 throw new Error("initializeWasm() must be awaited first!");
21533 const nativeResponseValue = wasm.TS_ChannelDetails_write(obj);
21534 return nativeResponseValue;
21536 // struct LDKCResult_ChannelDetailsDecodeErrorZ ChannelDetails_read(struct LDKu8slice ser);
21538 export function ChannelDetails_read(ser: number): bigint {
21539 if(!isWasmInitialized) {
21540 throw new Error("initializeWasm() must be awaited first!");
21542 const nativeResponseValue = wasm.TS_ChannelDetails_read(ser);
21543 return nativeResponseValue;
21545 // struct LDKCVec_u8Z PhantomRouteHints_write(const struct LDKPhantomRouteHints *NONNULL_PTR obj);
21547 export function PhantomRouteHints_write(obj: bigint): number {
21548 if(!isWasmInitialized) {
21549 throw new Error("initializeWasm() must be awaited first!");
21551 const nativeResponseValue = wasm.TS_PhantomRouteHints_write(obj);
21552 return nativeResponseValue;
21554 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ PhantomRouteHints_read(struct LDKu8slice ser);
21556 export function PhantomRouteHints_read(ser: number): bigint {
21557 if(!isWasmInitialized) {
21558 throw new Error("initializeWasm() must be awaited first!");
21560 const nativeResponseValue = wasm.TS_PhantomRouteHints_read(ser);
21561 return nativeResponseValue;
21563 // struct LDKCVec_u8Z ChannelManager_write(const struct LDKChannelManager *NONNULL_PTR obj);
21565 export function ChannelManager_write(obj: bigint): number {
21566 if(!isWasmInitialized) {
21567 throw new Error("initializeWasm() must be awaited first!");
21569 const nativeResponseValue = wasm.TS_ChannelManager_write(obj);
21570 return nativeResponseValue;
21572 // void ChannelManagerReadArgs_free(struct LDKChannelManagerReadArgs this_obj);
21574 export function ChannelManagerReadArgs_free(this_obj: bigint): void {
21575 if(!isWasmInitialized) {
21576 throw new Error("initializeWasm() must be awaited first!");
21578 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_free(this_obj);
21579 // debug statements here
21581 // const struct LDKKeysInterface *ChannelManagerReadArgs_get_keys_manager(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
21583 export function ChannelManagerReadArgs_get_keys_manager(this_ptr: bigint): bigint {
21584 if(!isWasmInitialized) {
21585 throw new Error("initializeWasm() must be awaited first!");
21587 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_keys_manager(this_ptr);
21588 return nativeResponseValue;
21590 // void ChannelManagerReadArgs_set_keys_manager(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKKeysInterface val);
21592 export function ChannelManagerReadArgs_set_keys_manager(this_ptr: bigint, val: bigint): void {
21593 if(!isWasmInitialized) {
21594 throw new Error("initializeWasm() must be awaited first!");
21596 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_keys_manager(this_ptr, val);
21597 // debug statements here
21599 // const struct LDKFeeEstimator *ChannelManagerReadArgs_get_fee_estimator(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
21601 export function ChannelManagerReadArgs_get_fee_estimator(this_ptr: bigint): bigint {
21602 if(!isWasmInitialized) {
21603 throw new Error("initializeWasm() must be awaited first!");
21605 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_fee_estimator(this_ptr);
21606 return nativeResponseValue;
21608 // void ChannelManagerReadArgs_set_fee_estimator(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKFeeEstimator val);
21610 export function ChannelManagerReadArgs_set_fee_estimator(this_ptr: bigint, val: bigint): void {
21611 if(!isWasmInitialized) {
21612 throw new Error("initializeWasm() must be awaited first!");
21614 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_fee_estimator(this_ptr, val);
21615 // debug statements here
21617 // const struct LDKWatch *ChannelManagerReadArgs_get_chain_monitor(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
21619 export function ChannelManagerReadArgs_get_chain_monitor(this_ptr: bigint): bigint {
21620 if(!isWasmInitialized) {
21621 throw new Error("initializeWasm() must be awaited first!");
21623 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_chain_monitor(this_ptr);
21624 return nativeResponseValue;
21626 // void ChannelManagerReadArgs_set_chain_monitor(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKWatch val);
21628 export function ChannelManagerReadArgs_set_chain_monitor(this_ptr: bigint, val: bigint): void {
21629 if(!isWasmInitialized) {
21630 throw new Error("initializeWasm() must be awaited first!");
21632 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_chain_monitor(this_ptr, val);
21633 // debug statements here
21635 // const struct LDKBroadcasterInterface *ChannelManagerReadArgs_get_tx_broadcaster(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
21637 export function ChannelManagerReadArgs_get_tx_broadcaster(this_ptr: bigint): bigint {
21638 if(!isWasmInitialized) {
21639 throw new Error("initializeWasm() must be awaited first!");
21641 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_tx_broadcaster(this_ptr);
21642 return nativeResponseValue;
21644 // void ChannelManagerReadArgs_set_tx_broadcaster(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKBroadcasterInterface val);
21646 export function ChannelManagerReadArgs_set_tx_broadcaster(this_ptr: bigint, val: bigint): void {
21647 if(!isWasmInitialized) {
21648 throw new Error("initializeWasm() must be awaited first!");
21650 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_tx_broadcaster(this_ptr, val);
21651 // debug statements here
21653 // const struct LDKLogger *ChannelManagerReadArgs_get_logger(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
21655 export function ChannelManagerReadArgs_get_logger(this_ptr: bigint): bigint {
21656 if(!isWasmInitialized) {
21657 throw new Error("initializeWasm() must be awaited first!");
21659 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_logger(this_ptr);
21660 return nativeResponseValue;
21662 // void ChannelManagerReadArgs_set_logger(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKLogger val);
21664 export function ChannelManagerReadArgs_set_logger(this_ptr: bigint, val: bigint): void {
21665 if(!isWasmInitialized) {
21666 throw new Error("initializeWasm() must be awaited first!");
21668 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_logger(this_ptr, val);
21669 // debug statements here
21671 // struct LDKUserConfig ChannelManagerReadArgs_get_default_config(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
21673 export function ChannelManagerReadArgs_get_default_config(this_ptr: bigint): bigint {
21674 if(!isWasmInitialized) {
21675 throw new Error("initializeWasm() must be awaited first!");
21677 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_default_config(this_ptr);
21678 return nativeResponseValue;
21680 // void ChannelManagerReadArgs_set_default_config(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKUserConfig val);
21682 export function ChannelManagerReadArgs_set_default_config(this_ptr: bigint, val: bigint): void {
21683 if(!isWasmInitialized) {
21684 throw new Error("initializeWasm() must be awaited first!");
21686 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_default_config(this_ptr, val);
21687 // debug statements here
21689 // 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);
21691 export function ChannelManagerReadArgs_new(keys_manager: bigint, fee_estimator: bigint, chain_monitor: bigint, tx_broadcaster: bigint, logger: bigint, default_config: bigint, channel_monitors: number): bigint {
21692 if(!isWasmInitialized) {
21693 throw new Error("initializeWasm() must be awaited first!");
21695 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_new(keys_manager, fee_estimator, chain_monitor, tx_broadcaster, logger, default_config, channel_monitors);
21696 return nativeResponseValue;
21698 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ C2Tuple_BlockHashChannelManagerZ_read(struct LDKu8slice ser, struct LDKChannelManagerReadArgs arg);
21700 export function C2Tuple_BlockHashChannelManagerZ_read(ser: number, arg: bigint): bigint {
21701 if(!isWasmInitialized) {
21702 throw new Error("initializeWasm() must be awaited first!");
21704 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_read(ser, arg);
21705 return nativeResponseValue;
21707 // void ExpandedKey_free(struct LDKExpandedKey this_obj);
21709 export function ExpandedKey_free(this_obj: bigint): void {
21710 if(!isWasmInitialized) {
21711 throw new Error("initializeWasm() must be awaited first!");
21713 const nativeResponseValue = wasm.TS_ExpandedKey_free(this_obj);
21714 // debug statements here
21716 // MUST_USE_RES struct LDKExpandedKey ExpandedKey_new(const uint8_t (*key_material)[32]);
21718 export function ExpandedKey_new(key_material: number): bigint {
21719 if(!isWasmInitialized) {
21720 throw new Error("initializeWasm() must be awaited first!");
21722 const nativeResponseValue = wasm.TS_ExpandedKey_new(key_material);
21723 return nativeResponseValue;
21725 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ create(const struct LDKExpandedKey *NONNULL_PTR keys, struct LDKCOption_u64Z min_value_msat, uint32_t invoice_expiry_delta_secs, const struct LDKKeysInterface *NONNULL_PTR keys_manager, uint64_t current_time);
21727 export function create(keys: bigint, min_value_msat: bigint, invoice_expiry_delta_secs: number, keys_manager: bigint, current_time: bigint): bigint {
21728 if(!isWasmInitialized) {
21729 throw new Error("initializeWasm() must be awaited first!");
21731 const nativeResponseValue = wasm.TS_create(keys, min_value_msat, invoice_expiry_delta_secs, keys_manager, current_time);
21732 return nativeResponseValue;
21734 // struct LDKCResult_PaymentSecretNoneZ create_from_hash(const struct LDKExpandedKey *NONNULL_PTR keys, struct LDKCOption_u64Z min_value_msat, struct LDKThirtyTwoBytes payment_hash, uint32_t invoice_expiry_delta_secs, uint64_t current_time);
21736 export function create_from_hash(keys: bigint, min_value_msat: bigint, payment_hash: number, invoice_expiry_delta_secs: number, current_time: bigint): bigint {
21737 if(!isWasmInitialized) {
21738 throw new Error("initializeWasm() must be awaited first!");
21740 const nativeResponseValue = wasm.TS_create_from_hash(keys, min_value_msat, payment_hash, invoice_expiry_delta_secs, current_time);
21741 return nativeResponseValue;
21743 // void DecodeError_free(struct LDKDecodeError this_obj);
21745 export function DecodeError_free(this_obj: bigint): void {
21746 if(!isWasmInitialized) {
21747 throw new Error("initializeWasm() must be awaited first!");
21749 const nativeResponseValue = wasm.TS_DecodeError_free(this_obj);
21750 // debug statements here
21752 // uint64_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg);
21754 export function DecodeError_clone_ptr(arg: bigint): bigint {
21755 if(!isWasmInitialized) {
21756 throw new Error("initializeWasm() must be awaited first!");
21758 const nativeResponseValue = wasm.TS_DecodeError_clone_ptr(arg);
21759 return nativeResponseValue;
21761 // struct LDKDecodeError DecodeError_clone(const struct LDKDecodeError *NONNULL_PTR orig);
21763 export function DecodeError_clone(orig: bigint): bigint {
21764 if(!isWasmInitialized) {
21765 throw new Error("initializeWasm() must be awaited first!");
21767 const nativeResponseValue = wasm.TS_DecodeError_clone(orig);
21768 return nativeResponseValue;
21770 // void Init_free(struct LDKInit this_obj);
21772 export function Init_free(this_obj: bigint): void {
21773 if(!isWasmInitialized) {
21774 throw new Error("initializeWasm() must be awaited first!");
21776 const nativeResponseValue = wasm.TS_Init_free(this_obj);
21777 // debug statements here
21779 // struct LDKInitFeatures Init_get_features(const struct LDKInit *NONNULL_PTR this_ptr);
21781 export function Init_get_features(this_ptr: bigint): bigint {
21782 if(!isWasmInitialized) {
21783 throw new Error("initializeWasm() must be awaited first!");
21785 const nativeResponseValue = wasm.TS_Init_get_features(this_ptr);
21786 return nativeResponseValue;
21788 // void Init_set_features(struct LDKInit *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
21790 export function Init_set_features(this_ptr: bigint, val: bigint): void {
21791 if(!isWasmInitialized) {
21792 throw new Error("initializeWasm() must be awaited first!");
21794 const nativeResponseValue = wasm.TS_Init_set_features(this_ptr, val);
21795 // debug statements here
21797 // struct LDKCOption_NetAddressZ Init_get_remote_network_address(const struct LDKInit *NONNULL_PTR this_ptr);
21799 export function Init_get_remote_network_address(this_ptr: bigint): bigint {
21800 if(!isWasmInitialized) {
21801 throw new Error("initializeWasm() must be awaited first!");
21803 const nativeResponseValue = wasm.TS_Init_get_remote_network_address(this_ptr);
21804 return nativeResponseValue;
21806 // void Init_set_remote_network_address(struct LDKInit *NONNULL_PTR this_ptr, struct LDKCOption_NetAddressZ val);
21808 export function Init_set_remote_network_address(this_ptr: bigint, val: bigint): void {
21809 if(!isWasmInitialized) {
21810 throw new Error("initializeWasm() must be awaited first!");
21812 const nativeResponseValue = wasm.TS_Init_set_remote_network_address(this_ptr, val);
21813 // debug statements here
21815 // MUST_USE_RES struct LDKInit Init_new(struct LDKInitFeatures features_arg, struct LDKCOption_NetAddressZ remote_network_address_arg);
21817 export function Init_new(features_arg: bigint, remote_network_address_arg: bigint): bigint {
21818 if(!isWasmInitialized) {
21819 throw new Error("initializeWasm() must be awaited first!");
21821 const nativeResponseValue = wasm.TS_Init_new(features_arg, remote_network_address_arg);
21822 return nativeResponseValue;
21824 // uint64_t Init_clone_ptr(LDKInit *NONNULL_PTR arg);
21826 export function Init_clone_ptr(arg: bigint): bigint {
21827 if(!isWasmInitialized) {
21828 throw new Error("initializeWasm() must be awaited first!");
21830 const nativeResponseValue = wasm.TS_Init_clone_ptr(arg);
21831 return nativeResponseValue;
21833 // struct LDKInit Init_clone(const struct LDKInit *NONNULL_PTR orig);
21835 export function Init_clone(orig: bigint): bigint {
21836 if(!isWasmInitialized) {
21837 throw new Error("initializeWasm() must be awaited first!");
21839 const nativeResponseValue = wasm.TS_Init_clone(orig);
21840 return nativeResponseValue;
21842 // void ErrorMessage_free(struct LDKErrorMessage this_obj);
21844 export function ErrorMessage_free(this_obj: bigint): void {
21845 if(!isWasmInitialized) {
21846 throw new Error("initializeWasm() must be awaited first!");
21848 const nativeResponseValue = wasm.TS_ErrorMessage_free(this_obj);
21849 // debug statements here
21851 // const uint8_t (*ErrorMessage_get_channel_id(const struct LDKErrorMessage *NONNULL_PTR this_ptr))[32];
21853 export function ErrorMessage_get_channel_id(this_ptr: bigint): number {
21854 if(!isWasmInitialized) {
21855 throw new Error("initializeWasm() must be awaited first!");
21857 const nativeResponseValue = wasm.TS_ErrorMessage_get_channel_id(this_ptr);
21858 return nativeResponseValue;
21860 // void ErrorMessage_set_channel_id(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21862 export function ErrorMessage_set_channel_id(this_ptr: bigint, val: number): void {
21863 if(!isWasmInitialized) {
21864 throw new Error("initializeWasm() must be awaited first!");
21866 const nativeResponseValue = wasm.TS_ErrorMessage_set_channel_id(this_ptr, val);
21867 // debug statements here
21869 // struct LDKStr ErrorMessage_get_data(const struct LDKErrorMessage *NONNULL_PTR this_ptr);
21871 export function ErrorMessage_get_data(this_ptr: bigint): number {
21872 if(!isWasmInitialized) {
21873 throw new Error("initializeWasm() must be awaited first!");
21875 const nativeResponseValue = wasm.TS_ErrorMessage_get_data(this_ptr);
21876 return nativeResponseValue;
21878 // void ErrorMessage_set_data(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKStr val);
21880 export function ErrorMessage_set_data(this_ptr: bigint, val: number): void {
21881 if(!isWasmInitialized) {
21882 throw new Error("initializeWasm() must be awaited first!");
21884 const nativeResponseValue = wasm.TS_ErrorMessage_set_data(this_ptr, val);
21885 // debug statements here
21887 // MUST_USE_RES struct LDKErrorMessage ErrorMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
21889 export function ErrorMessage_new(channel_id_arg: number, data_arg: number): bigint {
21890 if(!isWasmInitialized) {
21891 throw new Error("initializeWasm() must be awaited first!");
21893 const nativeResponseValue = wasm.TS_ErrorMessage_new(channel_id_arg, data_arg);
21894 return nativeResponseValue;
21896 // uint64_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg);
21898 export function ErrorMessage_clone_ptr(arg: bigint): bigint {
21899 if(!isWasmInitialized) {
21900 throw new Error("initializeWasm() must be awaited first!");
21902 const nativeResponseValue = wasm.TS_ErrorMessage_clone_ptr(arg);
21903 return nativeResponseValue;
21905 // struct LDKErrorMessage ErrorMessage_clone(const struct LDKErrorMessage *NONNULL_PTR orig);
21907 export function ErrorMessage_clone(orig: bigint): bigint {
21908 if(!isWasmInitialized) {
21909 throw new Error("initializeWasm() must be awaited first!");
21911 const nativeResponseValue = wasm.TS_ErrorMessage_clone(orig);
21912 return nativeResponseValue;
21914 // void WarningMessage_free(struct LDKWarningMessage this_obj);
21916 export function WarningMessage_free(this_obj: bigint): void {
21917 if(!isWasmInitialized) {
21918 throw new Error("initializeWasm() must be awaited first!");
21920 const nativeResponseValue = wasm.TS_WarningMessage_free(this_obj);
21921 // debug statements here
21923 // const uint8_t (*WarningMessage_get_channel_id(const struct LDKWarningMessage *NONNULL_PTR this_ptr))[32];
21925 export function WarningMessage_get_channel_id(this_ptr: bigint): number {
21926 if(!isWasmInitialized) {
21927 throw new Error("initializeWasm() must be awaited first!");
21929 const nativeResponseValue = wasm.TS_WarningMessage_get_channel_id(this_ptr);
21930 return nativeResponseValue;
21932 // void WarningMessage_set_channel_id(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21934 export function WarningMessage_set_channel_id(this_ptr: bigint, val: number): void {
21935 if(!isWasmInitialized) {
21936 throw new Error("initializeWasm() must be awaited first!");
21938 const nativeResponseValue = wasm.TS_WarningMessage_set_channel_id(this_ptr, val);
21939 // debug statements here
21941 // struct LDKStr WarningMessage_get_data(const struct LDKWarningMessage *NONNULL_PTR this_ptr);
21943 export function WarningMessage_get_data(this_ptr: bigint): number {
21944 if(!isWasmInitialized) {
21945 throw new Error("initializeWasm() must be awaited first!");
21947 const nativeResponseValue = wasm.TS_WarningMessage_get_data(this_ptr);
21948 return nativeResponseValue;
21950 // void WarningMessage_set_data(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKStr val);
21952 export function WarningMessage_set_data(this_ptr: bigint, val: number): void {
21953 if(!isWasmInitialized) {
21954 throw new Error("initializeWasm() must be awaited first!");
21956 const nativeResponseValue = wasm.TS_WarningMessage_set_data(this_ptr, val);
21957 // debug statements here
21959 // MUST_USE_RES struct LDKWarningMessage WarningMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
21961 export function WarningMessage_new(channel_id_arg: number, data_arg: number): bigint {
21962 if(!isWasmInitialized) {
21963 throw new Error("initializeWasm() must be awaited first!");
21965 const nativeResponseValue = wasm.TS_WarningMessage_new(channel_id_arg, data_arg);
21966 return nativeResponseValue;
21968 // uint64_t WarningMessage_clone_ptr(LDKWarningMessage *NONNULL_PTR arg);
21970 export function WarningMessage_clone_ptr(arg: bigint): bigint {
21971 if(!isWasmInitialized) {
21972 throw new Error("initializeWasm() must be awaited first!");
21974 const nativeResponseValue = wasm.TS_WarningMessage_clone_ptr(arg);
21975 return nativeResponseValue;
21977 // struct LDKWarningMessage WarningMessage_clone(const struct LDKWarningMessage *NONNULL_PTR orig);
21979 export function WarningMessage_clone(orig: bigint): bigint {
21980 if(!isWasmInitialized) {
21981 throw new Error("initializeWasm() must be awaited first!");
21983 const nativeResponseValue = wasm.TS_WarningMessage_clone(orig);
21984 return nativeResponseValue;
21986 // void Ping_free(struct LDKPing this_obj);
21988 export function Ping_free(this_obj: bigint): void {
21989 if(!isWasmInitialized) {
21990 throw new Error("initializeWasm() must be awaited first!");
21992 const nativeResponseValue = wasm.TS_Ping_free(this_obj);
21993 // debug statements here
21995 // uint16_t Ping_get_ponglen(const struct LDKPing *NONNULL_PTR this_ptr);
21997 export function Ping_get_ponglen(this_ptr: bigint): number {
21998 if(!isWasmInitialized) {
21999 throw new Error("initializeWasm() must be awaited first!");
22001 const nativeResponseValue = wasm.TS_Ping_get_ponglen(this_ptr);
22002 return nativeResponseValue;
22004 // void Ping_set_ponglen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
22006 export function Ping_set_ponglen(this_ptr: bigint, val: number): void {
22007 if(!isWasmInitialized) {
22008 throw new Error("initializeWasm() must be awaited first!");
22010 const nativeResponseValue = wasm.TS_Ping_set_ponglen(this_ptr, val);
22011 // debug statements here
22013 // uint16_t Ping_get_byteslen(const struct LDKPing *NONNULL_PTR this_ptr);
22015 export function Ping_get_byteslen(this_ptr: bigint): number {
22016 if(!isWasmInitialized) {
22017 throw new Error("initializeWasm() must be awaited first!");
22019 const nativeResponseValue = wasm.TS_Ping_get_byteslen(this_ptr);
22020 return nativeResponseValue;
22022 // void Ping_set_byteslen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
22024 export function Ping_set_byteslen(this_ptr: bigint, val: number): void {
22025 if(!isWasmInitialized) {
22026 throw new Error("initializeWasm() must be awaited first!");
22028 const nativeResponseValue = wasm.TS_Ping_set_byteslen(this_ptr, val);
22029 // debug statements here
22031 // MUST_USE_RES struct LDKPing Ping_new(uint16_t ponglen_arg, uint16_t byteslen_arg);
22033 export function Ping_new(ponglen_arg: number, byteslen_arg: number): bigint {
22034 if(!isWasmInitialized) {
22035 throw new Error("initializeWasm() must be awaited first!");
22037 const nativeResponseValue = wasm.TS_Ping_new(ponglen_arg, byteslen_arg);
22038 return nativeResponseValue;
22040 // uint64_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg);
22042 export function Ping_clone_ptr(arg: bigint): bigint {
22043 if(!isWasmInitialized) {
22044 throw new Error("initializeWasm() must be awaited first!");
22046 const nativeResponseValue = wasm.TS_Ping_clone_ptr(arg);
22047 return nativeResponseValue;
22049 // struct LDKPing Ping_clone(const struct LDKPing *NONNULL_PTR orig);
22051 export function Ping_clone(orig: bigint): bigint {
22052 if(!isWasmInitialized) {
22053 throw new Error("initializeWasm() must be awaited first!");
22055 const nativeResponseValue = wasm.TS_Ping_clone(orig);
22056 return nativeResponseValue;
22058 // void Pong_free(struct LDKPong this_obj);
22060 export function Pong_free(this_obj: bigint): void {
22061 if(!isWasmInitialized) {
22062 throw new Error("initializeWasm() must be awaited first!");
22064 const nativeResponseValue = wasm.TS_Pong_free(this_obj);
22065 // debug statements here
22067 // uint16_t Pong_get_byteslen(const struct LDKPong *NONNULL_PTR this_ptr);
22069 export function Pong_get_byteslen(this_ptr: bigint): number {
22070 if(!isWasmInitialized) {
22071 throw new Error("initializeWasm() must be awaited first!");
22073 const nativeResponseValue = wasm.TS_Pong_get_byteslen(this_ptr);
22074 return nativeResponseValue;
22076 // void Pong_set_byteslen(struct LDKPong *NONNULL_PTR this_ptr, uint16_t val);
22078 export function Pong_set_byteslen(this_ptr: bigint, val: number): void {
22079 if(!isWasmInitialized) {
22080 throw new Error("initializeWasm() must be awaited first!");
22082 const nativeResponseValue = wasm.TS_Pong_set_byteslen(this_ptr, val);
22083 // debug statements here
22085 // MUST_USE_RES struct LDKPong Pong_new(uint16_t byteslen_arg);
22087 export function Pong_new(byteslen_arg: number): bigint {
22088 if(!isWasmInitialized) {
22089 throw new Error("initializeWasm() must be awaited first!");
22091 const nativeResponseValue = wasm.TS_Pong_new(byteslen_arg);
22092 return nativeResponseValue;
22094 // uint64_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg);
22096 export function Pong_clone_ptr(arg: bigint): bigint {
22097 if(!isWasmInitialized) {
22098 throw new Error("initializeWasm() must be awaited first!");
22100 const nativeResponseValue = wasm.TS_Pong_clone_ptr(arg);
22101 return nativeResponseValue;
22103 // struct LDKPong Pong_clone(const struct LDKPong *NONNULL_PTR orig);
22105 export function Pong_clone(orig: bigint): bigint {
22106 if(!isWasmInitialized) {
22107 throw new Error("initializeWasm() must be awaited first!");
22109 const nativeResponseValue = wasm.TS_Pong_clone(orig);
22110 return nativeResponseValue;
22112 // void OpenChannel_free(struct LDKOpenChannel this_obj);
22114 export function OpenChannel_free(this_obj: bigint): void {
22115 if(!isWasmInitialized) {
22116 throw new Error("initializeWasm() must be awaited first!");
22118 const nativeResponseValue = wasm.TS_OpenChannel_free(this_obj);
22119 // debug statements here
22121 // const uint8_t (*OpenChannel_get_chain_hash(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
22123 export function OpenChannel_get_chain_hash(this_ptr: bigint): number {
22124 if(!isWasmInitialized) {
22125 throw new Error("initializeWasm() must be awaited first!");
22127 const nativeResponseValue = wasm.TS_OpenChannel_get_chain_hash(this_ptr);
22128 return nativeResponseValue;
22130 // void OpenChannel_set_chain_hash(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22132 export function OpenChannel_set_chain_hash(this_ptr: bigint, val: number): void {
22133 if(!isWasmInitialized) {
22134 throw new Error("initializeWasm() must be awaited first!");
22136 const nativeResponseValue = wasm.TS_OpenChannel_set_chain_hash(this_ptr, val);
22137 // debug statements here
22139 // const uint8_t (*OpenChannel_get_temporary_channel_id(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
22141 export function OpenChannel_get_temporary_channel_id(this_ptr: bigint): number {
22142 if(!isWasmInitialized) {
22143 throw new Error("initializeWasm() must be awaited first!");
22145 const nativeResponseValue = wasm.TS_OpenChannel_get_temporary_channel_id(this_ptr);
22146 return nativeResponseValue;
22148 // void OpenChannel_set_temporary_channel_id(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22150 export function OpenChannel_set_temporary_channel_id(this_ptr: bigint, val: number): void {
22151 if(!isWasmInitialized) {
22152 throw new Error("initializeWasm() must be awaited first!");
22154 const nativeResponseValue = wasm.TS_OpenChannel_set_temporary_channel_id(this_ptr, val);
22155 // debug statements here
22157 // uint64_t OpenChannel_get_funding_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22159 export function OpenChannel_get_funding_satoshis(this_ptr: bigint): bigint {
22160 if(!isWasmInitialized) {
22161 throw new Error("initializeWasm() must be awaited first!");
22163 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_satoshis(this_ptr);
22164 return nativeResponseValue;
22166 // void OpenChannel_set_funding_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
22168 export function OpenChannel_set_funding_satoshis(this_ptr: bigint, val: bigint): void {
22169 if(!isWasmInitialized) {
22170 throw new Error("initializeWasm() must be awaited first!");
22172 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_satoshis(this_ptr, val);
22173 // debug statements here
22175 // uint64_t OpenChannel_get_push_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22177 export function OpenChannel_get_push_msat(this_ptr: bigint): bigint {
22178 if(!isWasmInitialized) {
22179 throw new Error("initializeWasm() must be awaited first!");
22181 const nativeResponseValue = wasm.TS_OpenChannel_get_push_msat(this_ptr);
22182 return nativeResponseValue;
22184 // void OpenChannel_set_push_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
22186 export function OpenChannel_set_push_msat(this_ptr: bigint, val: bigint): void {
22187 if(!isWasmInitialized) {
22188 throw new Error("initializeWasm() must be awaited first!");
22190 const nativeResponseValue = wasm.TS_OpenChannel_set_push_msat(this_ptr, val);
22191 // debug statements here
22193 // uint64_t OpenChannel_get_dust_limit_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22195 export function OpenChannel_get_dust_limit_satoshis(this_ptr: bigint): bigint {
22196 if(!isWasmInitialized) {
22197 throw new Error("initializeWasm() must be awaited first!");
22199 const nativeResponseValue = wasm.TS_OpenChannel_get_dust_limit_satoshis(this_ptr);
22200 return nativeResponseValue;
22202 // void OpenChannel_set_dust_limit_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
22204 export function OpenChannel_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
22205 if(!isWasmInitialized) {
22206 throw new Error("initializeWasm() must be awaited first!");
22208 const nativeResponseValue = wasm.TS_OpenChannel_set_dust_limit_satoshis(this_ptr, val);
22209 // debug statements here
22211 // uint64_t OpenChannel_get_max_htlc_value_in_flight_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22213 export function OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
22214 if(!isWasmInitialized) {
22215 throw new Error("initializeWasm() must be awaited first!");
22217 const nativeResponseValue = wasm.TS_OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr);
22218 return nativeResponseValue;
22220 // void OpenChannel_set_max_htlc_value_in_flight_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
22222 export function OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
22223 if(!isWasmInitialized) {
22224 throw new Error("initializeWasm() must be awaited first!");
22226 const nativeResponseValue = wasm.TS_OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
22227 // debug statements here
22229 // uint64_t OpenChannel_get_channel_reserve_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22231 export function OpenChannel_get_channel_reserve_satoshis(this_ptr: bigint): bigint {
22232 if(!isWasmInitialized) {
22233 throw new Error("initializeWasm() must be awaited first!");
22235 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_reserve_satoshis(this_ptr);
22236 return nativeResponseValue;
22238 // void OpenChannel_set_channel_reserve_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
22240 export function OpenChannel_set_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
22241 if(!isWasmInitialized) {
22242 throw new Error("initializeWasm() must be awaited first!");
22244 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_reserve_satoshis(this_ptr, val);
22245 // debug statements here
22247 // uint64_t OpenChannel_get_htlc_minimum_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22249 export function OpenChannel_get_htlc_minimum_msat(this_ptr: bigint): bigint {
22250 if(!isWasmInitialized) {
22251 throw new Error("initializeWasm() must be awaited first!");
22253 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_minimum_msat(this_ptr);
22254 return nativeResponseValue;
22256 // void OpenChannel_set_htlc_minimum_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
22258 export function OpenChannel_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
22259 if(!isWasmInitialized) {
22260 throw new Error("initializeWasm() must be awaited first!");
22262 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_minimum_msat(this_ptr, val);
22263 // debug statements here
22265 // uint32_t OpenChannel_get_feerate_per_kw(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22267 export function OpenChannel_get_feerate_per_kw(this_ptr: bigint): number {
22268 if(!isWasmInitialized) {
22269 throw new Error("initializeWasm() must be awaited first!");
22271 const nativeResponseValue = wasm.TS_OpenChannel_get_feerate_per_kw(this_ptr);
22272 return nativeResponseValue;
22274 // void OpenChannel_set_feerate_per_kw(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint32_t val);
22276 export function OpenChannel_set_feerate_per_kw(this_ptr: bigint, val: number): void {
22277 if(!isWasmInitialized) {
22278 throw new Error("initializeWasm() must be awaited first!");
22280 const nativeResponseValue = wasm.TS_OpenChannel_set_feerate_per_kw(this_ptr, val);
22281 // debug statements here
22283 // uint16_t OpenChannel_get_to_self_delay(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22285 export function OpenChannel_get_to_self_delay(this_ptr: bigint): number {
22286 if(!isWasmInitialized) {
22287 throw new Error("initializeWasm() must be awaited first!");
22289 const nativeResponseValue = wasm.TS_OpenChannel_get_to_self_delay(this_ptr);
22290 return nativeResponseValue;
22292 // void OpenChannel_set_to_self_delay(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
22294 export function OpenChannel_set_to_self_delay(this_ptr: bigint, val: number): void {
22295 if(!isWasmInitialized) {
22296 throw new Error("initializeWasm() must be awaited first!");
22298 const nativeResponseValue = wasm.TS_OpenChannel_set_to_self_delay(this_ptr, val);
22299 // debug statements here
22301 // uint16_t OpenChannel_get_max_accepted_htlcs(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22303 export function OpenChannel_get_max_accepted_htlcs(this_ptr: bigint): number {
22304 if(!isWasmInitialized) {
22305 throw new Error("initializeWasm() must be awaited first!");
22307 const nativeResponseValue = wasm.TS_OpenChannel_get_max_accepted_htlcs(this_ptr);
22308 return nativeResponseValue;
22310 // void OpenChannel_set_max_accepted_htlcs(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
22312 export function OpenChannel_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
22313 if(!isWasmInitialized) {
22314 throw new Error("initializeWasm() must be awaited first!");
22316 const nativeResponseValue = wasm.TS_OpenChannel_set_max_accepted_htlcs(this_ptr, val);
22317 // debug statements here
22319 // struct LDKPublicKey OpenChannel_get_funding_pubkey(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22321 export function OpenChannel_get_funding_pubkey(this_ptr: bigint): number {
22322 if(!isWasmInitialized) {
22323 throw new Error("initializeWasm() must be awaited first!");
22325 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_pubkey(this_ptr);
22326 return nativeResponseValue;
22328 // void OpenChannel_set_funding_pubkey(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22330 export function OpenChannel_set_funding_pubkey(this_ptr: bigint, val: number): void {
22331 if(!isWasmInitialized) {
22332 throw new Error("initializeWasm() must be awaited first!");
22334 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_pubkey(this_ptr, val);
22335 // debug statements here
22337 // struct LDKPublicKey OpenChannel_get_revocation_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22339 export function OpenChannel_get_revocation_basepoint(this_ptr: bigint): number {
22340 if(!isWasmInitialized) {
22341 throw new Error("initializeWasm() must be awaited first!");
22343 const nativeResponseValue = wasm.TS_OpenChannel_get_revocation_basepoint(this_ptr);
22344 return nativeResponseValue;
22346 // void OpenChannel_set_revocation_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22348 export function OpenChannel_set_revocation_basepoint(this_ptr: bigint, val: number): void {
22349 if(!isWasmInitialized) {
22350 throw new Error("initializeWasm() must be awaited first!");
22352 const nativeResponseValue = wasm.TS_OpenChannel_set_revocation_basepoint(this_ptr, val);
22353 // debug statements here
22355 // struct LDKPublicKey OpenChannel_get_payment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22357 export function OpenChannel_get_payment_point(this_ptr: bigint): number {
22358 if(!isWasmInitialized) {
22359 throw new Error("initializeWasm() must be awaited first!");
22361 const nativeResponseValue = wasm.TS_OpenChannel_get_payment_point(this_ptr);
22362 return nativeResponseValue;
22364 // void OpenChannel_set_payment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22366 export function OpenChannel_set_payment_point(this_ptr: bigint, val: number): void {
22367 if(!isWasmInitialized) {
22368 throw new Error("initializeWasm() must be awaited first!");
22370 const nativeResponseValue = wasm.TS_OpenChannel_set_payment_point(this_ptr, val);
22371 // debug statements here
22373 // struct LDKPublicKey OpenChannel_get_delayed_payment_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22375 export function OpenChannel_get_delayed_payment_basepoint(this_ptr: bigint): number {
22376 if(!isWasmInitialized) {
22377 throw new Error("initializeWasm() must be awaited first!");
22379 const nativeResponseValue = wasm.TS_OpenChannel_get_delayed_payment_basepoint(this_ptr);
22380 return nativeResponseValue;
22382 // void OpenChannel_set_delayed_payment_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22384 export function OpenChannel_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
22385 if(!isWasmInitialized) {
22386 throw new Error("initializeWasm() must be awaited first!");
22388 const nativeResponseValue = wasm.TS_OpenChannel_set_delayed_payment_basepoint(this_ptr, val);
22389 // debug statements here
22391 // struct LDKPublicKey OpenChannel_get_htlc_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22393 export function OpenChannel_get_htlc_basepoint(this_ptr: bigint): number {
22394 if(!isWasmInitialized) {
22395 throw new Error("initializeWasm() must be awaited first!");
22397 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_basepoint(this_ptr);
22398 return nativeResponseValue;
22400 // void OpenChannel_set_htlc_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22402 export function OpenChannel_set_htlc_basepoint(this_ptr: bigint, val: number): void {
22403 if(!isWasmInitialized) {
22404 throw new Error("initializeWasm() must be awaited first!");
22406 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_basepoint(this_ptr, val);
22407 // debug statements here
22409 // struct LDKPublicKey OpenChannel_get_first_per_commitment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22411 export function OpenChannel_get_first_per_commitment_point(this_ptr: bigint): number {
22412 if(!isWasmInitialized) {
22413 throw new Error("initializeWasm() must be awaited first!");
22415 const nativeResponseValue = wasm.TS_OpenChannel_get_first_per_commitment_point(this_ptr);
22416 return nativeResponseValue;
22418 // void OpenChannel_set_first_per_commitment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22420 export function OpenChannel_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
22421 if(!isWasmInitialized) {
22422 throw new Error("initializeWasm() must be awaited first!");
22424 const nativeResponseValue = wasm.TS_OpenChannel_set_first_per_commitment_point(this_ptr, val);
22425 // debug statements here
22427 // uint8_t OpenChannel_get_channel_flags(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22429 export function OpenChannel_get_channel_flags(this_ptr: bigint): number {
22430 if(!isWasmInitialized) {
22431 throw new Error("initializeWasm() must be awaited first!");
22433 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_flags(this_ptr);
22434 return nativeResponseValue;
22436 // void OpenChannel_set_channel_flags(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint8_t val);
22438 export function OpenChannel_set_channel_flags(this_ptr: bigint, val: number): void {
22439 if(!isWasmInitialized) {
22440 throw new Error("initializeWasm() must be awaited first!");
22442 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_flags(this_ptr, val);
22443 // debug statements here
22445 // struct LDKChannelTypeFeatures OpenChannel_get_channel_type(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22447 export function OpenChannel_get_channel_type(this_ptr: bigint): bigint {
22448 if(!isWasmInitialized) {
22449 throw new Error("initializeWasm() must be awaited first!");
22451 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_type(this_ptr);
22452 return nativeResponseValue;
22454 // void OpenChannel_set_channel_type(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
22456 export function OpenChannel_set_channel_type(this_ptr: bigint, val: bigint): void {
22457 if(!isWasmInitialized) {
22458 throw new Error("initializeWasm() must be awaited first!");
22460 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_type(this_ptr, val);
22461 // debug statements here
22463 // uint64_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg);
22465 export function OpenChannel_clone_ptr(arg: bigint): bigint {
22466 if(!isWasmInitialized) {
22467 throw new Error("initializeWasm() must be awaited first!");
22469 const nativeResponseValue = wasm.TS_OpenChannel_clone_ptr(arg);
22470 return nativeResponseValue;
22472 // struct LDKOpenChannel OpenChannel_clone(const struct LDKOpenChannel *NONNULL_PTR orig);
22474 export function OpenChannel_clone(orig: bigint): bigint {
22475 if(!isWasmInitialized) {
22476 throw new Error("initializeWasm() must be awaited first!");
22478 const nativeResponseValue = wasm.TS_OpenChannel_clone(orig);
22479 return nativeResponseValue;
22481 // void AcceptChannel_free(struct LDKAcceptChannel this_obj);
22483 export function AcceptChannel_free(this_obj: bigint): void {
22484 if(!isWasmInitialized) {
22485 throw new Error("initializeWasm() must be awaited first!");
22487 const nativeResponseValue = wasm.TS_AcceptChannel_free(this_obj);
22488 // debug statements here
22490 // const uint8_t (*AcceptChannel_get_temporary_channel_id(const struct LDKAcceptChannel *NONNULL_PTR this_ptr))[32];
22492 export function AcceptChannel_get_temporary_channel_id(this_ptr: bigint): number {
22493 if(!isWasmInitialized) {
22494 throw new Error("initializeWasm() must be awaited first!");
22496 const nativeResponseValue = wasm.TS_AcceptChannel_get_temporary_channel_id(this_ptr);
22497 return nativeResponseValue;
22499 // void AcceptChannel_set_temporary_channel_id(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22501 export function AcceptChannel_set_temporary_channel_id(this_ptr: bigint, val: number): void {
22502 if(!isWasmInitialized) {
22503 throw new Error("initializeWasm() must be awaited first!");
22505 const nativeResponseValue = wasm.TS_AcceptChannel_set_temporary_channel_id(this_ptr, val);
22506 // debug statements here
22508 // uint64_t AcceptChannel_get_dust_limit_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
22510 export function AcceptChannel_get_dust_limit_satoshis(this_ptr: bigint): bigint {
22511 if(!isWasmInitialized) {
22512 throw new Error("initializeWasm() must be awaited first!");
22514 const nativeResponseValue = wasm.TS_AcceptChannel_get_dust_limit_satoshis(this_ptr);
22515 return nativeResponseValue;
22517 // void AcceptChannel_set_dust_limit_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
22519 export function AcceptChannel_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
22520 if(!isWasmInitialized) {
22521 throw new Error("initializeWasm() must be awaited first!");
22523 const nativeResponseValue = wasm.TS_AcceptChannel_set_dust_limit_satoshis(this_ptr, val);
22524 // debug statements here
22526 // uint64_t AcceptChannel_get_max_htlc_value_in_flight_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
22528 export function AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
22529 if(!isWasmInitialized) {
22530 throw new Error("initializeWasm() must be awaited first!");
22532 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr);
22533 return nativeResponseValue;
22535 // void AcceptChannel_set_max_htlc_value_in_flight_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
22537 export function AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
22538 if(!isWasmInitialized) {
22539 throw new Error("initializeWasm() must be awaited first!");
22541 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
22542 // debug statements here
22544 // uint64_t AcceptChannel_get_channel_reserve_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
22546 export function AcceptChannel_get_channel_reserve_satoshis(this_ptr: bigint): bigint {
22547 if(!isWasmInitialized) {
22548 throw new Error("initializeWasm() must be awaited first!");
22550 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_reserve_satoshis(this_ptr);
22551 return nativeResponseValue;
22553 // void AcceptChannel_set_channel_reserve_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
22555 export function AcceptChannel_set_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
22556 if(!isWasmInitialized) {
22557 throw new Error("initializeWasm() must be awaited first!");
22559 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_reserve_satoshis(this_ptr, val);
22560 // debug statements here
22562 // uint64_t AcceptChannel_get_htlc_minimum_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
22564 export function AcceptChannel_get_htlc_minimum_msat(this_ptr: bigint): bigint {
22565 if(!isWasmInitialized) {
22566 throw new Error("initializeWasm() must be awaited first!");
22568 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_minimum_msat(this_ptr);
22569 return nativeResponseValue;
22571 // void AcceptChannel_set_htlc_minimum_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
22573 export function AcceptChannel_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
22574 if(!isWasmInitialized) {
22575 throw new Error("initializeWasm() must be awaited first!");
22577 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_minimum_msat(this_ptr, val);
22578 // debug statements here
22580 // uint32_t AcceptChannel_get_minimum_depth(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
22582 export function AcceptChannel_get_minimum_depth(this_ptr: bigint): number {
22583 if(!isWasmInitialized) {
22584 throw new Error("initializeWasm() must be awaited first!");
22586 const nativeResponseValue = wasm.TS_AcceptChannel_get_minimum_depth(this_ptr);
22587 return nativeResponseValue;
22589 // void AcceptChannel_set_minimum_depth(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint32_t val);
22591 export function AcceptChannel_set_minimum_depth(this_ptr: bigint, val: number): void {
22592 if(!isWasmInitialized) {
22593 throw new Error("initializeWasm() must be awaited first!");
22595 const nativeResponseValue = wasm.TS_AcceptChannel_set_minimum_depth(this_ptr, val);
22596 // debug statements here
22598 // uint16_t AcceptChannel_get_to_self_delay(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
22600 export function AcceptChannel_get_to_self_delay(this_ptr: bigint): number {
22601 if(!isWasmInitialized) {
22602 throw new Error("initializeWasm() must be awaited first!");
22604 const nativeResponseValue = wasm.TS_AcceptChannel_get_to_self_delay(this_ptr);
22605 return nativeResponseValue;
22607 // void AcceptChannel_set_to_self_delay(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
22609 export function AcceptChannel_set_to_self_delay(this_ptr: bigint, val: number): void {
22610 if(!isWasmInitialized) {
22611 throw new Error("initializeWasm() must be awaited first!");
22613 const nativeResponseValue = wasm.TS_AcceptChannel_set_to_self_delay(this_ptr, val);
22614 // debug statements here
22616 // uint16_t AcceptChannel_get_max_accepted_htlcs(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
22618 export function AcceptChannel_get_max_accepted_htlcs(this_ptr: bigint): number {
22619 if(!isWasmInitialized) {
22620 throw new Error("initializeWasm() must be awaited first!");
22622 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_accepted_htlcs(this_ptr);
22623 return nativeResponseValue;
22625 // void AcceptChannel_set_max_accepted_htlcs(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
22627 export function AcceptChannel_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
22628 if(!isWasmInitialized) {
22629 throw new Error("initializeWasm() must be awaited first!");
22631 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_accepted_htlcs(this_ptr, val);
22632 // debug statements here
22634 // struct LDKPublicKey AcceptChannel_get_funding_pubkey(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
22636 export function AcceptChannel_get_funding_pubkey(this_ptr: bigint): number {
22637 if(!isWasmInitialized) {
22638 throw new Error("initializeWasm() must be awaited first!");
22640 const nativeResponseValue = wasm.TS_AcceptChannel_get_funding_pubkey(this_ptr);
22641 return nativeResponseValue;
22643 // void AcceptChannel_set_funding_pubkey(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22645 export function AcceptChannel_set_funding_pubkey(this_ptr: bigint, val: number): void {
22646 if(!isWasmInitialized) {
22647 throw new Error("initializeWasm() must be awaited first!");
22649 const nativeResponseValue = wasm.TS_AcceptChannel_set_funding_pubkey(this_ptr, val);
22650 // debug statements here
22652 // struct LDKPublicKey AcceptChannel_get_revocation_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
22654 export function AcceptChannel_get_revocation_basepoint(this_ptr: bigint): number {
22655 if(!isWasmInitialized) {
22656 throw new Error("initializeWasm() must be awaited first!");
22658 const nativeResponseValue = wasm.TS_AcceptChannel_get_revocation_basepoint(this_ptr);
22659 return nativeResponseValue;
22661 // void AcceptChannel_set_revocation_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22663 export function AcceptChannel_set_revocation_basepoint(this_ptr: bigint, val: number): void {
22664 if(!isWasmInitialized) {
22665 throw new Error("initializeWasm() must be awaited first!");
22667 const nativeResponseValue = wasm.TS_AcceptChannel_set_revocation_basepoint(this_ptr, val);
22668 // debug statements here
22670 // struct LDKPublicKey AcceptChannel_get_payment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
22672 export function AcceptChannel_get_payment_point(this_ptr: bigint): number {
22673 if(!isWasmInitialized) {
22674 throw new Error("initializeWasm() must be awaited first!");
22676 const nativeResponseValue = wasm.TS_AcceptChannel_get_payment_point(this_ptr);
22677 return nativeResponseValue;
22679 // void AcceptChannel_set_payment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22681 export function AcceptChannel_set_payment_point(this_ptr: bigint, val: number): void {
22682 if(!isWasmInitialized) {
22683 throw new Error("initializeWasm() must be awaited first!");
22685 const nativeResponseValue = wasm.TS_AcceptChannel_set_payment_point(this_ptr, val);
22686 // debug statements here
22688 // struct LDKPublicKey AcceptChannel_get_delayed_payment_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
22690 export function AcceptChannel_get_delayed_payment_basepoint(this_ptr: bigint): number {
22691 if(!isWasmInitialized) {
22692 throw new Error("initializeWasm() must be awaited first!");
22694 const nativeResponseValue = wasm.TS_AcceptChannel_get_delayed_payment_basepoint(this_ptr);
22695 return nativeResponseValue;
22697 // void AcceptChannel_set_delayed_payment_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22699 export function AcceptChannel_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
22700 if(!isWasmInitialized) {
22701 throw new Error("initializeWasm() must be awaited first!");
22703 const nativeResponseValue = wasm.TS_AcceptChannel_set_delayed_payment_basepoint(this_ptr, val);
22704 // debug statements here
22706 // struct LDKPublicKey AcceptChannel_get_htlc_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
22708 export function AcceptChannel_get_htlc_basepoint(this_ptr: bigint): number {
22709 if(!isWasmInitialized) {
22710 throw new Error("initializeWasm() must be awaited first!");
22712 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_basepoint(this_ptr);
22713 return nativeResponseValue;
22715 // void AcceptChannel_set_htlc_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22717 export function AcceptChannel_set_htlc_basepoint(this_ptr: bigint, val: number): void {
22718 if(!isWasmInitialized) {
22719 throw new Error("initializeWasm() must be awaited first!");
22721 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_basepoint(this_ptr, val);
22722 // debug statements here
22724 // struct LDKPublicKey AcceptChannel_get_first_per_commitment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
22726 export function AcceptChannel_get_first_per_commitment_point(this_ptr: bigint): number {
22727 if(!isWasmInitialized) {
22728 throw new Error("initializeWasm() must be awaited first!");
22730 const nativeResponseValue = wasm.TS_AcceptChannel_get_first_per_commitment_point(this_ptr);
22731 return nativeResponseValue;
22733 // void AcceptChannel_set_first_per_commitment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22735 export function AcceptChannel_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
22736 if(!isWasmInitialized) {
22737 throw new Error("initializeWasm() must be awaited first!");
22739 const nativeResponseValue = wasm.TS_AcceptChannel_set_first_per_commitment_point(this_ptr, val);
22740 // debug statements here
22742 // struct LDKChannelTypeFeatures AcceptChannel_get_channel_type(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
22744 export function AcceptChannel_get_channel_type(this_ptr: bigint): bigint {
22745 if(!isWasmInitialized) {
22746 throw new Error("initializeWasm() must be awaited first!");
22748 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_type(this_ptr);
22749 return nativeResponseValue;
22751 // void AcceptChannel_set_channel_type(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
22753 export function AcceptChannel_set_channel_type(this_ptr: bigint, val: bigint): void {
22754 if(!isWasmInitialized) {
22755 throw new Error("initializeWasm() must be awaited first!");
22757 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_type(this_ptr, val);
22758 // debug statements here
22760 // uint64_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg);
22762 export function AcceptChannel_clone_ptr(arg: bigint): bigint {
22763 if(!isWasmInitialized) {
22764 throw new Error("initializeWasm() must be awaited first!");
22766 const nativeResponseValue = wasm.TS_AcceptChannel_clone_ptr(arg);
22767 return nativeResponseValue;
22769 // struct LDKAcceptChannel AcceptChannel_clone(const struct LDKAcceptChannel *NONNULL_PTR orig);
22771 export function AcceptChannel_clone(orig: bigint): bigint {
22772 if(!isWasmInitialized) {
22773 throw new Error("initializeWasm() must be awaited first!");
22775 const nativeResponseValue = wasm.TS_AcceptChannel_clone(orig);
22776 return nativeResponseValue;
22778 // void FundingCreated_free(struct LDKFundingCreated this_obj);
22780 export function FundingCreated_free(this_obj: bigint): void {
22781 if(!isWasmInitialized) {
22782 throw new Error("initializeWasm() must be awaited first!");
22784 const nativeResponseValue = wasm.TS_FundingCreated_free(this_obj);
22785 // debug statements here
22787 // const uint8_t (*FundingCreated_get_temporary_channel_id(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
22789 export function FundingCreated_get_temporary_channel_id(this_ptr: bigint): number {
22790 if(!isWasmInitialized) {
22791 throw new Error("initializeWasm() must be awaited first!");
22793 const nativeResponseValue = wasm.TS_FundingCreated_get_temporary_channel_id(this_ptr);
22794 return nativeResponseValue;
22796 // void FundingCreated_set_temporary_channel_id(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22798 export function FundingCreated_set_temporary_channel_id(this_ptr: bigint, val: number): void {
22799 if(!isWasmInitialized) {
22800 throw new Error("initializeWasm() must be awaited first!");
22802 const nativeResponseValue = wasm.TS_FundingCreated_set_temporary_channel_id(this_ptr, val);
22803 // debug statements here
22805 // const uint8_t (*FundingCreated_get_funding_txid(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
22807 export function FundingCreated_get_funding_txid(this_ptr: bigint): number {
22808 if(!isWasmInitialized) {
22809 throw new Error("initializeWasm() must be awaited first!");
22811 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_txid(this_ptr);
22812 return nativeResponseValue;
22814 // void FundingCreated_set_funding_txid(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22816 export function FundingCreated_set_funding_txid(this_ptr: bigint, val: number): void {
22817 if(!isWasmInitialized) {
22818 throw new Error("initializeWasm() must be awaited first!");
22820 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_txid(this_ptr, val);
22821 // debug statements here
22823 // uint16_t FundingCreated_get_funding_output_index(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
22825 export function FundingCreated_get_funding_output_index(this_ptr: bigint): number {
22826 if(!isWasmInitialized) {
22827 throw new Error("initializeWasm() must be awaited first!");
22829 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_output_index(this_ptr);
22830 return nativeResponseValue;
22832 // void FundingCreated_set_funding_output_index(struct LDKFundingCreated *NONNULL_PTR this_ptr, uint16_t val);
22834 export function FundingCreated_set_funding_output_index(this_ptr: bigint, val: number): void {
22835 if(!isWasmInitialized) {
22836 throw new Error("initializeWasm() must be awaited first!");
22838 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_output_index(this_ptr, val);
22839 // debug statements here
22841 // struct LDKSignature FundingCreated_get_signature(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
22843 export function FundingCreated_get_signature(this_ptr: bigint): number {
22844 if(!isWasmInitialized) {
22845 throw new Error("initializeWasm() must be awaited first!");
22847 const nativeResponseValue = wasm.TS_FundingCreated_get_signature(this_ptr);
22848 return nativeResponseValue;
22850 // void FundingCreated_set_signature(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKSignature val);
22852 export function FundingCreated_set_signature(this_ptr: bigint, val: number): void {
22853 if(!isWasmInitialized) {
22854 throw new Error("initializeWasm() must be awaited first!");
22856 const nativeResponseValue = wasm.TS_FundingCreated_set_signature(this_ptr, val);
22857 // debug statements here
22859 // 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);
22861 export function FundingCreated_new(temporary_channel_id_arg: number, funding_txid_arg: number, funding_output_index_arg: number, signature_arg: number): bigint {
22862 if(!isWasmInitialized) {
22863 throw new Error("initializeWasm() must be awaited first!");
22865 const nativeResponseValue = wasm.TS_FundingCreated_new(temporary_channel_id_arg, funding_txid_arg, funding_output_index_arg, signature_arg);
22866 return nativeResponseValue;
22868 // uint64_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg);
22870 export function FundingCreated_clone_ptr(arg: bigint): bigint {
22871 if(!isWasmInitialized) {
22872 throw new Error("initializeWasm() must be awaited first!");
22874 const nativeResponseValue = wasm.TS_FundingCreated_clone_ptr(arg);
22875 return nativeResponseValue;
22877 // struct LDKFundingCreated FundingCreated_clone(const struct LDKFundingCreated *NONNULL_PTR orig);
22879 export function FundingCreated_clone(orig: bigint): bigint {
22880 if(!isWasmInitialized) {
22881 throw new Error("initializeWasm() must be awaited first!");
22883 const nativeResponseValue = wasm.TS_FundingCreated_clone(orig);
22884 return nativeResponseValue;
22886 // void FundingSigned_free(struct LDKFundingSigned this_obj);
22888 export function FundingSigned_free(this_obj: bigint): void {
22889 if(!isWasmInitialized) {
22890 throw new Error("initializeWasm() must be awaited first!");
22892 const nativeResponseValue = wasm.TS_FundingSigned_free(this_obj);
22893 // debug statements here
22895 // const uint8_t (*FundingSigned_get_channel_id(const struct LDKFundingSigned *NONNULL_PTR this_ptr))[32];
22897 export function FundingSigned_get_channel_id(this_ptr: bigint): number {
22898 if(!isWasmInitialized) {
22899 throw new Error("initializeWasm() must be awaited first!");
22901 const nativeResponseValue = wasm.TS_FundingSigned_get_channel_id(this_ptr);
22902 return nativeResponseValue;
22904 // void FundingSigned_set_channel_id(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22906 export function FundingSigned_set_channel_id(this_ptr: bigint, val: number): void {
22907 if(!isWasmInitialized) {
22908 throw new Error("initializeWasm() must be awaited first!");
22910 const nativeResponseValue = wasm.TS_FundingSigned_set_channel_id(this_ptr, val);
22911 // debug statements here
22913 // struct LDKSignature FundingSigned_get_signature(const struct LDKFundingSigned *NONNULL_PTR this_ptr);
22915 export function FundingSigned_get_signature(this_ptr: bigint): number {
22916 if(!isWasmInitialized) {
22917 throw new Error("initializeWasm() must be awaited first!");
22919 const nativeResponseValue = wasm.TS_FundingSigned_get_signature(this_ptr);
22920 return nativeResponseValue;
22922 // void FundingSigned_set_signature(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
22924 export function FundingSigned_set_signature(this_ptr: bigint, val: number): void {
22925 if(!isWasmInitialized) {
22926 throw new Error("initializeWasm() must be awaited first!");
22928 const nativeResponseValue = wasm.TS_FundingSigned_set_signature(this_ptr, val);
22929 // debug statements here
22931 // MUST_USE_RES struct LDKFundingSigned FundingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg);
22933 export function FundingSigned_new(channel_id_arg: number, signature_arg: number): bigint {
22934 if(!isWasmInitialized) {
22935 throw new Error("initializeWasm() must be awaited first!");
22937 const nativeResponseValue = wasm.TS_FundingSigned_new(channel_id_arg, signature_arg);
22938 return nativeResponseValue;
22940 // uint64_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg);
22942 export function FundingSigned_clone_ptr(arg: bigint): bigint {
22943 if(!isWasmInitialized) {
22944 throw new Error("initializeWasm() must be awaited first!");
22946 const nativeResponseValue = wasm.TS_FundingSigned_clone_ptr(arg);
22947 return nativeResponseValue;
22949 // struct LDKFundingSigned FundingSigned_clone(const struct LDKFundingSigned *NONNULL_PTR orig);
22951 export function FundingSigned_clone(orig: bigint): bigint {
22952 if(!isWasmInitialized) {
22953 throw new Error("initializeWasm() must be awaited first!");
22955 const nativeResponseValue = wasm.TS_FundingSigned_clone(orig);
22956 return nativeResponseValue;
22958 // void ChannelReady_free(struct LDKChannelReady this_obj);
22960 export function ChannelReady_free(this_obj: bigint): void {
22961 if(!isWasmInitialized) {
22962 throw new Error("initializeWasm() must be awaited first!");
22964 const nativeResponseValue = wasm.TS_ChannelReady_free(this_obj);
22965 // debug statements here
22967 // const uint8_t (*ChannelReady_get_channel_id(const struct LDKChannelReady *NONNULL_PTR this_ptr))[32];
22969 export function ChannelReady_get_channel_id(this_ptr: bigint): number {
22970 if(!isWasmInitialized) {
22971 throw new Error("initializeWasm() must be awaited first!");
22973 const nativeResponseValue = wasm.TS_ChannelReady_get_channel_id(this_ptr);
22974 return nativeResponseValue;
22976 // void ChannelReady_set_channel_id(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22978 export function ChannelReady_set_channel_id(this_ptr: bigint, val: number): void {
22979 if(!isWasmInitialized) {
22980 throw new Error("initializeWasm() must be awaited first!");
22982 const nativeResponseValue = wasm.TS_ChannelReady_set_channel_id(this_ptr, val);
22983 // debug statements here
22985 // struct LDKPublicKey ChannelReady_get_next_per_commitment_point(const struct LDKChannelReady *NONNULL_PTR this_ptr);
22987 export function ChannelReady_get_next_per_commitment_point(this_ptr: bigint): number {
22988 if(!isWasmInitialized) {
22989 throw new Error("initializeWasm() must be awaited first!");
22991 const nativeResponseValue = wasm.TS_ChannelReady_get_next_per_commitment_point(this_ptr);
22992 return nativeResponseValue;
22994 // void ChannelReady_set_next_per_commitment_point(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22996 export function ChannelReady_set_next_per_commitment_point(this_ptr: bigint, val: number): void {
22997 if(!isWasmInitialized) {
22998 throw new Error("initializeWasm() must be awaited first!");
23000 const nativeResponseValue = wasm.TS_ChannelReady_set_next_per_commitment_point(this_ptr, val);
23001 // debug statements here
23003 // struct LDKCOption_u64Z ChannelReady_get_short_channel_id_alias(const struct LDKChannelReady *NONNULL_PTR this_ptr);
23005 export function ChannelReady_get_short_channel_id_alias(this_ptr: bigint): bigint {
23006 if(!isWasmInitialized) {
23007 throw new Error("initializeWasm() must be awaited first!");
23009 const nativeResponseValue = wasm.TS_ChannelReady_get_short_channel_id_alias(this_ptr);
23010 return nativeResponseValue;
23012 // void ChannelReady_set_short_channel_id_alias(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
23014 export function ChannelReady_set_short_channel_id_alias(this_ptr: bigint, val: bigint): void {
23015 if(!isWasmInitialized) {
23016 throw new Error("initializeWasm() must be awaited first!");
23018 const nativeResponseValue = wasm.TS_ChannelReady_set_short_channel_id_alias(this_ptr, val);
23019 // debug statements here
23021 // MUST_USE_RES struct LDKChannelReady ChannelReady_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKPublicKey next_per_commitment_point_arg, struct LDKCOption_u64Z short_channel_id_alias_arg);
23023 export function ChannelReady_new(channel_id_arg: number, next_per_commitment_point_arg: number, short_channel_id_alias_arg: bigint): bigint {
23024 if(!isWasmInitialized) {
23025 throw new Error("initializeWasm() must be awaited first!");
23027 const nativeResponseValue = wasm.TS_ChannelReady_new(channel_id_arg, next_per_commitment_point_arg, short_channel_id_alias_arg);
23028 return nativeResponseValue;
23030 // uint64_t ChannelReady_clone_ptr(LDKChannelReady *NONNULL_PTR arg);
23032 export function ChannelReady_clone_ptr(arg: bigint): bigint {
23033 if(!isWasmInitialized) {
23034 throw new Error("initializeWasm() must be awaited first!");
23036 const nativeResponseValue = wasm.TS_ChannelReady_clone_ptr(arg);
23037 return nativeResponseValue;
23039 // struct LDKChannelReady ChannelReady_clone(const struct LDKChannelReady *NONNULL_PTR orig);
23041 export function ChannelReady_clone(orig: bigint): bigint {
23042 if(!isWasmInitialized) {
23043 throw new Error("initializeWasm() must be awaited first!");
23045 const nativeResponseValue = wasm.TS_ChannelReady_clone(orig);
23046 return nativeResponseValue;
23048 // void Shutdown_free(struct LDKShutdown this_obj);
23050 export function Shutdown_free(this_obj: bigint): void {
23051 if(!isWasmInitialized) {
23052 throw new Error("initializeWasm() must be awaited first!");
23054 const nativeResponseValue = wasm.TS_Shutdown_free(this_obj);
23055 // debug statements here
23057 // const uint8_t (*Shutdown_get_channel_id(const struct LDKShutdown *NONNULL_PTR this_ptr))[32];
23059 export function Shutdown_get_channel_id(this_ptr: bigint): number {
23060 if(!isWasmInitialized) {
23061 throw new Error("initializeWasm() must be awaited first!");
23063 const nativeResponseValue = wasm.TS_Shutdown_get_channel_id(this_ptr);
23064 return nativeResponseValue;
23066 // void Shutdown_set_channel_id(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23068 export function Shutdown_set_channel_id(this_ptr: bigint, val: number): void {
23069 if(!isWasmInitialized) {
23070 throw new Error("initializeWasm() must be awaited first!");
23072 const nativeResponseValue = wasm.TS_Shutdown_set_channel_id(this_ptr, val);
23073 // debug statements here
23075 // struct LDKu8slice Shutdown_get_scriptpubkey(const struct LDKShutdown *NONNULL_PTR this_ptr);
23077 export function Shutdown_get_scriptpubkey(this_ptr: bigint): number {
23078 if(!isWasmInitialized) {
23079 throw new Error("initializeWasm() must be awaited first!");
23081 const nativeResponseValue = wasm.TS_Shutdown_get_scriptpubkey(this_ptr);
23082 return nativeResponseValue;
23084 // void Shutdown_set_scriptpubkey(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
23086 export function Shutdown_set_scriptpubkey(this_ptr: bigint, val: number): void {
23087 if(!isWasmInitialized) {
23088 throw new Error("initializeWasm() must be awaited first!");
23090 const nativeResponseValue = wasm.TS_Shutdown_set_scriptpubkey(this_ptr, val);
23091 // debug statements here
23093 // MUST_USE_RES struct LDKShutdown Shutdown_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z scriptpubkey_arg);
23095 export function Shutdown_new(channel_id_arg: number, scriptpubkey_arg: number): bigint {
23096 if(!isWasmInitialized) {
23097 throw new Error("initializeWasm() must be awaited first!");
23099 const nativeResponseValue = wasm.TS_Shutdown_new(channel_id_arg, scriptpubkey_arg);
23100 return nativeResponseValue;
23102 // uint64_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg);
23104 export function Shutdown_clone_ptr(arg: bigint): bigint {
23105 if(!isWasmInitialized) {
23106 throw new Error("initializeWasm() must be awaited first!");
23108 const nativeResponseValue = wasm.TS_Shutdown_clone_ptr(arg);
23109 return nativeResponseValue;
23111 // struct LDKShutdown Shutdown_clone(const struct LDKShutdown *NONNULL_PTR orig);
23113 export function Shutdown_clone(orig: bigint): bigint {
23114 if(!isWasmInitialized) {
23115 throw new Error("initializeWasm() must be awaited first!");
23117 const nativeResponseValue = wasm.TS_Shutdown_clone(orig);
23118 return nativeResponseValue;
23120 // void ClosingSignedFeeRange_free(struct LDKClosingSignedFeeRange this_obj);
23122 export function ClosingSignedFeeRange_free(this_obj: bigint): void {
23123 if(!isWasmInitialized) {
23124 throw new Error("initializeWasm() must be awaited first!");
23126 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_free(this_obj);
23127 // debug statements here
23129 // uint64_t ClosingSignedFeeRange_get_min_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
23131 export function ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr: bigint): bigint {
23132 if(!isWasmInitialized) {
23133 throw new Error("initializeWasm() must be awaited first!");
23135 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr);
23136 return nativeResponseValue;
23138 // void ClosingSignedFeeRange_set_min_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
23140 export function ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr: bigint, val: bigint): void {
23141 if(!isWasmInitialized) {
23142 throw new Error("initializeWasm() must be awaited first!");
23144 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr, val);
23145 // debug statements here
23147 // uint64_t ClosingSignedFeeRange_get_max_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
23149 export function ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr: bigint): bigint {
23150 if(!isWasmInitialized) {
23151 throw new Error("initializeWasm() must be awaited first!");
23153 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr);
23154 return nativeResponseValue;
23156 // void ClosingSignedFeeRange_set_max_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
23158 export function ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr: bigint, val: bigint): void {
23159 if(!isWasmInitialized) {
23160 throw new Error("initializeWasm() must be awaited first!");
23162 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr, val);
23163 // debug statements here
23165 // MUST_USE_RES struct LDKClosingSignedFeeRange ClosingSignedFeeRange_new(uint64_t min_fee_satoshis_arg, uint64_t max_fee_satoshis_arg);
23167 export function ClosingSignedFeeRange_new(min_fee_satoshis_arg: bigint, max_fee_satoshis_arg: bigint): bigint {
23168 if(!isWasmInitialized) {
23169 throw new Error("initializeWasm() must be awaited first!");
23171 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
23172 return nativeResponseValue;
23174 // uint64_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg);
23176 export function ClosingSignedFeeRange_clone_ptr(arg: bigint): bigint {
23177 if(!isWasmInitialized) {
23178 throw new Error("initializeWasm() must be awaited first!");
23180 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone_ptr(arg);
23181 return nativeResponseValue;
23183 // struct LDKClosingSignedFeeRange ClosingSignedFeeRange_clone(const struct LDKClosingSignedFeeRange *NONNULL_PTR orig);
23185 export function ClosingSignedFeeRange_clone(orig: bigint): bigint {
23186 if(!isWasmInitialized) {
23187 throw new Error("initializeWasm() must be awaited first!");
23189 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone(orig);
23190 return nativeResponseValue;
23192 // void ClosingSigned_free(struct LDKClosingSigned this_obj);
23194 export function ClosingSigned_free(this_obj: bigint): void {
23195 if(!isWasmInitialized) {
23196 throw new Error("initializeWasm() must be awaited first!");
23198 const nativeResponseValue = wasm.TS_ClosingSigned_free(this_obj);
23199 // debug statements here
23201 // const uint8_t (*ClosingSigned_get_channel_id(const struct LDKClosingSigned *NONNULL_PTR this_ptr))[32];
23203 export function ClosingSigned_get_channel_id(this_ptr: bigint): number {
23204 if(!isWasmInitialized) {
23205 throw new Error("initializeWasm() must be awaited first!");
23207 const nativeResponseValue = wasm.TS_ClosingSigned_get_channel_id(this_ptr);
23208 return nativeResponseValue;
23210 // void ClosingSigned_set_channel_id(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23212 export function ClosingSigned_set_channel_id(this_ptr: bigint, val: number): void {
23213 if(!isWasmInitialized) {
23214 throw new Error("initializeWasm() must be awaited first!");
23216 const nativeResponseValue = wasm.TS_ClosingSigned_set_channel_id(this_ptr, val);
23217 // debug statements here
23219 // uint64_t ClosingSigned_get_fee_satoshis(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
23221 export function ClosingSigned_get_fee_satoshis(this_ptr: bigint): bigint {
23222 if(!isWasmInitialized) {
23223 throw new Error("initializeWasm() must be awaited first!");
23225 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_satoshis(this_ptr);
23226 return nativeResponseValue;
23228 // void ClosingSigned_set_fee_satoshis(struct LDKClosingSigned *NONNULL_PTR this_ptr, uint64_t val);
23230 export function ClosingSigned_set_fee_satoshis(this_ptr: bigint, val: bigint): void {
23231 if(!isWasmInitialized) {
23232 throw new Error("initializeWasm() must be awaited first!");
23234 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_satoshis(this_ptr, val);
23235 // debug statements here
23237 // struct LDKSignature ClosingSigned_get_signature(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
23239 export function ClosingSigned_get_signature(this_ptr: bigint): number {
23240 if(!isWasmInitialized) {
23241 throw new Error("initializeWasm() must be awaited first!");
23243 const nativeResponseValue = wasm.TS_ClosingSigned_get_signature(this_ptr);
23244 return nativeResponseValue;
23246 // void ClosingSigned_set_signature(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
23248 export function ClosingSigned_set_signature(this_ptr: bigint, val: number): void {
23249 if(!isWasmInitialized) {
23250 throw new Error("initializeWasm() must be awaited first!");
23252 const nativeResponseValue = wasm.TS_ClosingSigned_set_signature(this_ptr, val);
23253 // debug statements here
23255 // struct LDKClosingSignedFeeRange ClosingSigned_get_fee_range(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
23257 export function ClosingSigned_get_fee_range(this_ptr: bigint): bigint {
23258 if(!isWasmInitialized) {
23259 throw new Error("initializeWasm() must be awaited first!");
23261 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_range(this_ptr);
23262 return nativeResponseValue;
23264 // void ClosingSigned_set_fee_range(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKClosingSignedFeeRange val);
23266 export function ClosingSigned_set_fee_range(this_ptr: bigint, val: bigint): void {
23267 if(!isWasmInitialized) {
23268 throw new Error("initializeWasm() must be awaited first!");
23270 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_range(this_ptr, val);
23271 // debug statements here
23273 // 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);
23275 export function ClosingSigned_new(channel_id_arg: number, fee_satoshis_arg: bigint, signature_arg: number, fee_range_arg: bigint): bigint {
23276 if(!isWasmInitialized) {
23277 throw new Error("initializeWasm() must be awaited first!");
23279 const nativeResponseValue = wasm.TS_ClosingSigned_new(channel_id_arg, fee_satoshis_arg, signature_arg, fee_range_arg);
23280 return nativeResponseValue;
23282 // uint64_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg);
23284 export function ClosingSigned_clone_ptr(arg: bigint): bigint {
23285 if(!isWasmInitialized) {
23286 throw new Error("initializeWasm() must be awaited first!");
23288 const nativeResponseValue = wasm.TS_ClosingSigned_clone_ptr(arg);
23289 return nativeResponseValue;
23291 // struct LDKClosingSigned ClosingSigned_clone(const struct LDKClosingSigned *NONNULL_PTR orig);
23293 export function ClosingSigned_clone(orig: bigint): bigint {
23294 if(!isWasmInitialized) {
23295 throw new Error("initializeWasm() must be awaited first!");
23297 const nativeResponseValue = wasm.TS_ClosingSigned_clone(orig);
23298 return nativeResponseValue;
23300 // void UpdateAddHTLC_free(struct LDKUpdateAddHTLC this_obj);
23302 export function UpdateAddHTLC_free(this_obj: bigint): void {
23303 if(!isWasmInitialized) {
23304 throw new Error("initializeWasm() must be awaited first!");
23306 const nativeResponseValue = wasm.TS_UpdateAddHTLC_free(this_obj);
23307 // debug statements here
23309 // const uint8_t (*UpdateAddHTLC_get_channel_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
23311 export function UpdateAddHTLC_get_channel_id(this_ptr: bigint): number {
23312 if(!isWasmInitialized) {
23313 throw new Error("initializeWasm() must be awaited first!");
23315 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_channel_id(this_ptr);
23316 return nativeResponseValue;
23318 // void UpdateAddHTLC_set_channel_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23320 export function UpdateAddHTLC_set_channel_id(this_ptr: bigint, val: number): void {
23321 if(!isWasmInitialized) {
23322 throw new Error("initializeWasm() must be awaited first!");
23324 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_channel_id(this_ptr, val);
23325 // debug statements here
23327 // uint64_t UpdateAddHTLC_get_htlc_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
23329 export function UpdateAddHTLC_get_htlc_id(this_ptr: bigint): bigint {
23330 if(!isWasmInitialized) {
23331 throw new Error("initializeWasm() must be awaited first!");
23333 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_htlc_id(this_ptr);
23334 return nativeResponseValue;
23336 // void UpdateAddHTLC_set_htlc_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
23338 export function UpdateAddHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
23339 if(!isWasmInitialized) {
23340 throw new Error("initializeWasm() must be awaited first!");
23342 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_htlc_id(this_ptr, val);
23343 // debug statements here
23345 // uint64_t UpdateAddHTLC_get_amount_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
23347 export function UpdateAddHTLC_get_amount_msat(this_ptr: bigint): bigint {
23348 if(!isWasmInitialized) {
23349 throw new Error("initializeWasm() must be awaited first!");
23351 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_amount_msat(this_ptr);
23352 return nativeResponseValue;
23354 // void UpdateAddHTLC_set_amount_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
23356 export function UpdateAddHTLC_set_amount_msat(this_ptr: bigint, val: bigint): void {
23357 if(!isWasmInitialized) {
23358 throw new Error("initializeWasm() must be awaited first!");
23360 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_amount_msat(this_ptr, val);
23361 // debug statements here
23363 // const uint8_t (*UpdateAddHTLC_get_payment_hash(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
23365 export function UpdateAddHTLC_get_payment_hash(this_ptr: bigint): number {
23366 if(!isWasmInitialized) {
23367 throw new Error("initializeWasm() must be awaited first!");
23369 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_payment_hash(this_ptr);
23370 return nativeResponseValue;
23372 // void UpdateAddHTLC_set_payment_hash(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23374 export function UpdateAddHTLC_set_payment_hash(this_ptr: bigint, val: number): void {
23375 if(!isWasmInitialized) {
23376 throw new Error("initializeWasm() must be awaited first!");
23378 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_payment_hash(this_ptr, val);
23379 // debug statements here
23381 // uint32_t UpdateAddHTLC_get_cltv_expiry(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
23383 export function UpdateAddHTLC_get_cltv_expiry(this_ptr: bigint): number {
23384 if(!isWasmInitialized) {
23385 throw new Error("initializeWasm() must be awaited first!");
23387 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_cltv_expiry(this_ptr);
23388 return nativeResponseValue;
23390 // void UpdateAddHTLC_set_cltv_expiry(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint32_t val);
23392 export function UpdateAddHTLC_set_cltv_expiry(this_ptr: bigint, val: number): void {
23393 if(!isWasmInitialized) {
23394 throw new Error("initializeWasm() must be awaited first!");
23396 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_cltv_expiry(this_ptr, val);
23397 // debug statements here
23399 // uint64_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg);
23401 export function UpdateAddHTLC_clone_ptr(arg: bigint): bigint {
23402 if(!isWasmInitialized) {
23403 throw new Error("initializeWasm() must be awaited first!");
23405 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone_ptr(arg);
23406 return nativeResponseValue;
23408 // struct LDKUpdateAddHTLC UpdateAddHTLC_clone(const struct LDKUpdateAddHTLC *NONNULL_PTR orig);
23410 export function UpdateAddHTLC_clone(orig: bigint): bigint {
23411 if(!isWasmInitialized) {
23412 throw new Error("initializeWasm() must be awaited first!");
23414 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone(orig);
23415 return nativeResponseValue;
23417 // void OnionMessage_free(struct LDKOnionMessage this_obj);
23419 export function OnionMessage_free(this_obj: bigint): void {
23420 if(!isWasmInitialized) {
23421 throw new Error("initializeWasm() must be awaited first!");
23423 const nativeResponseValue = wasm.TS_OnionMessage_free(this_obj);
23424 // debug statements here
23426 // struct LDKPublicKey OnionMessage_get_blinding_point(const struct LDKOnionMessage *NONNULL_PTR this_ptr);
23428 export function OnionMessage_get_blinding_point(this_ptr: bigint): number {
23429 if(!isWasmInitialized) {
23430 throw new Error("initializeWasm() must be awaited first!");
23432 const nativeResponseValue = wasm.TS_OnionMessage_get_blinding_point(this_ptr);
23433 return nativeResponseValue;
23435 // void OnionMessage_set_blinding_point(struct LDKOnionMessage *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23437 export function OnionMessage_set_blinding_point(this_ptr: bigint, val: number): void {
23438 if(!isWasmInitialized) {
23439 throw new Error("initializeWasm() must be awaited first!");
23441 const nativeResponseValue = wasm.TS_OnionMessage_set_blinding_point(this_ptr, val);
23442 // debug statements here
23444 // uint64_t OnionMessage_clone_ptr(LDKOnionMessage *NONNULL_PTR arg);
23446 export function OnionMessage_clone_ptr(arg: bigint): bigint {
23447 if(!isWasmInitialized) {
23448 throw new Error("initializeWasm() must be awaited first!");
23450 const nativeResponseValue = wasm.TS_OnionMessage_clone_ptr(arg);
23451 return nativeResponseValue;
23453 // struct LDKOnionMessage OnionMessage_clone(const struct LDKOnionMessage *NONNULL_PTR orig);
23455 export function OnionMessage_clone(orig: bigint): bigint {
23456 if(!isWasmInitialized) {
23457 throw new Error("initializeWasm() must be awaited first!");
23459 const nativeResponseValue = wasm.TS_OnionMessage_clone(orig);
23460 return nativeResponseValue;
23462 // void UpdateFulfillHTLC_free(struct LDKUpdateFulfillHTLC this_obj);
23464 export function UpdateFulfillHTLC_free(this_obj: bigint): void {
23465 if(!isWasmInitialized) {
23466 throw new Error("initializeWasm() must be awaited first!");
23468 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_free(this_obj);
23469 // debug statements here
23471 // const uint8_t (*UpdateFulfillHTLC_get_channel_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
23473 export function UpdateFulfillHTLC_get_channel_id(this_ptr: bigint): number {
23474 if(!isWasmInitialized) {
23475 throw new Error("initializeWasm() must be awaited first!");
23477 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_channel_id(this_ptr);
23478 return nativeResponseValue;
23480 // void UpdateFulfillHTLC_set_channel_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23482 export function UpdateFulfillHTLC_set_channel_id(this_ptr: bigint, val: number): void {
23483 if(!isWasmInitialized) {
23484 throw new Error("initializeWasm() must be awaited first!");
23486 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_channel_id(this_ptr, val);
23487 // debug statements here
23489 // uint64_t UpdateFulfillHTLC_get_htlc_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr);
23491 export function UpdateFulfillHTLC_get_htlc_id(this_ptr: bigint): bigint {
23492 if(!isWasmInitialized) {
23493 throw new Error("initializeWasm() must be awaited first!");
23495 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_htlc_id(this_ptr);
23496 return nativeResponseValue;
23498 // void UpdateFulfillHTLC_set_htlc_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, uint64_t val);
23500 export function UpdateFulfillHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
23501 if(!isWasmInitialized) {
23502 throw new Error("initializeWasm() must be awaited first!");
23504 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_htlc_id(this_ptr, val);
23505 // debug statements here
23507 // const uint8_t (*UpdateFulfillHTLC_get_payment_preimage(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
23509 export function UpdateFulfillHTLC_get_payment_preimage(this_ptr: bigint): number {
23510 if(!isWasmInitialized) {
23511 throw new Error("initializeWasm() must be awaited first!");
23513 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_payment_preimage(this_ptr);
23514 return nativeResponseValue;
23516 // void UpdateFulfillHTLC_set_payment_preimage(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23518 export function UpdateFulfillHTLC_set_payment_preimage(this_ptr: bigint, val: number): void {
23519 if(!isWasmInitialized) {
23520 throw new Error("initializeWasm() must be awaited first!");
23522 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_payment_preimage(this_ptr, val);
23523 // debug statements here
23525 // MUST_USE_RES struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t htlc_id_arg, struct LDKThirtyTwoBytes payment_preimage_arg);
23527 export function UpdateFulfillHTLC_new(channel_id_arg: number, htlc_id_arg: bigint, payment_preimage_arg: number): bigint {
23528 if(!isWasmInitialized) {
23529 throw new Error("initializeWasm() must be awaited first!");
23531 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_new(channel_id_arg, htlc_id_arg, payment_preimage_arg);
23532 return nativeResponseValue;
23534 // uint64_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg);
23536 export function UpdateFulfillHTLC_clone_ptr(arg: bigint): bigint {
23537 if(!isWasmInitialized) {
23538 throw new Error("initializeWasm() must be awaited first!");
23540 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone_ptr(arg);
23541 return nativeResponseValue;
23543 // struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_clone(const struct LDKUpdateFulfillHTLC *NONNULL_PTR orig);
23545 export function UpdateFulfillHTLC_clone(orig: bigint): bigint {
23546 if(!isWasmInitialized) {
23547 throw new Error("initializeWasm() must be awaited first!");
23549 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone(orig);
23550 return nativeResponseValue;
23552 // void UpdateFailHTLC_free(struct LDKUpdateFailHTLC this_obj);
23554 export function UpdateFailHTLC_free(this_obj: bigint): void {
23555 if(!isWasmInitialized) {
23556 throw new Error("initializeWasm() must be awaited first!");
23558 const nativeResponseValue = wasm.TS_UpdateFailHTLC_free(this_obj);
23559 // debug statements here
23561 // const uint8_t (*UpdateFailHTLC_get_channel_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr))[32];
23563 export function UpdateFailHTLC_get_channel_id(this_ptr: bigint): number {
23564 if(!isWasmInitialized) {
23565 throw new Error("initializeWasm() must be awaited first!");
23567 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_channel_id(this_ptr);
23568 return nativeResponseValue;
23570 // void UpdateFailHTLC_set_channel_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23572 export function UpdateFailHTLC_set_channel_id(this_ptr: bigint, val: number): void {
23573 if(!isWasmInitialized) {
23574 throw new Error("initializeWasm() must be awaited first!");
23576 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_channel_id(this_ptr, val);
23577 // debug statements here
23579 // uint64_t UpdateFailHTLC_get_htlc_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr);
23581 export function UpdateFailHTLC_get_htlc_id(this_ptr: bigint): bigint {
23582 if(!isWasmInitialized) {
23583 throw new Error("initializeWasm() must be awaited first!");
23585 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_htlc_id(this_ptr);
23586 return nativeResponseValue;
23588 // void UpdateFailHTLC_set_htlc_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, uint64_t val);
23590 export function UpdateFailHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
23591 if(!isWasmInitialized) {
23592 throw new Error("initializeWasm() must be awaited first!");
23594 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_htlc_id(this_ptr, val);
23595 // debug statements here
23597 // uint64_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg);
23599 export function UpdateFailHTLC_clone_ptr(arg: bigint): bigint {
23600 if(!isWasmInitialized) {
23601 throw new Error("initializeWasm() must be awaited first!");
23603 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone_ptr(arg);
23604 return nativeResponseValue;
23606 // struct LDKUpdateFailHTLC UpdateFailHTLC_clone(const struct LDKUpdateFailHTLC *NONNULL_PTR orig);
23608 export function UpdateFailHTLC_clone(orig: bigint): bigint {
23609 if(!isWasmInitialized) {
23610 throw new Error("initializeWasm() must be awaited first!");
23612 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone(orig);
23613 return nativeResponseValue;
23615 // void UpdateFailMalformedHTLC_free(struct LDKUpdateFailMalformedHTLC this_obj);
23617 export function UpdateFailMalformedHTLC_free(this_obj: bigint): void {
23618 if(!isWasmInitialized) {
23619 throw new Error("initializeWasm() must be awaited first!");
23621 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_free(this_obj);
23622 // debug statements here
23624 // const uint8_t (*UpdateFailMalformedHTLC_get_channel_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr))[32];
23626 export function UpdateFailMalformedHTLC_get_channel_id(this_ptr: bigint): number {
23627 if(!isWasmInitialized) {
23628 throw new Error("initializeWasm() must be awaited first!");
23630 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_channel_id(this_ptr);
23631 return nativeResponseValue;
23633 // void UpdateFailMalformedHTLC_set_channel_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23635 export function UpdateFailMalformedHTLC_set_channel_id(this_ptr: bigint, val: number): void {
23636 if(!isWasmInitialized) {
23637 throw new Error("initializeWasm() must be awaited first!");
23639 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_channel_id(this_ptr, val);
23640 // debug statements here
23642 // uint64_t UpdateFailMalformedHTLC_get_htlc_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
23644 export function UpdateFailMalformedHTLC_get_htlc_id(this_ptr: bigint): bigint {
23645 if(!isWasmInitialized) {
23646 throw new Error("initializeWasm() must be awaited first!");
23648 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_htlc_id(this_ptr);
23649 return nativeResponseValue;
23651 // void UpdateFailMalformedHTLC_set_htlc_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint64_t val);
23653 export function UpdateFailMalformedHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
23654 if(!isWasmInitialized) {
23655 throw new Error("initializeWasm() must be awaited first!");
23657 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_htlc_id(this_ptr, val);
23658 // debug statements here
23660 // uint16_t UpdateFailMalformedHTLC_get_failure_code(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
23662 export function UpdateFailMalformedHTLC_get_failure_code(this_ptr: bigint): number {
23663 if(!isWasmInitialized) {
23664 throw new Error("initializeWasm() must be awaited first!");
23666 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_failure_code(this_ptr);
23667 return nativeResponseValue;
23669 // void UpdateFailMalformedHTLC_set_failure_code(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint16_t val);
23671 export function UpdateFailMalformedHTLC_set_failure_code(this_ptr: bigint, val: number): void {
23672 if(!isWasmInitialized) {
23673 throw new Error("initializeWasm() must be awaited first!");
23675 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_failure_code(this_ptr, val);
23676 // debug statements here
23678 // uint64_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg);
23680 export function UpdateFailMalformedHTLC_clone_ptr(arg: bigint): bigint {
23681 if(!isWasmInitialized) {
23682 throw new Error("initializeWasm() must be awaited first!");
23684 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone_ptr(arg);
23685 return nativeResponseValue;
23687 // struct LDKUpdateFailMalformedHTLC UpdateFailMalformedHTLC_clone(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR orig);
23689 export function UpdateFailMalformedHTLC_clone(orig: bigint): bigint {
23690 if(!isWasmInitialized) {
23691 throw new Error("initializeWasm() must be awaited first!");
23693 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone(orig);
23694 return nativeResponseValue;
23696 // void CommitmentSigned_free(struct LDKCommitmentSigned this_obj);
23698 export function CommitmentSigned_free(this_obj: bigint): void {
23699 if(!isWasmInitialized) {
23700 throw new Error("initializeWasm() must be awaited first!");
23702 const nativeResponseValue = wasm.TS_CommitmentSigned_free(this_obj);
23703 // debug statements here
23705 // const uint8_t (*CommitmentSigned_get_channel_id(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr))[32];
23707 export function CommitmentSigned_get_channel_id(this_ptr: bigint): number {
23708 if(!isWasmInitialized) {
23709 throw new Error("initializeWasm() must be awaited first!");
23711 const nativeResponseValue = wasm.TS_CommitmentSigned_get_channel_id(this_ptr);
23712 return nativeResponseValue;
23714 // void CommitmentSigned_set_channel_id(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23716 export function CommitmentSigned_set_channel_id(this_ptr: bigint, val: number): void {
23717 if(!isWasmInitialized) {
23718 throw new Error("initializeWasm() must be awaited first!");
23720 const nativeResponseValue = wasm.TS_CommitmentSigned_set_channel_id(this_ptr, val);
23721 // debug statements here
23723 // struct LDKSignature CommitmentSigned_get_signature(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
23725 export function CommitmentSigned_get_signature(this_ptr: bigint): number {
23726 if(!isWasmInitialized) {
23727 throw new Error("initializeWasm() must be awaited first!");
23729 const nativeResponseValue = wasm.TS_CommitmentSigned_get_signature(this_ptr);
23730 return nativeResponseValue;
23732 // void CommitmentSigned_set_signature(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
23734 export function CommitmentSigned_set_signature(this_ptr: bigint, val: number): void {
23735 if(!isWasmInitialized) {
23736 throw new Error("initializeWasm() must be awaited first!");
23738 const nativeResponseValue = wasm.TS_CommitmentSigned_set_signature(this_ptr, val);
23739 // debug statements here
23741 // struct LDKCVec_SignatureZ CommitmentSigned_get_htlc_signatures(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
23743 export function CommitmentSigned_get_htlc_signatures(this_ptr: bigint): number {
23744 if(!isWasmInitialized) {
23745 throw new Error("initializeWasm() must be awaited first!");
23747 const nativeResponseValue = wasm.TS_CommitmentSigned_get_htlc_signatures(this_ptr);
23748 return nativeResponseValue;
23750 // void CommitmentSigned_set_htlc_signatures(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
23752 export function CommitmentSigned_set_htlc_signatures(this_ptr: bigint, val: number): void {
23753 if(!isWasmInitialized) {
23754 throw new Error("initializeWasm() must be awaited first!");
23756 const nativeResponseValue = wasm.TS_CommitmentSigned_set_htlc_signatures(this_ptr, val);
23757 // debug statements here
23759 // MUST_USE_RES struct LDKCommitmentSigned CommitmentSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg, struct LDKCVec_SignatureZ htlc_signatures_arg);
23761 export function CommitmentSigned_new(channel_id_arg: number, signature_arg: number, htlc_signatures_arg: number): bigint {
23762 if(!isWasmInitialized) {
23763 throw new Error("initializeWasm() must be awaited first!");
23765 const nativeResponseValue = wasm.TS_CommitmentSigned_new(channel_id_arg, signature_arg, htlc_signatures_arg);
23766 return nativeResponseValue;
23768 // uint64_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg);
23770 export function CommitmentSigned_clone_ptr(arg: bigint): bigint {
23771 if(!isWasmInitialized) {
23772 throw new Error("initializeWasm() must be awaited first!");
23774 const nativeResponseValue = wasm.TS_CommitmentSigned_clone_ptr(arg);
23775 return nativeResponseValue;
23777 // struct LDKCommitmentSigned CommitmentSigned_clone(const struct LDKCommitmentSigned *NONNULL_PTR orig);
23779 export function CommitmentSigned_clone(orig: bigint): bigint {
23780 if(!isWasmInitialized) {
23781 throw new Error("initializeWasm() must be awaited first!");
23783 const nativeResponseValue = wasm.TS_CommitmentSigned_clone(orig);
23784 return nativeResponseValue;
23786 // void RevokeAndACK_free(struct LDKRevokeAndACK this_obj);
23788 export function RevokeAndACK_free(this_obj: bigint): void {
23789 if(!isWasmInitialized) {
23790 throw new Error("initializeWasm() must be awaited first!");
23792 const nativeResponseValue = wasm.TS_RevokeAndACK_free(this_obj);
23793 // debug statements here
23795 // const uint8_t (*RevokeAndACK_get_channel_id(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
23797 export function RevokeAndACK_get_channel_id(this_ptr: bigint): number {
23798 if(!isWasmInitialized) {
23799 throw new Error("initializeWasm() must be awaited first!");
23801 const nativeResponseValue = wasm.TS_RevokeAndACK_get_channel_id(this_ptr);
23802 return nativeResponseValue;
23804 // void RevokeAndACK_set_channel_id(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23806 export function RevokeAndACK_set_channel_id(this_ptr: bigint, val: number): void {
23807 if(!isWasmInitialized) {
23808 throw new Error("initializeWasm() must be awaited first!");
23810 const nativeResponseValue = wasm.TS_RevokeAndACK_set_channel_id(this_ptr, val);
23811 // debug statements here
23813 // const uint8_t (*RevokeAndACK_get_per_commitment_secret(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
23815 export function RevokeAndACK_get_per_commitment_secret(this_ptr: bigint): number {
23816 if(!isWasmInitialized) {
23817 throw new Error("initializeWasm() must be awaited first!");
23819 const nativeResponseValue = wasm.TS_RevokeAndACK_get_per_commitment_secret(this_ptr);
23820 return nativeResponseValue;
23822 // void RevokeAndACK_set_per_commitment_secret(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23824 export function RevokeAndACK_set_per_commitment_secret(this_ptr: bigint, val: number): void {
23825 if(!isWasmInitialized) {
23826 throw new Error("initializeWasm() must be awaited first!");
23828 const nativeResponseValue = wasm.TS_RevokeAndACK_set_per_commitment_secret(this_ptr, val);
23829 // debug statements here
23831 // struct LDKPublicKey RevokeAndACK_get_next_per_commitment_point(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr);
23833 export function RevokeAndACK_get_next_per_commitment_point(this_ptr: bigint): number {
23834 if(!isWasmInitialized) {
23835 throw new Error("initializeWasm() must be awaited first!");
23837 const nativeResponseValue = wasm.TS_RevokeAndACK_get_next_per_commitment_point(this_ptr);
23838 return nativeResponseValue;
23840 // void RevokeAndACK_set_next_per_commitment_point(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23842 export function RevokeAndACK_set_next_per_commitment_point(this_ptr: bigint, val: number): void {
23843 if(!isWasmInitialized) {
23844 throw new Error("initializeWasm() must be awaited first!");
23846 const nativeResponseValue = wasm.TS_RevokeAndACK_set_next_per_commitment_point(this_ptr, val);
23847 // debug statements here
23849 // 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);
23851 export function RevokeAndACK_new(channel_id_arg: number, per_commitment_secret_arg: number, next_per_commitment_point_arg: number): bigint {
23852 if(!isWasmInitialized) {
23853 throw new Error("initializeWasm() must be awaited first!");
23855 const nativeResponseValue = wasm.TS_RevokeAndACK_new(channel_id_arg, per_commitment_secret_arg, next_per_commitment_point_arg);
23856 return nativeResponseValue;
23858 // uint64_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg);
23860 export function RevokeAndACK_clone_ptr(arg: bigint): bigint {
23861 if(!isWasmInitialized) {
23862 throw new Error("initializeWasm() must be awaited first!");
23864 const nativeResponseValue = wasm.TS_RevokeAndACK_clone_ptr(arg);
23865 return nativeResponseValue;
23867 // struct LDKRevokeAndACK RevokeAndACK_clone(const struct LDKRevokeAndACK *NONNULL_PTR orig);
23869 export function RevokeAndACK_clone(orig: bigint): bigint {
23870 if(!isWasmInitialized) {
23871 throw new Error("initializeWasm() must be awaited first!");
23873 const nativeResponseValue = wasm.TS_RevokeAndACK_clone(orig);
23874 return nativeResponseValue;
23876 // void UpdateFee_free(struct LDKUpdateFee this_obj);
23878 export function UpdateFee_free(this_obj: bigint): void {
23879 if(!isWasmInitialized) {
23880 throw new Error("initializeWasm() must be awaited first!");
23882 const nativeResponseValue = wasm.TS_UpdateFee_free(this_obj);
23883 // debug statements here
23885 // const uint8_t (*UpdateFee_get_channel_id(const struct LDKUpdateFee *NONNULL_PTR this_ptr))[32];
23887 export function UpdateFee_get_channel_id(this_ptr: bigint): number {
23888 if(!isWasmInitialized) {
23889 throw new Error("initializeWasm() must be awaited first!");
23891 const nativeResponseValue = wasm.TS_UpdateFee_get_channel_id(this_ptr);
23892 return nativeResponseValue;
23894 // void UpdateFee_set_channel_id(struct LDKUpdateFee *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23896 export function UpdateFee_set_channel_id(this_ptr: bigint, val: number): void {
23897 if(!isWasmInitialized) {
23898 throw new Error("initializeWasm() must be awaited first!");
23900 const nativeResponseValue = wasm.TS_UpdateFee_set_channel_id(this_ptr, val);
23901 // debug statements here
23903 // uint32_t UpdateFee_get_feerate_per_kw(const struct LDKUpdateFee *NONNULL_PTR this_ptr);
23905 export function UpdateFee_get_feerate_per_kw(this_ptr: bigint): number {
23906 if(!isWasmInitialized) {
23907 throw new Error("initializeWasm() must be awaited first!");
23909 const nativeResponseValue = wasm.TS_UpdateFee_get_feerate_per_kw(this_ptr);
23910 return nativeResponseValue;
23912 // void UpdateFee_set_feerate_per_kw(struct LDKUpdateFee *NONNULL_PTR this_ptr, uint32_t val);
23914 export function UpdateFee_set_feerate_per_kw(this_ptr: bigint, val: number): void {
23915 if(!isWasmInitialized) {
23916 throw new Error("initializeWasm() must be awaited first!");
23918 const nativeResponseValue = wasm.TS_UpdateFee_set_feerate_per_kw(this_ptr, val);
23919 // debug statements here
23921 // MUST_USE_RES struct LDKUpdateFee UpdateFee_new(struct LDKThirtyTwoBytes channel_id_arg, uint32_t feerate_per_kw_arg);
23923 export function UpdateFee_new(channel_id_arg: number, feerate_per_kw_arg: number): bigint {
23924 if(!isWasmInitialized) {
23925 throw new Error("initializeWasm() must be awaited first!");
23927 const nativeResponseValue = wasm.TS_UpdateFee_new(channel_id_arg, feerate_per_kw_arg);
23928 return nativeResponseValue;
23930 // uint64_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg);
23932 export function UpdateFee_clone_ptr(arg: bigint): bigint {
23933 if(!isWasmInitialized) {
23934 throw new Error("initializeWasm() must be awaited first!");
23936 const nativeResponseValue = wasm.TS_UpdateFee_clone_ptr(arg);
23937 return nativeResponseValue;
23939 // struct LDKUpdateFee UpdateFee_clone(const struct LDKUpdateFee *NONNULL_PTR orig);
23941 export function UpdateFee_clone(orig: bigint): bigint {
23942 if(!isWasmInitialized) {
23943 throw new Error("initializeWasm() must be awaited first!");
23945 const nativeResponseValue = wasm.TS_UpdateFee_clone(orig);
23946 return nativeResponseValue;
23948 // void DataLossProtect_free(struct LDKDataLossProtect this_obj);
23950 export function DataLossProtect_free(this_obj: bigint): void {
23951 if(!isWasmInitialized) {
23952 throw new Error("initializeWasm() must be awaited first!");
23954 const nativeResponseValue = wasm.TS_DataLossProtect_free(this_obj);
23955 // debug statements here
23957 // const uint8_t (*DataLossProtect_get_your_last_per_commitment_secret(const struct LDKDataLossProtect *NONNULL_PTR this_ptr))[32];
23959 export function DataLossProtect_get_your_last_per_commitment_secret(this_ptr: bigint): number {
23960 if(!isWasmInitialized) {
23961 throw new Error("initializeWasm() must be awaited first!");
23963 const nativeResponseValue = wasm.TS_DataLossProtect_get_your_last_per_commitment_secret(this_ptr);
23964 return nativeResponseValue;
23966 // void DataLossProtect_set_your_last_per_commitment_secret(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23968 export function DataLossProtect_set_your_last_per_commitment_secret(this_ptr: bigint, val: number): void {
23969 if(!isWasmInitialized) {
23970 throw new Error("initializeWasm() must be awaited first!");
23972 const nativeResponseValue = wasm.TS_DataLossProtect_set_your_last_per_commitment_secret(this_ptr, val);
23973 // debug statements here
23975 // struct LDKPublicKey DataLossProtect_get_my_current_per_commitment_point(const struct LDKDataLossProtect *NONNULL_PTR this_ptr);
23977 export function DataLossProtect_get_my_current_per_commitment_point(this_ptr: bigint): number {
23978 if(!isWasmInitialized) {
23979 throw new Error("initializeWasm() must be awaited first!");
23981 const nativeResponseValue = wasm.TS_DataLossProtect_get_my_current_per_commitment_point(this_ptr);
23982 return nativeResponseValue;
23984 // void DataLossProtect_set_my_current_per_commitment_point(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23986 export function DataLossProtect_set_my_current_per_commitment_point(this_ptr: bigint, val: number): void {
23987 if(!isWasmInitialized) {
23988 throw new Error("initializeWasm() must be awaited first!");
23990 const nativeResponseValue = wasm.TS_DataLossProtect_set_my_current_per_commitment_point(this_ptr, val);
23991 // debug statements here
23993 // MUST_USE_RES struct LDKDataLossProtect DataLossProtect_new(struct LDKThirtyTwoBytes your_last_per_commitment_secret_arg, struct LDKPublicKey my_current_per_commitment_point_arg);
23995 export function DataLossProtect_new(your_last_per_commitment_secret_arg: number, my_current_per_commitment_point_arg: number): bigint {
23996 if(!isWasmInitialized) {
23997 throw new Error("initializeWasm() must be awaited first!");
23999 const nativeResponseValue = wasm.TS_DataLossProtect_new(your_last_per_commitment_secret_arg, my_current_per_commitment_point_arg);
24000 return nativeResponseValue;
24002 // uint64_t DataLossProtect_clone_ptr(LDKDataLossProtect *NONNULL_PTR arg);
24004 export function DataLossProtect_clone_ptr(arg: bigint): bigint {
24005 if(!isWasmInitialized) {
24006 throw new Error("initializeWasm() must be awaited first!");
24008 const nativeResponseValue = wasm.TS_DataLossProtect_clone_ptr(arg);
24009 return nativeResponseValue;
24011 // struct LDKDataLossProtect DataLossProtect_clone(const struct LDKDataLossProtect *NONNULL_PTR orig);
24013 export function DataLossProtect_clone(orig: bigint): bigint {
24014 if(!isWasmInitialized) {
24015 throw new Error("initializeWasm() must be awaited first!");
24017 const nativeResponseValue = wasm.TS_DataLossProtect_clone(orig);
24018 return nativeResponseValue;
24020 // void ChannelReestablish_free(struct LDKChannelReestablish this_obj);
24022 export function ChannelReestablish_free(this_obj: bigint): void {
24023 if(!isWasmInitialized) {
24024 throw new Error("initializeWasm() must be awaited first!");
24026 const nativeResponseValue = wasm.TS_ChannelReestablish_free(this_obj);
24027 // debug statements here
24029 // const uint8_t (*ChannelReestablish_get_channel_id(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
24031 export function ChannelReestablish_get_channel_id(this_ptr: bigint): number {
24032 if(!isWasmInitialized) {
24033 throw new Error("initializeWasm() must be awaited first!");
24035 const nativeResponseValue = wasm.TS_ChannelReestablish_get_channel_id(this_ptr);
24036 return nativeResponseValue;
24038 // void ChannelReestablish_set_channel_id(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24040 export function ChannelReestablish_set_channel_id(this_ptr: bigint, val: number): void {
24041 if(!isWasmInitialized) {
24042 throw new Error("initializeWasm() must be awaited first!");
24044 const nativeResponseValue = wasm.TS_ChannelReestablish_set_channel_id(this_ptr, val);
24045 // debug statements here
24047 // uint64_t ChannelReestablish_get_next_local_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
24049 export function ChannelReestablish_get_next_local_commitment_number(this_ptr: bigint): bigint {
24050 if(!isWasmInitialized) {
24051 throw new Error("initializeWasm() must be awaited first!");
24053 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_local_commitment_number(this_ptr);
24054 return nativeResponseValue;
24056 // void ChannelReestablish_set_next_local_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
24058 export function ChannelReestablish_set_next_local_commitment_number(this_ptr: bigint, val: bigint): void {
24059 if(!isWasmInitialized) {
24060 throw new Error("initializeWasm() must be awaited first!");
24062 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_local_commitment_number(this_ptr, val);
24063 // debug statements here
24065 // uint64_t ChannelReestablish_get_next_remote_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
24067 export function ChannelReestablish_get_next_remote_commitment_number(this_ptr: bigint): bigint {
24068 if(!isWasmInitialized) {
24069 throw new Error("initializeWasm() must be awaited first!");
24071 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_remote_commitment_number(this_ptr);
24072 return nativeResponseValue;
24074 // void ChannelReestablish_set_next_remote_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
24076 export function ChannelReestablish_set_next_remote_commitment_number(this_ptr: bigint, val: bigint): void {
24077 if(!isWasmInitialized) {
24078 throw new Error("initializeWasm() must be awaited first!");
24080 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_remote_commitment_number(this_ptr, val);
24081 // debug statements here
24083 // uint64_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg);
24085 export function ChannelReestablish_clone_ptr(arg: bigint): bigint {
24086 if(!isWasmInitialized) {
24087 throw new Error("initializeWasm() must be awaited first!");
24089 const nativeResponseValue = wasm.TS_ChannelReestablish_clone_ptr(arg);
24090 return nativeResponseValue;
24092 // struct LDKChannelReestablish ChannelReestablish_clone(const struct LDKChannelReestablish *NONNULL_PTR orig);
24094 export function ChannelReestablish_clone(orig: bigint): bigint {
24095 if(!isWasmInitialized) {
24096 throw new Error("initializeWasm() must be awaited first!");
24098 const nativeResponseValue = wasm.TS_ChannelReestablish_clone(orig);
24099 return nativeResponseValue;
24101 // void AnnouncementSignatures_free(struct LDKAnnouncementSignatures this_obj);
24103 export function AnnouncementSignatures_free(this_obj: bigint): void {
24104 if(!isWasmInitialized) {
24105 throw new Error("initializeWasm() must be awaited first!");
24107 const nativeResponseValue = wasm.TS_AnnouncementSignatures_free(this_obj);
24108 // debug statements here
24110 // const uint8_t (*AnnouncementSignatures_get_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr))[32];
24112 export function AnnouncementSignatures_get_channel_id(this_ptr: bigint): number {
24113 if(!isWasmInitialized) {
24114 throw new Error("initializeWasm() must be awaited first!");
24116 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_channel_id(this_ptr);
24117 return nativeResponseValue;
24119 // void AnnouncementSignatures_set_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24121 export function AnnouncementSignatures_set_channel_id(this_ptr: bigint, val: number): void {
24122 if(!isWasmInitialized) {
24123 throw new Error("initializeWasm() must be awaited first!");
24125 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_channel_id(this_ptr, val);
24126 // debug statements here
24128 // uint64_t AnnouncementSignatures_get_short_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
24130 export function AnnouncementSignatures_get_short_channel_id(this_ptr: bigint): bigint {
24131 if(!isWasmInitialized) {
24132 throw new Error("initializeWasm() must be awaited first!");
24134 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_short_channel_id(this_ptr);
24135 return nativeResponseValue;
24137 // void AnnouncementSignatures_set_short_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, uint64_t val);
24139 export function AnnouncementSignatures_set_short_channel_id(this_ptr: bigint, val: bigint): void {
24140 if(!isWasmInitialized) {
24141 throw new Error("initializeWasm() must be awaited first!");
24143 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_short_channel_id(this_ptr, val);
24144 // debug statements here
24146 // struct LDKSignature AnnouncementSignatures_get_node_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
24148 export function AnnouncementSignatures_get_node_signature(this_ptr: bigint): number {
24149 if(!isWasmInitialized) {
24150 throw new Error("initializeWasm() must be awaited first!");
24152 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_node_signature(this_ptr);
24153 return nativeResponseValue;
24155 // void AnnouncementSignatures_set_node_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
24157 export function AnnouncementSignatures_set_node_signature(this_ptr: bigint, val: number): void {
24158 if(!isWasmInitialized) {
24159 throw new Error("initializeWasm() must be awaited first!");
24161 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_node_signature(this_ptr, val);
24162 // debug statements here
24164 // struct LDKSignature AnnouncementSignatures_get_bitcoin_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
24166 export function AnnouncementSignatures_get_bitcoin_signature(this_ptr: bigint): number {
24167 if(!isWasmInitialized) {
24168 throw new Error("initializeWasm() must be awaited first!");
24170 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_bitcoin_signature(this_ptr);
24171 return nativeResponseValue;
24173 // void AnnouncementSignatures_set_bitcoin_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
24175 export function AnnouncementSignatures_set_bitcoin_signature(this_ptr: bigint, val: number): void {
24176 if(!isWasmInitialized) {
24177 throw new Error("initializeWasm() must be awaited first!");
24179 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_bitcoin_signature(this_ptr, val);
24180 // debug statements here
24182 // 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);
24184 export function AnnouncementSignatures_new(channel_id_arg: number, short_channel_id_arg: bigint, node_signature_arg: number, bitcoin_signature_arg: number): bigint {
24185 if(!isWasmInitialized) {
24186 throw new Error("initializeWasm() must be awaited first!");
24188 const nativeResponseValue = wasm.TS_AnnouncementSignatures_new(channel_id_arg, short_channel_id_arg, node_signature_arg, bitcoin_signature_arg);
24189 return nativeResponseValue;
24191 // uint64_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg);
24193 export function AnnouncementSignatures_clone_ptr(arg: bigint): bigint {
24194 if(!isWasmInitialized) {
24195 throw new Error("initializeWasm() must be awaited first!");
24197 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone_ptr(arg);
24198 return nativeResponseValue;
24200 // struct LDKAnnouncementSignatures AnnouncementSignatures_clone(const struct LDKAnnouncementSignatures *NONNULL_PTR orig);
24202 export function AnnouncementSignatures_clone(orig: bigint): bigint {
24203 if(!isWasmInitialized) {
24204 throw new Error("initializeWasm() must be awaited first!");
24206 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone(orig);
24207 return nativeResponseValue;
24209 // void NetAddress_free(struct LDKNetAddress this_ptr);
24211 export function NetAddress_free(this_ptr: bigint): void {
24212 if(!isWasmInitialized) {
24213 throw new Error("initializeWasm() must be awaited first!");
24215 const nativeResponseValue = wasm.TS_NetAddress_free(this_ptr);
24216 // debug statements here
24218 // uint64_t NetAddress_clone_ptr(LDKNetAddress *NONNULL_PTR arg);
24220 export function NetAddress_clone_ptr(arg: bigint): bigint {
24221 if(!isWasmInitialized) {
24222 throw new Error("initializeWasm() must be awaited first!");
24224 const nativeResponseValue = wasm.TS_NetAddress_clone_ptr(arg);
24225 return nativeResponseValue;
24227 // struct LDKNetAddress NetAddress_clone(const struct LDKNetAddress *NONNULL_PTR orig);
24229 export function NetAddress_clone(orig: bigint): bigint {
24230 if(!isWasmInitialized) {
24231 throw new Error("initializeWasm() must be awaited first!");
24233 const nativeResponseValue = wasm.TS_NetAddress_clone(orig);
24234 return nativeResponseValue;
24236 // struct LDKNetAddress NetAddress_ipv4(struct LDKFourBytes addr, uint16_t port);
24238 export function NetAddress_ipv4(addr: number, port: number): bigint {
24239 if(!isWasmInitialized) {
24240 throw new Error("initializeWasm() must be awaited first!");
24242 const nativeResponseValue = wasm.TS_NetAddress_ipv4(addr, port);
24243 return nativeResponseValue;
24245 // struct LDKNetAddress NetAddress_ipv6(struct LDKSixteenBytes addr, uint16_t port);
24247 export function NetAddress_ipv6(addr: number, port: number): bigint {
24248 if(!isWasmInitialized) {
24249 throw new Error("initializeWasm() must be awaited first!");
24251 const nativeResponseValue = wasm.TS_NetAddress_ipv6(addr, port);
24252 return nativeResponseValue;
24254 // struct LDKNetAddress NetAddress_onion_v2(struct LDKTwelveBytes a);
24256 export function NetAddress_onion_v2(a: number): bigint {
24257 if(!isWasmInitialized) {
24258 throw new Error("initializeWasm() must be awaited first!");
24260 const nativeResponseValue = wasm.TS_NetAddress_onion_v2(a);
24261 return nativeResponseValue;
24263 // struct LDKNetAddress NetAddress_onion_v3(struct LDKThirtyTwoBytes ed25519_pubkey, uint16_t checksum, uint8_t version, uint16_t port);
24265 export function NetAddress_onion_v3(ed25519_pubkey: number, checksum: number, version: number, port: number): bigint {
24266 if(!isWasmInitialized) {
24267 throw new Error("initializeWasm() must be awaited first!");
24269 const nativeResponseValue = wasm.TS_NetAddress_onion_v3(ed25519_pubkey, checksum, version, port);
24270 return nativeResponseValue;
24272 // struct LDKNetAddress NetAddress_hostname(struct LDKHostname hostname, uint16_t port);
24274 export function NetAddress_hostname(hostname: bigint, port: number): bigint {
24275 if(!isWasmInitialized) {
24276 throw new Error("initializeWasm() must be awaited first!");
24278 const nativeResponseValue = wasm.TS_NetAddress_hostname(hostname, port);
24279 return nativeResponseValue;
24281 // struct LDKCVec_u8Z NetAddress_write(const struct LDKNetAddress *NONNULL_PTR obj);
24283 export function NetAddress_write(obj: bigint): number {
24284 if(!isWasmInitialized) {
24285 throw new Error("initializeWasm() must be awaited first!");
24287 const nativeResponseValue = wasm.TS_NetAddress_write(obj);
24288 return nativeResponseValue;
24290 // struct LDKCResult_NetAddressDecodeErrorZ NetAddress_read(struct LDKu8slice ser);
24292 export function NetAddress_read(ser: number): bigint {
24293 if(!isWasmInitialized) {
24294 throw new Error("initializeWasm() must be awaited first!");
24296 const nativeResponseValue = wasm.TS_NetAddress_read(ser);
24297 return nativeResponseValue;
24299 // void UnsignedNodeAnnouncement_free(struct LDKUnsignedNodeAnnouncement this_obj);
24301 export function UnsignedNodeAnnouncement_free(this_obj: bigint): void {
24302 if(!isWasmInitialized) {
24303 throw new Error("initializeWasm() must be awaited first!");
24305 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_free(this_obj);
24306 // debug statements here
24308 // struct LDKNodeFeatures UnsignedNodeAnnouncement_get_features(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
24310 export function UnsignedNodeAnnouncement_get_features(this_ptr: bigint): bigint {
24311 if(!isWasmInitialized) {
24312 throw new Error("initializeWasm() must be awaited first!");
24314 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_features(this_ptr);
24315 return nativeResponseValue;
24317 // void UnsignedNodeAnnouncement_set_features(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
24319 export function UnsignedNodeAnnouncement_set_features(this_ptr: bigint, val: bigint): void {
24320 if(!isWasmInitialized) {
24321 throw new Error("initializeWasm() must be awaited first!");
24323 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_features(this_ptr, val);
24324 // debug statements here
24326 // uint32_t UnsignedNodeAnnouncement_get_timestamp(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
24328 export function UnsignedNodeAnnouncement_get_timestamp(this_ptr: bigint): number {
24329 if(!isWasmInitialized) {
24330 throw new Error("initializeWasm() must be awaited first!");
24332 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_timestamp(this_ptr);
24333 return nativeResponseValue;
24335 // void UnsignedNodeAnnouncement_set_timestamp(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, uint32_t val);
24337 export function UnsignedNodeAnnouncement_set_timestamp(this_ptr: bigint, val: number): void {
24338 if(!isWasmInitialized) {
24339 throw new Error("initializeWasm() must be awaited first!");
24341 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_timestamp(this_ptr, val);
24342 // debug statements here
24344 // struct LDKPublicKey UnsignedNodeAnnouncement_get_node_id(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
24346 export function UnsignedNodeAnnouncement_get_node_id(this_ptr: bigint): number {
24347 if(!isWasmInitialized) {
24348 throw new Error("initializeWasm() must be awaited first!");
24350 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_node_id(this_ptr);
24351 return nativeResponseValue;
24353 // void UnsignedNodeAnnouncement_set_node_id(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24355 export function UnsignedNodeAnnouncement_set_node_id(this_ptr: bigint, val: number): void {
24356 if(!isWasmInitialized) {
24357 throw new Error("initializeWasm() must be awaited first!");
24359 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_node_id(this_ptr, val);
24360 // debug statements here
24362 // const uint8_t (*UnsignedNodeAnnouncement_get_rgb(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[3];
24364 export function UnsignedNodeAnnouncement_get_rgb(this_ptr: bigint): number {
24365 if(!isWasmInitialized) {
24366 throw new Error("initializeWasm() must be awaited first!");
24368 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_rgb(this_ptr);
24369 return nativeResponseValue;
24371 // void UnsignedNodeAnnouncement_set_rgb(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
24373 export function UnsignedNodeAnnouncement_set_rgb(this_ptr: bigint, val: number): void {
24374 if(!isWasmInitialized) {
24375 throw new Error("initializeWasm() must be awaited first!");
24377 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_rgb(this_ptr, val);
24378 // debug statements here
24380 // const uint8_t (*UnsignedNodeAnnouncement_get_alias(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[32];
24382 export function UnsignedNodeAnnouncement_get_alias(this_ptr: bigint): number {
24383 if(!isWasmInitialized) {
24384 throw new Error("initializeWasm() must be awaited first!");
24386 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_alias(this_ptr);
24387 return nativeResponseValue;
24389 // void UnsignedNodeAnnouncement_set_alias(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24391 export function UnsignedNodeAnnouncement_set_alias(this_ptr: bigint, val: number): void {
24392 if(!isWasmInitialized) {
24393 throw new Error("initializeWasm() must be awaited first!");
24395 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_alias(this_ptr, val);
24396 // debug statements here
24398 // struct LDKCVec_NetAddressZ UnsignedNodeAnnouncement_get_addresses(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
24400 export function UnsignedNodeAnnouncement_get_addresses(this_ptr: bigint): number {
24401 if(!isWasmInitialized) {
24402 throw new Error("initializeWasm() must be awaited first!");
24404 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_addresses(this_ptr);
24405 return nativeResponseValue;
24407 // void UnsignedNodeAnnouncement_set_addresses(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
24409 export function UnsignedNodeAnnouncement_set_addresses(this_ptr: bigint, val: number): void {
24410 if(!isWasmInitialized) {
24411 throw new Error("initializeWasm() must be awaited first!");
24413 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_addresses(this_ptr, val);
24414 // debug statements here
24416 // uint64_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg);
24418 export function UnsignedNodeAnnouncement_clone_ptr(arg: bigint): bigint {
24419 if(!isWasmInitialized) {
24420 throw new Error("initializeWasm() must be awaited first!");
24422 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone_ptr(arg);
24423 return nativeResponseValue;
24425 // struct LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_clone(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR orig);
24427 export function UnsignedNodeAnnouncement_clone(orig: bigint): bigint {
24428 if(!isWasmInitialized) {
24429 throw new Error("initializeWasm() must be awaited first!");
24431 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone(orig);
24432 return nativeResponseValue;
24434 // void NodeAnnouncement_free(struct LDKNodeAnnouncement this_obj);
24436 export function NodeAnnouncement_free(this_obj: bigint): void {
24437 if(!isWasmInitialized) {
24438 throw new Error("initializeWasm() must be awaited first!");
24440 const nativeResponseValue = wasm.TS_NodeAnnouncement_free(this_obj);
24441 // debug statements here
24443 // struct LDKSignature NodeAnnouncement_get_signature(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
24445 export function NodeAnnouncement_get_signature(this_ptr: bigint): number {
24446 if(!isWasmInitialized) {
24447 throw new Error("initializeWasm() must be awaited first!");
24449 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_signature(this_ptr);
24450 return nativeResponseValue;
24452 // void NodeAnnouncement_set_signature(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
24454 export function NodeAnnouncement_set_signature(this_ptr: bigint, val: number): void {
24455 if(!isWasmInitialized) {
24456 throw new Error("initializeWasm() must be awaited first!");
24458 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_signature(this_ptr, val);
24459 // debug statements here
24461 // struct LDKUnsignedNodeAnnouncement NodeAnnouncement_get_contents(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
24463 export function NodeAnnouncement_get_contents(this_ptr: bigint): bigint {
24464 if(!isWasmInitialized) {
24465 throw new Error("initializeWasm() must be awaited first!");
24467 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_contents(this_ptr);
24468 return nativeResponseValue;
24470 // void NodeAnnouncement_set_contents(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedNodeAnnouncement val);
24472 export function NodeAnnouncement_set_contents(this_ptr: bigint, val: bigint): void {
24473 if(!isWasmInitialized) {
24474 throw new Error("initializeWasm() must be awaited first!");
24476 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_contents(this_ptr, val);
24477 // debug statements here
24479 // MUST_USE_RES struct LDKNodeAnnouncement NodeAnnouncement_new(struct LDKSignature signature_arg, struct LDKUnsignedNodeAnnouncement contents_arg);
24481 export function NodeAnnouncement_new(signature_arg: number, contents_arg: bigint): bigint {
24482 if(!isWasmInitialized) {
24483 throw new Error("initializeWasm() must be awaited first!");
24485 const nativeResponseValue = wasm.TS_NodeAnnouncement_new(signature_arg, contents_arg);
24486 return nativeResponseValue;
24488 // uint64_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg);
24490 export function NodeAnnouncement_clone_ptr(arg: bigint): bigint {
24491 if(!isWasmInitialized) {
24492 throw new Error("initializeWasm() must be awaited first!");
24494 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone_ptr(arg);
24495 return nativeResponseValue;
24497 // struct LDKNodeAnnouncement NodeAnnouncement_clone(const struct LDKNodeAnnouncement *NONNULL_PTR orig);
24499 export function NodeAnnouncement_clone(orig: bigint): bigint {
24500 if(!isWasmInitialized) {
24501 throw new Error("initializeWasm() must be awaited first!");
24503 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone(orig);
24504 return nativeResponseValue;
24506 // void UnsignedChannelAnnouncement_free(struct LDKUnsignedChannelAnnouncement this_obj);
24508 export function UnsignedChannelAnnouncement_free(this_obj: bigint): void {
24509 if(!isWasmInitialized) {
24510 throw new Error("initializeWasm() must be awaited first!");
24512 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_free(this_obj);
24513 // debug statements here
24515 // struct LDKChannelFeatures UnsignedChannelAnnouncement_get_features(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
24517 export function UnsignedChannelAnnouncement_get_features(this_ptr: bigint): bigint {
24518 if(!isWasmInitialized) {
24519 throw new Error("initializeWasm() must be awaited first!");
24521 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_features(this_ptr);
24522 return nativeResponseValue;
24524 // void UnsignedChannelAnnouncement_set_features(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
24526 export function UnsignedChannelAnnouncement_set_features(this_ptr: bigint, val: bigint): void {
24527 if(!isWasmInitialized) {
24528 throw new Error("initializeWasm() must be awaited first!");
24530 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_features(this_ptr, val);
24531 // debug statements here
24533 // const uint8_t (*UnsignedChannelAnnouncement_get_chain_hash(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr))[32];
24535 export function UnsignedChannelAnnouncement_get_chain_hash(this_ptr: bigint): number {
24536 if(!isWasmInitialized) {
24537 throw new Error("initializeWasm() must be awaited first!");
24539 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_chain_hash(this_ptr);
24540 return nativeResponseValue;
24542 // void UnsignedChannelAnnouncement_set_chain_hash(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24544 export function UnsignedChannelAnnouncement_set_chain_hash(this_ptr: bigint, val: number): void {
24545 if(!isWasmInitialized) {
24546 throw new Error("initializeWasm() must be awaited first!");
24548 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_chain_hash(this_ptr, val);
24549 // debug statements here
24551 // uint64_t UnsignedChannelAnnouncement_get_short_channel_id(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
24553 export function UnsignedChannelAnnouncement_get_short_channel_id(this_ptr: bigint): bigint {
24554 if(!isWasmInitialized) {
24555 throw new Error("initializeWasm() must be awaited first!");
24557 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_short_channel_id(this_ptr);
24558 return nativeResponseValue;
24560 // void UnsignedChannelAnnouncement_set_short_channel_id(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, uint64_t val);
24562 export function UnsignedChannelAnnouncement_set_short_channel_id(this_ptr: bigint, val: bigint): void {
24563 if(!isWasmInitialized) {
24564 throw new Error("initializeWasm() must be awaited first!");
24566 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_short_channel_id(this_ptr, val);
24567 // debug statements here
24569 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
24571 export function UnsignedChannelAnnouncement_get_node_id_1(this_ptr: bigint): number {
24572 if(!isWasmInitialized) {
24573 throw new Error("initializeWasm() must be awaited first!");
24575 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_1(this_ptr);
24576 return nativeResponseValue;
24578 // void UnsignedChannelAnnouncement_set_node_id_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24580 export function UnsignedChannelAnnouncement_set_node_id_1(this_ptr: bigint, val: number): void {
24581 if(!isWasmInitialized) {
24582 throw new Error("initializeWasm() must be awaited first!");
24584 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_1(this_ptr, val);
24585 // debug statements here
24587 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
24589 export function UnsignedChannelAnnouncement_get_node_id_2(this_ptr: bigint): number {
24590 if(!isWasmInitialized) {
24591 throw new Error("initializeWasm() must be awaited first!");
24593 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_2(this_ptr);
24594 return nativeResponseValue;
24596 // void UnsignedChannelAnnouncement_set_node_id_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24598 export function UnsignedChannelAnnouncement_set_node_id_2(this_ptr: bigint, val: number): void {
24599 if(!isWasmInitialized) {
24600 throw new Error("initializeWasm() must be awaited first!");
24602 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_2(this_ptr, val);
24603 // debug statements here
24605 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
24607 export function UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr: bigint): number {
24608 if(!isWasmInitialized) {
24609 throw new Error("initializeWasm() must be awaited first!");
24611 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr);
24612 return nativeResponseValue;
24614 // void UnsignedChannelAnnouncement_set_bitcoin_key_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24616 export function UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr: bigint, val: number): void {
24617 if(!isWasmInitialized) {
24618 throw new Error("initializeWasm() must be awaited first!");
24620 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr, val);
24621 // debug statements here
24623 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
24625 export function UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr: bigint): number {
24626 if(!isWasmInitialized) {
24627 throw new Error("initializeWasm() must be awaited first!");
24629 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr);
24630 return nativeResponseValue;
24632 // void UnsignedChannelAnnouncement_set_bitcoin_key_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24634 export function UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr: bigint, val: number): void {
24635 if(!isWasmInitialized) {
24636 throw new Error("initializeWasm() must be awaited first!");
24638 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr, val);
24639 // debug statements here
24641 // uint64_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg);
24643 export function UnsignedChannelAnnouncement_clone_ptr(arg: bigint): bigint {
24644 if(!isWasmInitialized) {
24645 throw new Error("initializeWasm() must be awaited first!");
24647 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone_ptr(arg);
24648 return nativeResponseValue;
24650 // struct LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_clone(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR orig);
24652 export function UnsignedChannelAnnouncement_clone(orig: bigint): bigint {
24653 if(!isWasmInitialized) {
24654 throw new Error("initializeWasm() must be awaited first!");
24656 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone(orig);
24657 return nativeResponseValue;
24659 // void ChannelAnnouncement_free(struct LDKChannelAnnouncement this_obj);
24661 export function ChannelAnnouncement_free(this_obj: bigint): void {
24662 if(!isWasmInitialized) {
24663 throw new Error("initializeWasm() must be awaited first!");
24665 const nativeResponseValue = wasm.TS_ChannelAnnouncement_free(this_obj);
24666 // debug statements here
24668 // struct LDKSignature ChannelAnnouncement_get_node_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
24670 export function ChannelAnnouncement_get_node_signature_1(this_ptr: bigint): number {
24671 if(!isWasmInitialized) {
24672 throw new Error("initializeWasm() must be awaited first!");
24674 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_1(this_ptr);
24675 return nativeResponseValue;
24677 // void ChannelAnnouncement_set_node_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
24679 export function ChannelAnnouncement_set_node_signature_1(this_ptr: bigint, val: number): void {
24680 if(!isWasmInitialized) {
24681 throw new Error("initializeWasm() must be awaited first!");
24683 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_1(this_ptr, val);
24684 // debug statements here
24686 // struct LDKSignature ChannelAnnouncement_get_node_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
24688 export function ChannelAnnouncement_get_node_signature_2(this_ptr: bigint): number {
24689 if(!isWasmInitialized) {
24690 throw new Error("initializeWasm() must be awaited first!");
24692 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_2(this_ptr);
24693 return nativeResponseValue;
24695 // void ChannelAnnouncement_set_node_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
24697 export function ChannelAnnouncement_set_node_signature_2(this_ptr: bigint, val: number): void {
24698 if(!isWasmInitialized) {
24699 throw new Error("initializeWasm() must be awaited first!");
24701 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_2(this_ptr, val);
24702 // debug statements here
24704 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
24706 export function ChannelAnnouncement_get_bitcoin_signature_1(this_ptr: bigint): number {
24707 if(!isWasmInitialized) {
24708 throw new Error("initializeWasm() must be awaited first!");
24710 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_1(this_ptr);
24711 return nativeResponseValue;
24713 // void ChannelAnnouncement_set_bitcoin_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
24715 export function ChannelAnnouncement_set_bitcoin_signature_1(this_ptr: bigint, val: number): void {
24716 if(!isWasmInitialized) {
24717 throw new Error("initializeWasm() must be awaited first!");
24719 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_1(this_ptr, val);
24720 // debug statements here
24722 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
24724 export function ChannelAnnouncement_get_bitcoin_signature_2(this_ptr: bigint): number {
24725 if(!isWasmInitialized) {
24726 throw new Error("initializeWasm() must be awaited first!");
24728 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_2(this_ptr);
24729 return nativeResponseValue;
24731 // void ChannelAnnouncement_set_bitcoin_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
24733 export function ChannelAnnouncement_set_bitcoin_signature_2(this_ptr: bigint, val: number): void {
24734 if(!isWasmInitialized) {
24735 throw new Error("initializeWasm() must be awaited first!");
24737 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_2(this_ptr, val);
24738 // debug statements here
24740 // struct LDKUnsignedChannelAnnouncement ChannelAnnouncement_get_contents(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
24742 export function ChannelAnnouncement_get_contents(this_ptr: bigint): bigint {
24743 if(!isWasmInitialized) {
24744 throw new Error("initializeWasm() must be awaited first!");
24746 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_contents(this_ptr);
24747 return nativeResponseValue;
24749 // void ChannelAnnouncement_set_contents(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedChannelAnnouncement val);
24751 export function ChannelAnnouncement_set_contents(this_ptr: bigint, val: bigint): void {
24752 if(!isWasmInitialized) {
24753 throw new Error("initializeWasm() must be awaited first!");
24755 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_contents(this_ptr, val);
24756 // debug statements here
24758 // 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);
24760 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: bigint): bigint {
24761 if(!isWasmInitialized) {
24762 throw new Error("initializeWasm() must be awaited first!");
24764 const nativeResponseValue = wasm.TS_ChannelAnnouncement_new(node_signature_1_arg, node_signature_2_arg, bitcoin_signature_1_arg, bitcoin_signature_2_arg, contents_arg);
24765 return nativeResponseValue;
24767 // uint64_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg);
24769 export function ChannelAnnouncement_clone_ptr(arg: bigint): bigint {
24770 if(!isWasmInitialized) {
24771 throw new Error("initializeWasm() must be awaited first!");
24773 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone_ptr(arg);
24774 return nativeResponseValue;
24776 // struct LDKChannelAnnouncement ChannelAnnouncement_clone(const struct LDKChannelAnnouncement *NONNULL_PTR orig);
24778 export function ChannelAnnouncement_clone(orig: bigint): bigint {
24779 if(!isWasmInitialized) {
24780 throw new Error("initializeWasm() must be awaited first!");
24782 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone(orig);
24783 return nativeResponseValue;
24785 // void UnsignedChannelUpdate_free(struct LDKUnsignedChannelUpdate this_obj);
24787 export function UnsignedChannelUpdate_free(this_obj: bigint): void {
24788 if(!isWasmInitialized) {
24789 throw new Error("initializeWasm() must be awaited first!");
24791 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_free(this_obj);
24792 // debug statements here
24794 // const uint8_t (*UnsignedChannelUpdate_get_chain_hash(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr))[32];
24796 export function UnsignedChannelUpdate_get_chain_hash(this_ptr: bigint): number {
24797 if(!isWasmInitialized) {
24798 throw new Error("initializeWasm() must be awaited first!");
24800 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_chain_hash(this_ptr);
24801 return nativeResponseValue;
24803 // void UnsignedChannelUpdate_set_chain_hash(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24805 export function UnsignedChannelUpdate_set_chain_hash(this_ptr: bigint, val: number): void {
24806 if(!isWasmInitialized) {
24807 throw new Error("initializeWasm() must be awaited first!");
24809 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_chain_hash(this_ptr, val);
24810 // debug statements here
24812 // uint64_t UnsignedChannelUpdate_get_short_channel_id(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
24814 export function UnsignedChannelUpdate_get_short_channel_id(this_ptr: bigint): bigint {
24815 if(!isWasmInitialized) {
24816 throw new Error("initializeWasm() must be awaited first!");
24818 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_short_channel_id(this_ptr);
24819 return nativeResponseValue;
24821 // void UnsignedChannelUpdate_set_short_channel_id(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
24823 export function UnsignedChannelUpdate_set_short_channel_id(this_ptr: bigint, val: bigint): void {
24824 if(!isWasmInitialized) {
24825 throw new Error("initializeWasm() must be awaited first!");
24827 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_short_channel_id(this_ptr, val);
24828 // debug statements here
24830 // uint32_t UnsignedChannelUpdate_get_timestamp(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
24832 export function UnsignedChannelUpdate_get_timestamp(this_ptr: bigint): number {
24833 if(!isWasmInitialized) {
24834 throw new Error("initializeWasm() must be awaited first!");
24836 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_timestamp(this_ptr);
24837 return nativeResponseValue;
24839 // void UnsignedChannelUpdate_set_timestamp(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
24841 export function UnsignedChannelUpdate_set_timestamp(this_ptr: bigint, val: number): void {
24842 if(!isWasmInitialized) {
24843 throw new Error("initializeWasm() must be awaited first!");
24845 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_timestamp(this_ptr, val);
24846 // debug statements here
24848 // uint8_t UnsignedChannelUpdate_get_flags(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
24850 export function UnsignedChannelUpdate_get_flags(this_ptr: bigint): number {
24851 if(!isWasmInitialized) {
24852 throw new Error("initializeWasm() must be awaited first!");
24854 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_flags(this_ptr);
24855 return nativeResponseValue;
24857 // void UnsignedChannelUpdate_set_flags(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint8_t val);
24859 export function UnsignedChannelUpdate_set_flags(this_ptr: bigint, val: number): void {
24860 if(!isWasmInitialized) {
24861 throw new Error("initializeWasm() must be awaited first!");
24863 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_flags(this_ptr, val);
24864 // debug statements here
24866 // uint16_t UnsignedChannelUpdate_get_cltv_expiry_delta(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
24868 export function UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr: bigint): number {
24869 if(!isWasmInitialized) {
24870 throw new Error("initializeWasm() must be awaited first!");
24872 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr);
24873 return nativeResponseValue;
24875 // void UnsignedChannelUpdate_set_cltv_expiry_delta(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint16_t val);
24877 export function UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
24878 if(!isWasmInitialized) {
24879 throw new Error("initializeWasm() must be awaited first!");
24881 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr, val);
24882 // debug statements here
24884 // uint64_t UnsignedChannelUpdate_get_htlc_minimum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
24886 export function UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr: bigint): bigint {
24887 if(!isWasmInitialized) {
24888 throw new Error("initializeWasm() must be awaited first!");
24890 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr);
24891 return nativeResponseValue;
24893 // void UnsignedChannelUpdate_set_htlc_minimum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
24895 export function UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
24896 if(!isWasmInitialized) {
24897 throw new Error("initializeWasm() must be awaited first!");
24899 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr, val);
24900 // debug statements here
24902 // uint64_t UnsignedChannelUpdate_get_htlc_maximum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
24904 export function UnsignedChannelUpdate_get_htlc_maximum_msat(this_ptr: bigint): bigint {
24905 if(!isWasmInitialized) {
24906 throw new Error("initializeWasm() must be awaited first!");
24908 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_maximum_msat(this_ptr);
24909 return nativeResponseValue;
24911 // void UnsignedChannelUpdate_set_htlc_maximum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
24913 export function UnsignedChannelUpdate_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
24914 if(!isWasmInitialized) {
24915 throw new Error("initializeWasm() must be awaited first!");
24917 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_maximum_msat(this_ptr, val);
24918 // debug statements here
24920 // uint32_t UnsignedChannelUpdate_get_fee_base_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
24922 export function UnsignedChannelUpdate_get_fee_base_msat(this_ptr: bigint): number {
24923 if(!isWasmInitialized) {
24924 throw new Error("initializeWasm() must be awaited first!");
24926 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_base_msat(this_ptr);
24927 return nativeResponseValue;
24929 // void UnsignedChannelUpdate_set_fee_base_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
24931 export function UnsignedChannelUpdate_set_fee_base_msat(this_ptr: bigint, val: number): void {
24932 if(!isWasmInitialized) {
24933 throw new Error("initializeWasm() must be awaited first!");
24935 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_base_msat(this_ptr, val);
24936 // debug statements here
24938 // uint32_t UnsignedChannelUpdate_get_fee_proportional_millionths(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
24940 export function UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr: bigint): number {
24941 if(!isWasmInitialized) {
24942 throw new Error("initializeWasm() must be awaited first!");
24944 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr);
24945 return nativeResponseValue;
24947 // void UnsignedChannelUpdate_set_fee_proportional_millionths(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
24949 export function UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
24950 if(!isWasmInitialized) {
24951 throw new Error("initializeWasm() must be awaited first!");
24953 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr, val);
24954 // debug statements here
24956 // struct LDKCVec_u8Z UnsignedChannelUpdate_get_excess_data(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
24958 export function UnsignedChannelUpdate_get_excess_data(this_ptr: bigint): number {
24959 if(!isWasmInitialized) {
24960 throw new Error("initializeWasm() must be awaited first!");
24962 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_excess_data(this_ptr);
24963 return nativeResponseValue;
24965 // void UnsignedChannelUpdate_set_excess_data(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
24967 export function UnsignedChannelUpdate_set_excess_data(this_ptr: bigint, val: number): void {
24968 if(!isWasmInitialized) {
24969 throw new Error("initializeWasm() must be awaited first!");
24971 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_excess_data(this_ptr, val);
24972 // debug statements here
24974 // MUST_USE_RES struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_new(struct LDKThirtyTwoBytes chain_hash_arg, uint64_t short_channel_id_arg, uint32_t timestamp_arg, uint8_t flags_arg, uint16_t cltv_expiry_delta_arg, uint64_t htlc_minimum_msat_arg, uint64_t htlc_maximum_msat_arg, uint32_t fee_base_msat_arg, uint32_t fee_proportional_millionths_arg, struct LDKCVec_u8Z excess_data_arg);
24976 export function UnsignedChannelUpdate_new(chain_hash_arg: number, short_channel_id_arg: bigint, timestamp_arg: number, flags_arg: number, cltv_expiry_delta_arg: number, htlc_minimum_msat_arg: bigint, htlc_maximum_msat_arg: bigint, fee_base_msat_arg: number, fee_proportional_millionths_arg: number, excess_data_arg: number): bigint {
24977 if(!isWasmInitialized) {
24978 throw new Error("initializeWasm() must be awaited first!");
24980 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_new(chain_hash_arg, short_channel_id_arg, timestamp_arg, flags_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg, fee_base_msat_arg, fee_proportional_millionths_arg, excess_data_arg);
24981 return nativeResponseValue;
24983 // uint64_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg);
24985 export function UnsignedChannelUpdate_clone_ptr(arg: bigint): bigint {
24986 if(!isWasmInitialized) {
24987 throw new Error("initializeWasm() must be awaited first!");
24989 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone_ptr(arg);
24990 return nativeResponseValue;
24992 // struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_clone(const struct LDKUnsignedChannelUpdate *NONNULL_PTR orig);
24994 export function UnsignedChannelUpdate_clone(orig: bigint): bigint {
24995 if(!isWasmInitialized) {
24996 throw new Error("initializeWasm() must be awaited first!");
24998 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone(orig);
24999 return nativeResponseValue;
25001 // void ChannelUpdate_free(struct LDKChannelUpdate this_obj);
25003 export function ChannelUpdate_free(this_obj: bigint): void {
25004 if(!isWasmInitialized) {
25005 throw new Error("initializeWasm() must be awaited first!");
25007 const nativeResponseValue = wasm.TS_ChannelUpdate_free(this_obj);
25008 // debug statements here
25010 // struct LDKSignature ChannelUpdate_get_signature(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
25012 export function ChannelUpdate_get_signature(this_ptr: bigint): number {
25013 if(!isWasmInitialized) {
25014 throw new Error("initializeWasm() must be awaited first!");
25016 const nativeResponseValue = wasm.TS_ChannelUpdate_get_signature(this_ptr);
25017 return nativeResponseValue;
25019 // void ChannelUpdate_set_signature(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKSignature val);
25021 export function ChannelUpdate_set_signature(this_ptr: bigint, val: number): void {
25022 if(!isWasmInitialized) {
25023 throw new Error("initializeWasm() must be awaited first!");
25025 const nativeResponseValue = wasm.TS_ChannelUpdate_set_signature(this_ptr, val);
25026 // debug statements here
25028 // struct LDKUnsignedChannelUpdate ChannelUpdate_get_contents(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
25030 export function ChannelUpdate_get_contents(this_ptr: bigint): bigint {
25031 if(!isWasmInitialized) {
25032 throw new Error("initializeWasm() must be awaited first!");
25034 const nativeResponseValue = wasm.TS_ChannelUpdate_get_contents(this_ptr);
25035 return nativeResponseValue;
25037 // void ChannelUpdate_set_contents(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKUnsignedChannelUpdate val);
25039 export function ChannelUpdate_set_contents(this_ptr: bigint, val: bigint): void {
25040 if(!isWasmInitialized) {
25041 throw new Error("initializeWasm() must be awaited first!");
25043 const nativeResponseValue = wasm.TS_ChannelUpdate_set_contents(this_ptr, val);
25044 // debug statements here
25046 // MUST_USE_RES struct LDKChannelUpdate ChannelUpdate_new(struct LDKSignature signature_arg, struct LDKUnsignedChannelUpdate contents_arg);
25048 export function ChannelUpdate_new(signature_arg: number, contents_arg: bigint): bigint {
25049 if(!isWasmInitialized) {
25050 throw new Error("initializeWasm() must be awaited first!");
25052 const nativeResponseValue = wasm.TS_ChannelUpdate_new(signature_arg, contents_arg);
25053 return nativeResponseValue;
25055 // uint64_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg);
25057 export function ChannelUpdate_clone_ptr(arg: bigint): bigint {
25058 if(!isWasmInitialized) {
25059 throw new Error("initializeWasm() must be awaited first!");
25061 const nativeResponseValue = wasm.TS_ChannelUpdate_clone_ptr(arg);
25062 return nativeResponseValue;
25064 // struct LDKChannelUpdate ChannelUpdate_clone(const struct LDKChannelUpdate *NONNULL_PTR orig);
25066 export function ChannelUpdate_clone(orig: bigint): bigint {
25067 if(!isWasmInitialized) {
25068 throw new Error("initializeWasm() must be awaited first!");
25070 const nativeResponseValue = wasm.TS_ChannelUpdate_clone(orig);
25071 return nativeResponseValue;
25073 // void QueryChannelRange_free(struct LDKQueryChannelRange this_obj);
25075 export function QueryChannelRange_free(this_obj: bigint): void {
25076 if(!isWasmInitialized) {
25077 throw new Error("initializeWasm() must be awaited first!");
25079 const nativeResponseValue = wasm.TS_QueryChannelRange_free(this_obj);
25080 // debug statements here
25082 // const uint8_t (*QueryChannelRange_get_chain_hash(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr))[32];
25084 export function QueryChannelRange_get_chain_hash(this_ptr: bigint): number {
25085 if(!isWasmInitialized) {
25086 throw new Error("initializeWasm() must be awaited first!");
25088 const nativeResponseValue = wasm.TS_QueryChannelRange_get_chain_hash(this_ptr);
25089 return nativeResponseValue;
25091 // void QueryChannelRange_set_chain_hash(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25093 export function QueryChannelRange_set_chain_hash(this_ptr: bigint, val: number): void {
25094 if(!isWasmInitialized) {
25095 throw new Error("initializeWasm() must be awaited first!");
25097 const nativeResponseValue = wasm.TS_QueryChannelRange_set_chain_hash(this_ptr, val);
25098 // debug statements here
25100 // uint32_t QueryChannelRange_get_first_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
25102 export function QueryChannelRange_get_first_blocknum(this_ptr: bigint): number {
25103 if(!isWasmInitialized) {
25104 throw new Error("initializeWasm() must be awaited first!");
25106 const nativeResponseValue = wasm.TS_QueryChannelRange_get_first_blocknum(this_ptr);
25107 return nativeResponseValue;
25109 // void QueryChannelRange_set_first_blocknum(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
25111 export function QueryChannelRange_set_first_blocknum(this_ptr: bigint, val: number): void {
25112 if(!isWasmInitialized) {
25113 throw new Error("initializeWasm() must be awaited first!");
25115 const nativeResponseValue = wasm.TS_QueryChannelRange_set_first_blocknum(this_ptr, val);
25116 // debug statements here
25118 // uint32_t QueryChannelRange_get_number_of_blocks(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
25120 export function QueryChannelRange_get_number_of_blocks(this_ptr: bigint): number {
25121 if(!isWasmInitialized) {
25122 throw new Error("initializeWasm() must be awaited first!");
25124 const nativeResponseValue = wasm.TS_QueryChannelRange_get_number_of_blocks(this_ptr);
25125 return nativeResponseValue;
25127 // void QueryChannelRange_set_number_of_blocks(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
25129 export function QueryChannelRange_set_number_of_blocks(this_ptr: bigint, val: number): void {
25130 if(!isWasmInitialized) {
25131 throw new Error("initializeWasm() must be awaited first!");
25133 const nativeResponseValue = wasm.TS_QueryChannelRange_set_number_of_blocks(this_ptr, val);
25134 // debug statements here
25136 // MUST_USE_RES struct LDKQueryChannelRange QueryChannelRange_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_blocknum_arg, uint32_t number_of_blocks_arg);
25138 export function QueryChannelRange_new(chain_hash_arg: number, first_blocknum_arg: number, number_of_blocks_arg: number): bigint {
25139 if(!isWasmInitialized) {
25140 throw new Error("initializeWasm() must be awaited first!");
25142 const nativeResponseValue = wasm.TS_QueryChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg);
25143 return nativeResponseValue;
25145 // uint64_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg);
25147 export function QueryChannelRange_clone_ptr(arg: bigint): bigint {
25148 if(!isWasmInitialized) {
25149 throw new Error("initializeWasm() must be awaited first!");
25151 const nativeResponseValue = wasm.TS_QueryChannelRange_clone_ptr(arg);
25152 return nativeResponseValue;
25154 // struct LDKQueryChannelRange QueryChannelRange_clone(const struct LDKQueryChannelRange *NONNULL_PTR orig);
25156 export function QueryChannelRange_clone(orig: bigint): bigint {
25157 if(!isWasmInitialized) {
25158 throw new Error("initializeWasm() must be awaited first!");
25160 const nativeResponseValue = wasm.TS_QueryChannelRange_clone(orig);
25161 return nativeResponseValue;
25163 // void ReplyChannelRange_free(struct LDKReplyChannelRange this_obj);
25165 export function ReplyChannelRange_free(this_obj: bigint): void {
25166 if(!isWasmInitialized) {
25167 throw new Error("initializeWasm() must be awaited first!");
25169 const nativeResponseValue = wasm.TS_ReplyChannelRange_free(this_obj);
25170 // debug statements here
25172 // const uint8_t (*ReplyChannelRange_get_chain_hash(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr))[32];
25174 export function ReplyChannelRange_get_chain_hash(this_ptr: bigint): number {
25175 if(!isWasmInitialized) {
25176 throw new Error("initializeWasm() must be awaited first!");
25178 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_chain_hash(this_ptr);
25179 return nativeResponseValue;
25181 // void ReplyChannelRange_set_chain_hash(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25183 export function ReplyChannelRange_set_chain_hash(this_ptr: bigint, val: number): void {
25184 if(!isWasmInitialized) {
25185 throw new Error("initializeWasm() must be awaited first!");
25187 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_chain_hash(this_ptr, val);
25188 // debug statements here
25190 // uint32_t ReplyChannelRange_get_first_blocknum(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
25192 export function ReplyChannelRange_get_first_blocknum(this_ptr: bigint): number {
25193 if(!isWasmInitialized) {
25194 throw new Error("initializeWasm() must be awaited first!");
25196 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_first_blocknum(this_ptr);
25197 return nativeResponseValue;
25199 // void ReplyChannelRange_set_first_blocknum(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
25201 export function ReplyChannelRange_set_first_blocknum(this_ptr: bigint, val: number): void {
25202 if(!isWasmInitialized) {
25203 throw new Error("initializeWasm() must be awaited first!");
25205 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_first_blocknum(this_ptr, val);
25206 // debug statements here
25208 // uint32_t ReplyChannelRange_get_number_of_blocks(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
25210 export function ReplyChannelRange_get_number_of_blocks(this_ptr: bigint): number {
25211 if(!isWasmInitialized) {
25212 throw new Error("initializeWasm() must be awaited first!");
25214 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_number_of_blocks(this_ptr);
25215 return nativeResponseValue;
25217 // void ReplyChannelRange_set_number_of_blocks(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
25219 export function ReplyChannelRange_set_number_of_blocks(this_ptr: bigint, val: number): void {
25220 if(!isWasmInitialized) {
25221 throw new Error("initializeWasm() must be awaited first!");
25223 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_number_of_blocks(this_ptr, val);
25224 // debug statements here
25226 // bool ReplyChannelRange_get_sync_complete(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
25228 export function ReplyChannelRange_get_sync_complete(this_ptr: bigint): boolean {
25229 if(!isWasmInitialized) {
25230 throw new Error("initializeWasm() must be awaited first!");
25232 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_sync_complete(this_ptr);
25233 return nativeResponseValue;
25235 // void ReplyChannelRange_set_sync_complete(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, bool val);
25237 export function ReplyChannelRange_set_sync_complete(this_ptr: bigint, val: boolean): void {
25238 if(!isWasmInitialized) {
25239 throw new Error("initializeWasm() must be awaited first!");
25241 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_sync_complete(this_ptr, val);
25242 // debug statements here
25244 // struct LDKCVec_u64Z ReplyChannelRange_get_short_channel_ids(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
25246 export function ReplyChannelRange_get_short_channel_ids(this_ptr: bigint): number {
25247 if(!isWasmInitialized) {
25248 throw new Error("initializeWasm() must be awaited first!");
25250 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_short_channel_ids(this_ptr);
25251 return nativeResponseValue;
25253 // void ReplyChannelRange_set_short_channel_ids(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
25255 export function ReplyChannelRange_set_short_channel_ids(this_ptr: bigint, val: number): void {
25256 if(!isWasmInitialized) {
25257 throw new Error("initializeWasm() must be awaited first!");
25259 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_short_channel_ids(this_ptr, val);
25260 // debug statements here
25262 // 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);
25264 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): bigint {
25265 if(!isWasmInitialized) {
25266 throw new Error("initializeWasm() must be awaited first!");
25268 const nativeResponseValue = wasm.TS_ReplyChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg);
25269 return nativeResponseValue;
25271 // uint64_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg);
25273 export function ReplyChannelRange_clone_ptr(arg: bigint): bigint {
25274 if(!isWasmInitialized) {
25275 throw new Error("initializeWasm() must be awaited first!");
25277 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone_ptr(arg);
25278 return nativeResponseValue;
25280 // struct LDKReplyChannelRange ReplyChannelRange_clone(const struct LDKReplyChannelRange *NONNULL_PTR orig);
25282 export function ReplyChannelRange_clone(orig: bigint): bigint {
25283 if(!isWasmInitialized) {
25284 throw new Error("initializeWasm() must be awaited first!");
25286 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone(orig);
25287 return nativeResponseValue;
25289 // void QueryShortChannelIds_free(struct LDKQueryShortChannelIds this_obj);
25291 export function QueryShortChannelIds_free(this_obj: bigint): void {
25292 if(!isWasmInitialized) {
25293 throw new Error("initializeWasm() must be awaited first!");
25295 const nativeResponseValue = wasm.TS_QueryShortChannelIds_free(this_obj);
25296 // debug statements here
25298 // const uint8_t (*QueryShortChannelIds_get_chain_hash(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr))[32];
25300 export function QueryShortChannelIds_get_chain_hash(this_ptr: bigint): number {
25301 if(!isWasmInitialized) {
25302 throw new Error("initializeWasm() must be awaited first!");
25304 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_chain_hash(this_ptr);
25305 return nativeResponseValue;
25307 // void QueryShortChannelIds_set_chain_hash(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25309 export function QueryShortChannelIds_set_chain_hash(this_ptr: bigint, val: number): void {
25310 if(!isWasmInitialized) {
25311 throw new Error("initializeWasm() must be awaited first!");
25313 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_chain_hash(this_ptr, val);
25314 // debug statements here
25316 // struct LDKCVec_u64Z QueryShortChannelIds_get_short_channel_ids(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr);
25318 export function QueryShortChannelIds_get_short_channel_ids(this_ptr: bigint): number {
25319 if(!isWasmInitialized) {
25320 throw new Error("initializeWasm() must be awaited first!");
25322 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_short_channel_ids(this_ptr);
25323 return nativeResponseValue;
25325 // void QueryShortChannelIds_set_short_channel_ids(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
25327 export function QueryShortChannelIds_set_short_channel_ids(this_ptr: bigint, val: number): void {
25328 if(!isWasmInitialized) {
25329 throw new Error("initializeWasm() must be awaited first!");
25331 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_short_channel_ids(this_ptr, val);
25332 // debug statements here
25334 // MUST_USE_RES struct LDKQueryShortChannelIds QueryShortChannelIds_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKCVec_u64Z short_channel_ids_arg);
25336 export function QueryShortChannelIds_new(chain_hash_arg: number, short_channel_ids_arg: number): bigint {
25337 if(!isWasmInitialized) {
25338 throw new Error("initializeWasm() must be awaited first!");
25340 const nativeResponseValue = wasm.TS_QueryShortChannelIds_new(chain_hash_arg, short_channel_ids_arg);
25341 return nativeResponseValue;
25343 // uint64_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg);
25345 export function QueryShortChannelIds_clone_ptr(arg: bigint): bigint {
25346 if(!isWasmInitialized) {
25347 throw new Error("initializeWasm() must be awaited first!");
25349 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone_ptr(arg);
25350 return nativeResponseValue;
25352 // struct LDKQueryShortChannelIds QueryShortChannelIds_clone(const struct LDKQueryShortChannelIds *NONNULL_PTR orig);
25354 export function QueryShortChannelIds_clone(orig: bigint): bigint {
25355 if(!isWasmInitialized) {
25356 throw new Error("initializeWasm() must be awaited first!");
25358 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone(orig);
25359 return nativeResponseValue;
25361 // void ReplyShortChannelIdsEnd_free(struct LDKReplyShortChannelIdsEnd this_obj);
25363 export function ReplyShortChannelIdsEnd_free(this_obj: bigint): void {
25364 if(!isWasmInitialized) {
25365 throw new Error("initializeWasm() must be awaited first!");
25367 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_free(this_obj);
25368 // debug statements here
25370 // const uint8_t (*ReplyShortChannelIdsEnd_get_chain_hash(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr))[32];
25372 export function ReplyShortChannelIdsEnd_get_chain_hash(this_ptr: bigint): number {
25373 if(!isWasmInitialized) {
25374 throw new Error("initializeWasm() must be awaited first!");
25376 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_chain_hash(this_ptr);
25377 return nativeResponseValue;
25379 // void ReplyShortChannelIdsEnd_set_chain_hash(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25381 export function ReplyShortChannelIdsEnd_set_chain_hash(this_ptr: bigint, val: number): void {
25382 if(!isWasmInitialized) {
25383 throw new Error("initializeWasm() must be awaited first!");
25385 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_chain_hash(this_ptr, val);
25386 // debug statements here
25388 // bool ReplyShortChannelIdsEnd_get_full_information(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr);
25390 export function ReplyShortChannelIdsEnd_get_full_information(this_ptr: bigint): boolean {
25391 if(!isWasmInitialized) {
25392 throw new Error("initializeWasm() must be awaited first!");
25394 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_full_information(this_ptr);
25395 return nativeResponseValue;
25397 // void ReplyShortChannelIdsEnd_set_full_information(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, bool val);
25399 export function ReplyShortChannelIdsEnd_set_full_information(this_ptr: bigint, val: boolean): void {
25400 if(!isWasmInitialized) {
25401 throw new Error("initializeWasm() must be awaited first!");
25403 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_full_information(this_ptr, val);
25404 // debug statements here
25406 // MUST_USE_RES struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_new(struct LDKThirtyTwoBytes chain_hash_arg, bool full_information_arg);
25408 export function ReplyShortChannelIdsEnd_new(chain_hash_arg: number, full_information_arg: boolean): bigint {
25409 if(!isWasmInitialized) {
25410 throw new Error("initializeWasm() must be awaited first!");
25412 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_new(chain_hash_arg, full_information_arg);
25413 return nativeResponseValue;
25415 // uint64_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg);
25417 export function ReplyShortChannelIdsEnd_clone_ptr(arg: bigint): bigint {
25418 if(!isWasmInitialized) {
25419 throw new Error("initializeWasm() must be awaited first!");
25421 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone_ptr(arg);
25422 return nativeResponseValue;
25424 // struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_clone(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR orig);
25426 export function ReplyShortChannelIdsEnd_clone(orig: bigint): bigint {
25427 if(!isWasmInitialized) {
25428 throw new Error("initializeWasm() must be awaited first!");
25430 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone(orig);
25431 return nativeResponseValue;
25433 // void GossipTimestampFilter_free(struct LDKGossipTimestampFilter this_obj);
25435 export function GossipTimestampFilter_free(this_obj: bigint): void {
25436 if(!isWasmInitialized) {
25437 throw new Error("initializeWasm() must be awaited first!");
25439 const nativeResponseValue = wasm.TS_GossipTimestampFilter_free(this_obj);
25440 // debug statements here
25442 // const uint8_t (*GossipTimestampFilter_get_chain_hash(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr))[32];
25444 export function GossipTimestampFilter_get_chain_hash(this_ptr: bigint): number {
25445 if(!isWasmInitialized) {
25446 throw new Error("initializeWasm() must be awaited first!");
25448 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_chain_hash(this_ptr);
25449 return nativeResponseValue;
25451 // void GossipTimestampFilter_set_chain_hash(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25453 export function GossipTimestampFilter_set_chain_hash(this_ptr: bigint, val: number): void {
25454 if(!isWasmInitialized) {
25455 throw new Error("initializeWasm() must be awaited first!");
25457 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_chain_hash(this_ptr, val);
25458 // debug statements here
25460 // uint32_t GossipTimestampFilter_get_first_timestamp(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
25462 export function GossipTimestampFilter_get_first_timestamp(this_ptr: bigint): number {
25463 if(!isWasmInitialized) {
25464 throw new Error("initializeWasm() must be awaited first!");
25466 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_first_timestamp(this_ptr);
25467 return nativeResponseValue;
25469 // void GossipTimestampFilter_set_first_timestamp(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
25471 export function GossipTimestampFilter_set_first_timestamp(this_ptr: bigint, val: number): void {
25472 if(!isWasmInitialized) {
25473 throw new Error("initializeWasm() must be awaited first!");
25475 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_first_timestamp(this_ptr, val);
25476 // debug statements here
25478 // uint32_t GossipTimestampFilter_get_timestamp_range(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
25480 export function GossipTimestampFilter_get_timestamp_range(this_ptr: bigint): number {
25481 if(!isWasmInitialized) {
25482 throw new Error("initializeWasm() must be awaited first!");
25484 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_timestamp_range(this_ptr);
25485 return nativeResponseValue;
25487 // void GossipTimestampFilter_set_timestamp_range(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
25489 export function GossipTimestampFilter_set_timestamp_range(this_ptr: bigint, val: number): void {
25490 if(!isWasmInitialized) {
25491 throw new Error("initializeWasm() must be awaited first!");
25493 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_timestamp_range(this_ptr, val);
25494 // debug statements here
25496 // MUST_USE_RES struct LDKGossipTimestampFilter GossipTimestampFilter_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_timestamp_arg, uint32_t timestamp_range_arg);
25498 export function GossipTimestampFilter_new(chain_hash_arg: number, first_timestamp_arg: number, timestamp_range_arg: number): bigint {
25499 if(!isWasmInitialized) {
25500 throw new Error("initializeWasm() must be awaited first!");
25502 const nativeResponseValue = wasm.TS_GossipTimestampFilter_new(chain_hash_arg, first_timestamp_arg, timestamp_range_arg);
25503 return nativeResponseValue;
25505 // uint64_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg);
25507 export function GossipTimestampFilter_clone_ptr(arg: bigint): bigint {
25508 if(!isWasmInitialized) {
25509 throw new Error("initializeWasm() must be awaited first!");
25511 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone_ptr(arg);
25512 return nativeResponseValue;
25514 // struct LDKGossipTimestampFilter GossipTimestampFilter_clone(const struct LDKGossipTimestampFilter *NONNULL_PTR orig);
25516 export function GossipTimestampFilter_clone(orig: bigint): bigint {
25517 if(!isWasmInitialized) {
25518 throw new Error("initializeWasm() must be awaited first!");
25520 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone(orig);
25521 return nativeResponseValue;
25523 // void ErrorAction_free(struct LDKErrorAction this_ptr);
25525 export function ErrorAction_free(this_ptr: bigint): void {
25526 if(!isWasmInitialized) {
25527 throw new Error("initializeWasm() must be awaited first!");
25529 const nativeResponseValue = wasm.TS_ErrorAction_free(this_ptr);
25530 // debug statements here
25532 // uint64_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg);
25534 export function ErrorAction_clone_ptr(arg: bigint): bigint {
25535 if(!isWasmInitialized) {
25536 throw new Error("initializeWasm() must be awaited first!");
25538 const nativeResponseValue = wasm.TS_ErrorAction_clone_ptr(arg);
25539 return nativeResponseValue;
25541 // struct LDKErrorAction ErrorAction_clone(const struct LDKErrorAction *NONNULL_PTR orig);
25543 export function ErrorAction_clone(orig: bigint): bigint {
25544 if(!isWasmInitialized) {
25545 throw new Error("initializeWasm() must be awaited first!");
25547 const nativeResponseValue = wasm.TS_ErrorAction_clone(orig);
25548 return nativeResponseValue;
25550 // struct LDKErrorAction ErrorAction_disconnect_peer(struct LDKErrorMessage msg);
25552 export function ErrorAction_disconnect_peer(msg: bigint): bigint {
25553 if(!isWasmInitialized) {
25554 throw new Error("initializeWasm() must be awaited first!");
25556 const nativeResponseValue = wasm.TS_ErrorAction_disconnect_peer(msg);
25557 return nativeResponseValue;
25559 // struct LDKErrorAction ErrorAction_ignore_error(void);
25561 export function ErrorAction_ignore_error(): bigint {
25562 if(!isWasmInitialized) {
25563 throw new Error("initializeWasm() must be awaited first!");
25565 const nativeResponseValue = wasm.TS_ErrorAction_ignore_error();
25566 return nativeResponseValue;
25568 // struct LDKErrorAction ErrorAction_ignore_and_log(enum LDKLevel a);
25570 export function ErrorAction_ignore_and_log(a: Level): bigint {
25571 if(!isWasmInitialized) {
25572 throw new Error("initializeWasm() must be awaited first!");
25574 const nativeResponseValue = wasm.TS_ErrorAction_ignore_and_log(a);
25575 return nativeResponseValue;
25577 // struct LDKErrorAction ErrorAction_ignore_duplicate_gossip(void);
25579 export function ErrorAction_ignore_duplicate_gossip(): bigint {
25580 if(!isWasmInitialized) {
25581 throw new Error("initializeWasm() must be awaited first!");
25583 const nativeResponseValue = wasm.TS_ErrorAction_ignore_duplicate_gossip();
25584 return nativeResponseValue;
25586 // struct LDKErrorAction ErrorAction_send_error_message(struct LDKErrorMessage msg);
25588 export function ErrorAction_send_error_message(msg: bigint): bigint {
25589 if(!isWasmInitialized) {
25590 throw new Error("initializeWasm() must be awaited first!");
25592 const nativeResponseValue = wasm.TS_ErrorAction_send_error_message(msg);
25593 return nativeResponseValue;
25595 // struct LDKErrorAction ErrorAction_send_warning_message(struct LDKWarningMessage msg, enum LDKLevel log_level);
25597 export function ErrorAction_send_warning_message(msg: bigint, log_level: Level): bigint {
25598 if(!isWasmInitialized) {
25599 throw new Error("initializeWasm() must be awaited first!");
25601 const nativeResponseValue = wasm.TS_ErrorAction_send_warning_message(msg, log_level);
25602 return nativeResponseValue;
25604 // void LightningError_free(struct LDKLightningError this_obj);
25606 export function LightningError_free(this_obj: bigint): void {
25607 if(!isWasmInitialized) {
25608 throw new Error("initializeWasm() must be awaited first!");
25610 const nativeResponseValue = wasm.TS_LightningError_free(this_obj);
25611 // debug statements here
25613 // struct LDKStr LightningError_get_err(const struct LDKLightningError *NONNULL_PTR this_ptr);
25615 export function LightningError_get_err(this_ptr: bigint): number {
25616 if(!isWasmInitialized) {
25617 throw new Error("initializeWasm() must be awaited first!");
25619 const nativeResponseValue = wasm.TS_LightningError_get_err(this_ptr);
25620 return nativeResponseValue;
25622 // void LightningError_set_err(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKStr val);
25624 export function LightningError_set_err(this_ptr: bigint, val: number): void {
25625 if(!isWasmInitialized) {
25626 throw new Error("initializeWasm() must be awaited first!");
25628 const nativeResponseValue = wasm.TS_LightningError_set_err(this_ptr, val);
25629 // debug statements here
25631 // struct LDKErrorAction LightningError_get_action(const struct LDKLightningError *NONNULL_PTR this_ptr);
25633 export function LightningError_get_action(this_ptr: bigint): bigint {
25634 if(!isWasmInitialized) {
25635 throw new Error("initializeWasm() must be awaited first!");
25637 const nativeResponseValue = wasm.TS_LightningError_get_action(this_ptr);
25638 return nativeResponseValue;
25640 // void LightningError_set_action(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKErrorAction val);
25642 export function LightningError_set_action(this_ptr: bigint, val: bigint): void {
25643 if(!isWasmInitialized) {
25644 throw new Error("initializeWasm() must be awaited first!");
25646 const nativeResponseValue = wasm.TS_LightningError_set_action(this_ptr, val);
25647 // debug statements here
25649 // MUST_USE_RES struct LDKLightningError LightningError_new(struct LDKStr err_arg, struct LDKErrorAction action_arg);
25651 export function LightningError_new(err_arg: number, action_arg: bigint): bigint {
25652 if(!isWasmInitialized) {
25653 throw new Error("initializeWasm() must be awaited first!");
25655 const nativeResponseValue = wasm.TS_LightningError_new(err_arg, action_arg);
25656 return nativeResponseValue;
25658 // uint64_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg);
25660 export function LightningError_clone_ptr(arg: bigint): bigint {
25661 if(!isWasmInitialized) {
25662 throw new Error("initializeWasm() must be awaited first!");
25664 const nativeResponseValue = wasm.TS_LightningError_clone_ptr(arg);
25665 return nativeResponseValue;
25667 // struct LDKLightningError LightningError_clone(const struct LDKLightningError *NONNULL_PTR orig);
25669 export function LightningError_clone(orig: bigint): bigint {
25670 if(!isWasmInitialized) {
25671 throw new Error("initializeWasm() must be awaited first!");
25673 const nativeResponseValue = wasm.TS_LightningError_clone(orig);
25674 return nativeResponseValue;
25676 // void CommitmentUpdate_free(struct LDKCommitmentUpdate this_obj);
25678 export function CommitmentUpdate_free(this_obj: bigint): void {
25679 if(!isWasmInitialized) {
25680 throw new Error("initializeWasm() must be awaited first!");
25682 const nativeResponseValue = wasm.TS_CommitmentUpdate_free(this_obj);
25683 // debug statements here
25685 // struct LDKCVec_UpdateAddHTLCZ CommitmentUpdate_get_update_add_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
25687 export function CommitmentUpdate_get_update_add_htlcs(this_ptr: bigint): number {
25688 if(!isWasmInitialized) {
25689 throw new Error("initializeWasm() must be awaited first!");
25691 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_add_htlcs(this_ptr);
25692 return nativeResponseValue;
25694 // void CommitmentUpdate_set_update_add_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateAddHTLCZ val);
25696 export function CommitmentUpdate_set_update_add_htlcs(this_ptr: bigint, val: number): void {
25697 if(!isWasmInitialized) {
25698 throw new Error("initializeWasm() must be awaited first!");
25700 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_add_htlcs(this_ptr, val);
25701 // debug statements here
25703 // struct LDKCVec_UpdateFulfillHTLCZ CommitmentUpdate_get_update_fulfill_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
25705 export function CommitmentUpdate_get_update_fulfill_htlcs(this_ptr: bigint): number {
25706 if(!isWasmInitialized) {
25707 throw new Error("initializeWasm() must be awaited first!");
25709 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fulfill_htlcs(this_ptr);
25710 return nativeResponseValue;
25712 // void CommitmentUpdate_set_update_fulfill_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFulfillHTLCZ val);
25714 export function CommitmentUpdate_set_update_fulfill_htlcs(this_ptr: bigint, val: number): void {
25715 if(!isWasmInitialized) {
25716 throw new Error("initializeWasm() must be awaited first!");
25718 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fulfill_htlcs(this_ptr, val);
25719 // debug statements here
25721 // struct LDKCVec_UpdateFailHTLCZ CommitmentUpdate_get_update_fail_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
25723 export function CommitmentUpdate_get_update_fail_htlcs(this_ptr: bigint): number {
25724 if(!isWasmInitialized) {
25725 throw new Error("initializeWasm() must be awaited first!");
25727 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_htlcs(this_ptr);
25728 return nativeResponseValue;
25730 // void CommitmentUpdate_set_update_fail_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailHTLCZ val);
25732 export function CommitmentUpdate_set_update_fail_htlcs(this_ptr: bigint, val: number): void {
25733 if(!isWasmInitialized) {
25734 throw new Error("initializeWasm() must be awaited first!");
25736 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_htlcs(this_ptr, val);
25737 // debug statements here
25739 // struct LDKCVec_UpdateFailMalformedHTLCZ CommitmentUpdate_get_update_fail_malformed_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
25741 export function CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr: bigint): number {
25742 if(!isWasmInitialized) {
25743 throw new Error("initializeWasm() must be awaited first!");
25745 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr);
25746 return nativeResponseValue;
25748 // void CommitmentUpdate_set_update_fail_malformed_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailMalformedHTLCZ val);
25750 export function CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr: bigint, val: number): void {
25751 if(!isWasmInitialized) {
25752 throw new Error("initializeWasm() must be awaited first!");
25754 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr, val);
25755 // debug statements here
25757 // struct LDKUpdateFee CommitmentUpdate_get_update_fee(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
25759 export function CommitmentUpdate_get_update_fee(this_ptr: bigint): bigint {
25760 if(!isWasmInitialized) {
25761 throw new Error("initializeWasm() must be awaited first!");
25763 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fee(this_ptr);
25764 return nativeResponseValue;
25766 // void CommitmentUpdate_set_update_fee(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKUpdateFee val);
25768 export function CommitmentUpdate_set_update_fee(this_ptr: bigint, val: bigint): void {
25769 if(!isWasmInitialized) {
25770 throw new Error("initializeWasm() must be awaited first!");
25772 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fee(this_ptr, val);
25773 // debug statements here
25775 // struct LDKCommitmentSigned CommitmentUpdate_get_commitment_signed(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
25777 export function CommitmentUpdate_get_commitment_signed(this_ptr: bigint): bigint {
25778 if(!isWasmInitialized) {
25779 throw new Error("initializeWasm() must be awaited first!");
25781 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_commitment_signed(this_ptr);
25782 return nativeResponseValue;
25784 // void CommitmentUpdate_set_commitment_signed(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCommitmentSigned val);
25786 export function CommitmentUpdate_set_commitment_signed(this_ptr: bigint, val: bigint): void {
25787 if(!isWasmInitialized) {
25788 throw new Error("initializeWasm() must be awaited first!");
25790 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_commitment_signed(this_ptr, val);
25791 // debug statements here
25793 // 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);
25795 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: bigint, commitment_signed_arg: bigint): bigint {
25796 if(!isWasmInitialized) {
25797 throw new Error("initializeWasm() must be awaited first!");
25799 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);
25800 return nativeResponseValue;
25802 // uint64_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg);
25804 export function CommitmentUpdate_clone_ptr(arg: bigint): bigint {
25805 if(!isWasmInitialized) {
25806 throw new Error("initializeWasm() must be awaited first!");
25808 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone_ptr(arg);
25809 return nativeResponseValue;
25811 // struct LDKCommitmentUpdate CommitmentUpdate_clone(const struct LDKCommitmentUpdate *NONNULL_PTR orig);
25813 export function CommitmentUpdate_clone(orig: bigint): bigint {
25814 if(!isWasmInitialized) {
25815 throw new Error("initializeWasm() must be awaited first!");
25817 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone(orig);
25818 return nativeResponseValue;
25820 // void ChannelMessageHandler_free(struct LDKChannelMessageHandler this_ptr);
25822 export function ChannelMessageHandler_free(this_ptr: bigint): void {
25823 if(!isWasmInitialized) {
25824 throw new Error("initializeWasm() must be awaited first!");
25826 const nativeResponseValue = wasm.TS_ChannelMessageHandler_free(this_ptr);
25827 // debug statements here
25829 // void RoutingMessageHandler_free(struct LDKRoutingMessageHandler this_ptr);
25831 export function RoutingMessageHandler_free(this_ptr: bigint): void {
25832 if(!isWasmInitialized) {
25833 throw new Error("initializeWasm() must be awaited first!");
25835 const nativeResponseValue = wasm.TS_RoutingMessageHandler_free(this_ptr);
25836 // debug statements here
25838 // void OnionMessageHandler_free(struct LDKOnionMessageHandler this_ptr);
25840 export function OnionMessageHandler_free(this_ptr: bigint): void {
25841 if(!isWasmInitialized) {
25842 throw new Error("initializeWasm() must be awaited first!");
25844 const nativeResponseValue = wasm.TS_OnionMessageHandler_free(this_ptr);
25845 // debug statements here
25847 // struct LDKCVec_u8Z AcceptChannel_write(const struct LDKAcceptChannel *NONNULL_PTR obj);
25849 export function AcceptChannel_write(obj: bigint): number {
25850 if(!isWasmInitialized) {
25851 throw new Error("initializeWasm() must be awaited first!");
25853 const nativeResponseValue = wasm.TS_AcceptChannel_write(obj);
25854 return nativeResponseValue;
25856 // struct LDKCResult_AcceptChannelDecodeErrorZ AcceptChannel_read(struct LDKu8slice ser);
25858 export function AcceptChannel_read(ser: number): bigint {
25859 if(!isWasmInitialized) {
25860 throw new Error("initializeWasm() must be awaited first!");
25862 const nativeResponseValue = wasm.TS_AcceptChannel_read(ser);
25863 return nativeResponseValue;
25865 // struct LDKCVec_u8Z AnnouncementSignatures_write(const struct LDKAnnouncementSignatures *NONNULL_PTR obj);
25867 export function AnnouncementSignatures_write(obj: bigint): number {
25868 if(!isWasmInitialized) {
25869 throw new Error("initializeWasm() must be awaited first!");
25871 const nativeResponseValue = wasm.TS_AnnouncementSignatures_write(obj);
25872 return nativeResponseValue;
25874 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ AnnouncementSignatures_read(struct LDKu8slice ser);
25876 export function AnnouncementSignatures_read(ser: number): bigint {
25877 if(!isWasmInitialized) {
25878 throw new Error("initializeWasm() must be awaited first!");
25880 const nativeResponseValue = wasm.TS_AnnouncementSignatures_read(ser);
25881 return nativeResponseValue;
25883 // struct LDKCVec_u8Z ChannelReestablish_write(const struct LDKChannelReestablish *NONNULL_PTR obj);
25885 export function ChannelReestablish_write(obj: bigint): number {
25886 if(!isWasmInitialized) {
25887 throw new Error("initializeWasm() must be awaited first!");
25889 const nativeResponseValue = wasm.TS_ChannelReestablish_write(obj);
25890 return nativeResponseValue;
25892 // struct LDKCResult_ChannelReestablishDecodeErrorZ ChannelReestablish_read(struct LDKu8slice ser);
25894 export function ChannelReestablish_read(ser: number): bigint {
25895 if(!isWasmInitialized) {
25896 throw new Error("initializeWasm() must be awaited first!");
25898 const nativeResponseValue = wasm.TS_ChannelReestablish_read(ser);
25899 return nativeResponseValue;
25901 // struct LDKCVec_u8Z ClosingSigned_write(const struct LDKClosingSigned *NONNULL_PTR obj);
25903 export function ClosingSigned_write(obj: bigint): number {
25904 if(!isWasmInitialized) {
25905 throw new Error("initializeWasm() must be awaited first!");
25907 const nativeResponseValue = wasm.TS_ClosingSigned_write(obj);
25908 return nativeResponseValue;
25910 // struct LDKCResult_ClosingSignedDecodeErrorZ ClosingSigned_read(struct LDKu8slice ser);
25912 export function ClosingSigned_read(ser: number): bigint {
25913 if(!isWasmInitialized) {
25914 throw new Error("initializeWasm() must be awaited first!");
25916 const nativeResponseValue = wasm.TS_ClosingSigned_read(ser);
25917 return nativeResponseValue;
25919 // struct LDKCVec_u8Z ClosingSignedFeeRange_write(const struct LDKClosingSignedFeeRange *NONNULL_PTR obj);
25921 export function ClosingSignedFeeRange_write(obj: bigint): number {
25922 if(!isWasmInitialized) {
25923 throw new Error("initializeWasm() must be awaited first!");
25925 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_write(obj);
25926 return nativeResponseValue;
25928 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ ClosingSignedFeeRange_read(struct LDKu8slice ser);
25930 export function ClosingSignedFeeRange_read(ser: number): bigint {
25931 if(!isWasmInitialized) {
25932 throw new Error("initializeWasm() must be awaited first!");
25934 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_read(ser);
25935 return nativeResponseValue;
25937 // struct LDKCVec_u8Z CommitmentSigned_write(const struct LDKCommitmentSigned *NONNULL_PTR obj);
25939 export function CommitmentSigned_write(obj: bigint): number {
25940 if(!isWasmInitialized) {
25941 throw new Error("initializeWasm() must be awaited first!");
25943 const nativeResponseValue = wasm.TS_CommitmentSigned_write(obj);
25944 return nativeResponseValue;
25946 // struct LDKCResult_CommitmentSignedDecodeErrorZ CommitmentSigned_read(struct LDKu8slice ser);
25948 export function CommitmentSigned_read(ser: number): bigint {
25949 if(!isWasmInitialized) {
25950 throw new Error("initializeWasm() must be awaited first!");
25952 const nativeResponseValue = wasm.TS_CommitmentSigned_read(ser);
25953 return nativeResponseValue;
25955 // struct LDKCVec_u8Z FundingCreated_write(const struct LDKFundingCreated *NONNULL_PTR obj);
25957 export function FundingCreated_write(obj: bigint): number {
25958 if(!isWasmInitialized) {
25959 throw new Error("initializeWasm() must be awaited first!");
25961 const nativeResponseValue = wasm.TS_FundingCreated_write(obj);
25962 return nativeResponseValue;
25964 // struct LDKCResult_FundingCreatedDecodeErrorZ FundingCreated_read(struct LDKu8slice ser);
25966 export function FundingCreated_read(ser: number): bigint {
25967 if(!isWasmInitialized) {
25968 throw new Error("initializeWasm() must be awaited first!");
25970 const nativeResponseValue = wasm.TS_FundingCreated_read(ser);
25971 return nativeResponseValue;
25973 // struct LDKCVec_u8Z FundingSigned_write(const struct LDKFundingSigned *NONNULL_PTR obj);
25975 export function FundingSigned_write(obj: bigint): number {
25976 if(!isWasmInitialized) {
25977 throw new Error("initializeWasm() must be awaited first!");
25979 const nativeResponseValue = wasm.TS_FundingSigned_write(obj);
25980 return nativeResponseValue;
25982 // struct LDKCResult_FundingSignedDecodeErrorZ FundingSigned_read(struct LDKu8slice ser);
25984 export function FundingSigned_read(ser: number): bigint {
25985 if(!isWasmInitialized) {
25986 throw new Error("initializeWasm() must be awaited first!");
25988 const nativeResponseValue = wasm.TS_FundingSigned_read(ser);
25989 return nativeResponseValue;
25991 // struct LDKCVec_u8Z ChannelReady_write(const struct LDKChannelReady *NONNULL_PTR obj);
25993 export function ChannelReady_write(obj: bigint): number {
25994 if(!isWasmInitialized) {
25995 throw new Error("initializeWasm() must be awaited first!");
25997 const nativeResponseValue = wasm.TS_ChannelReady_write(obj);
25998 return nativeResponseValue;
26000 // struct LDKCResult_ChannelReadyDecodeErrorZ ChannelReady_read(struct LDKu8slice ser);
26002 export function ChannelReady_read(ser: number): bigint {
26003 if(!isWasmInitialized) {
26004 throw new Error("initializeWasm() must be awaited first!");
26006 const nativeResponseValue = wasm.TS_ChannelReady_read(ser);
26007 return nativeResponseValue;
26009 // struct LDKCVec_u8Z Init_write(const struct LDKInit *NONNULL_PTR obj);
26011 export function Init_write(obj: bigint): number {
26012 if(!isWasmInitialized) {
26013 throw new Error("initializeWasm() must be awaited first!");
26015 const nativeResponseValue = wasm.TS_Init_write(obj);
26016 return nativeResponseValue;
26018 // struct LDKCResult_InitDecodeErrorZ Init_read(struct LDKu8slice ser);
26020 export function Init_read(ser: number): bigint {
26021 if(!isWasmInitialized) {
26022 throw new Error("initializeWasm() must be awaited first!");
26024 const nativeResponseValue = wasm.TS_Init_read(ser);
26025 return nativeResponseValue;
26027 // struct LDKCVec_u8Z OpenChannel_write(const struct LDKOpenChannel *NONNULL_PTR obj);
26029 export function OpenChannel_write(obj: bigint): number {
26030 if(!isWasmInitialized) {
26031 throw new Error("initializeWasm() must be awaited first!");
26033 const nativeResponseValue = wasm.TS_OpenChannel_write(obj);
26034 return nativeResponseValue;
26036 // struct LDKCResult_OpenChannelDecodeErrorZ OpenChannel_read(struct LDKu8slice ser);
26038 export function OpenChannel_read(ser: number): bigint {
26039 if(!isWasmInitialized) {
26040 throw new Error("initializeWasm() must be awaited first!");
26042 const nativeResponseValue = wasm.TS_OpenChannel_read(ser);
26043 return nativeResponseValue;
26045 // struct LDKCVec_u8Z RevokeAndACK_write(const struct LDKRevokeAndACK *NONNULL_PTR obj);
26047 export function RevokeAndACK_write(obj: bigint): number {
26048 if(!isWasmInitialized) {
26049 throw new Error("initializeWasm() must be awaited first!");
26051 const nativeResponseValue = wasm.TS_RevokeAndACK_write(obj);
26052 return nativeResponseValue;
26054 // struct LDKCResult_RevokeAndACKDecodeErrorZ RevokeAndACK_read(struct LDKu8slice ser);
26056 export function RevokeAndACK_read(ser: number): bigint {
26057 if(!isWasmInitialized) {
26058 throw new Error("initializeWasm() must be awaited first!");
26060 const nativeResponseValue = wasm.TS_RevokeAndACK_read(ser);
26061 return nativeResponseValue;
26063 // struct LDKCVec_u8Z Shutdown_write(const struct LDKShutdown *NONNULL_PTR obj);
26065 export function Shutdown_write(obj: bigint): number {
26066 if(!isWasmInitialized) {
26067 throw new Error("initializeWasm() must be awaited first!");
26069 const nativeResponseValue = wasm.TS_Shutdown_write(obj);
26070 return nativeResponseValue;
26072 // struct LDKCResult_ShutdownDecodeErrorZ Shutdown_read(struct LDKu8slice ser);
26074 export function Shutdown_read(ser: number): bigint {
26075 if(!isWasmInitialized) {
26076 throw new Error("initializeWasm() must be awaited first!");
26078 const nativeResponseValue = wasm.TS_Shutdown_read(ser);
26079 return nativeResponseValue;
26081 // struct LDKCVec_u8Z UpdateFailHTLC_write(const struct LDKUpdateFailHTLC *NONNULL_PTR obj);
26083 export function UpdateFailHTLC_write(obj: bigint): number {
26084 if(!isWasmInitialized) {
26085 throw new Error("initializeWasm() must be awaited first!");
26087 const nativeResponseValue = wasm.TS_UpdateFailHTLC_write(obj);
26088 return nativeResponseValue;
26090 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ UpdateFailHTLC_read(struct LDKu8slice ser);
26092 export function UpdateFailHTLC_read(ser: number): bigint {
26093 if(!isWasmInitialized) {
26094 throw new Error("initializeWasm() must be awaited first!");
26096 const nativeResponseValue = wasm.TS_UpdateFailHTLC_read(ser);
26097 return nativeResponseValue;
26099 // struct LDKCVec_u8Z UpdateFailMalformedHTLC_write(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR obj);
26101 export function UpdateFailMalformedHTLC_write(obj: bigint): number {
26102 if(!isWasmInitialized) {
26103 throw new Error("initializeWasm() must be awaited first!");
26105 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_write(obj);
26106 return nativeResponseValue;
26108 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ UpdateFailMalformedHTLC_read(struct LDKu8slice ser);
26110 export function UpdateFailMalformedHTLC_read(ser: number): bigint {
26111 if(!isWasmInitialized) {
26112 throw new Error("initializeWasm() must be awaited first!");
26114 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_read(ser);
26115 return nativeResponseValue;
26117 // struct LDKCVec_u8Z UpdateFee_write(const struct LDKUpdateFee *NONNULL_PTR obj);
26119 export function UpdateFee_write(obj: bigint): number {
26120 if(!isWasmInitialized) {
26121 throw new Error("initializeWasm() must be awaited first!");
26123 const nativeResponseValue = wasm.TS_UpdateFee_write(obj);
26124 return nativeResponseValue;
26126 // struct LDKCResult_UpdateFeeDecodeErrorZ UpdateFee_read(struct LDKu8slice ser);
26128 export function UpdateFee_read(ser: number): bigint {
26129 if(!isWasmInitialized) {
26130 throw new Error("initializeWasm() must be awaited first!");
26132 const nativeResponseValue = wasm.TS_UpdateFee_read(ser);
26133 return nativeResponseValue;
26135 // struct LDKCVec_u8Z UpdateFulfillHTLC_write(const struct LDKUpdateFulfillHTLC *NONNULL_PTR obj);
26137 export function UpdateFulfillHTLC_write(obj: bigint): number {
26138 if(!isWasmInitialized) {
26139 throw new Error("initializeWasm() must be awaited first!");
26141 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_write(obj);
26142 return nativeResponseValue;
26144 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ UpdateFulfillHTLC_read(struct LDKu8slice ser);
26146 export function UpdateFulfillHTLC_read(ser: number): bigint {
26147 if(!isWasmInitialized) {
26148 throw new Error("initializeWasm() must be awaited first!");
26150 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_read(ser);
26151 return nativeResponseValue;
26153 // struct LDKCVec_u8Z UpdateAddHTLC_write(const struct LDKUpdateAddHTLC *NONNULL_PTR obj);
26155 export function UpdateAddHTLC_write(obj: bigint): number {
26156 if(!isWasmInitialized) {
26157 throw new Error("initializeWasm() must be awaited first!");
26159 const nativeResponseValue = wasm.TS_UpdateAddHTLC_write(obj);
26160 return nativeResponseValue;
26162 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ UpdateAddHTLC_read(struct LDKu8slice ser);
26164 export function UpdateAddHTLC_read(ser: number): bigint {
26165 if(!isWasmInitialized) {
26166 throw new Error("initializeWasm() must be awaited first!");
26168 const nativeResponseValue = wasm.TS_UpdateAddHTLC_read(ser);
26169 return nativeResponseValue;
26171 // struct LDKCResult_OnionMessageDecodeErrorZ OnionMessage_read(struct LDKu8slice ser);
26173 export function OnionMessage_read(ser: number): bigint {
26174 if(!isWasmInitialized) {
26175 throw new Error("initializeWasm() must be awaited first!");
26177 const nativeResponseValue = wasm.TS_OnionMessage_read(ser);
26178 return nativeResponseValue;
26180 // struct LDKCVec_u8Z OnionMessage_write(const struct LDKOnionMessage *NONNULL_PTR obj);
26182 export function OnionMessage_write(obj: bigint): number {
26183 if(!isWasmInitialized) {
26184 throw new Error("initializeWasm() must be awaited first!");
26186 const nativeResponseValue = wasm.TS_OnionMessage_write(obj);
26187 return nativeResponseValue;
26189 // struct LDKCVec_u8Z Ping_write(const struct LDKPing *NONNULL_PTR obj);
26191 export function Ping_write(obj: bigint): number {
26192 if(!isWasmInitialized) {
26193 throw new Error("initializeWasm() must be awaited first!");
26195 const nativeResponseValue = wasm.TS_Ping_write(obj);
26196 return nativeResponseValue;
26198 // struct LDKCResult_PingDecodeErrorZ Ping_read(struct LDKu8slice ser);
26200 export function Ping_read(ser: number): bigint {
26201 if(!isWasmInitialized) {
26202 throw new Error("initializeWasm() must be awaited first!");
26204 const nativeResponseValue = wasm.TS_Ping_read(ser);
26205 return nativeResponseValue;
26207 // struct LDKCVec_u8Z Pong_write(const struct LDKPong *NONNULL_PTR obj);
26209 export function Pong_write(obj: bigint): number {
26210 if(!isWasmInitialized) {
26211 throw new Error("initializeWasm() must be awaited first!");
26213 const nativeResponseValue = wasm.TS_Pong_write(obj);
26214 return nativeResponseValue;
26216 // struct LDKCResult_PongDecodeErrorZ Pong_read(struct LDKu8slice ser);
26218 export function Pong_read(ser: number): bigint {
26219 if(!isWasmInitialized) {
26220 throw new Error("initializeWasm() must be awaited first!");
26222 const nativeResponseValue = wasm.TS_Pong_read(ser);
26223 return nativeResponseValue;
26225 // struct LDKCVec_u8Z UnsignedChannelAnnouncement_write(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR obj);
26227 export function UnsignedChannelAnnouncement_write(obj: bigint): number {
26228 if(!isWasmInitialized) {
26229 throw new Error("initializeWasm() must be awaited first!");
26231 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_write(obj);
26232 return nativeResponseValue;
26234 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ UnsignedChannelAnnouncement_read(struct LDKu8slice ser);
26236 export function UnsignedChannelAnnouncement_read(ser: number): bigint {
26237 if(!isWasmInitialized) {
26238 throw new Error("initializeWasm() must be awaited first!");
26240 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_read(ser);
26241 return nativeResponseValue;
26243 // struct LDKCVec_u8Z ChannelAnnouncement_write(const struct LDKChannelAnnouncement *NONNULL_PTR obj);
26245 export function ChannelAnnouncement_write(obj: bigint): number {
26246 if(!isWasmInitialized) {
26247 throw new Error("initializeWasm() must be awaited first!");
26249 const nativeResponseValue = wasm.TS_ChannelAnnouncement_write(obj);
26250 return nativeResponseValue;
26252 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ ChannelAnnouncement_read(struct LDKu8slice ser);
26254 export function ChannelAnnouncement_read(ser: number): bigint {
26255 if(!isWasmInitialized) {
26256 throw new Error("initializeWasm() must be awaited first!");
26258 const nativeResponseValue = wasm.TS_ChannelAnnouncement_read(ser);
26259 return nativeResponseValue;
26261 // struct LDKCVec_u8Z UnsignedChannelUpdate_write(const struct LDKUnsignedChannelUpdate *NONNULL_PTR obj);
26263 export function UnsignedChannelUpdate_write(obj: bigint): number {
26264 if(!isWasmInitialized) {
26265 throw new Error("initializeWasm() must be awaited first!");
26267 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_write(obj);
26268 return nativeResponseValue;
26270 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ UnsignedChannelUpdate_read(struct LDKu8slice ser);
26272 export function UnsignedChannelUpdate_read(ser: number): bigint {
26273 if(!isWasmInitialized) {
26274 throw new Error("initializeWasm() must be awaited first!");
26276 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_read(ser);
26277 return nativeResponseValue;
26279 // struct LDKCVec_u8Z ChannelUpdate_write(const struct LDKChannelUpdate *NONNULL_PTR obj);
26281 export function ChannelUpdate_write(obj: bigint): number {
26282 if(!isWasmInitialized) {
26283 throw new Error("initializeWasm() must be awaited first!");
26285 const nativeResponseValue = wasm.TS_ChannelUpdate_write(obj);
26286 return nativeResponseValue;
26288 // struct LDKCResult_ChannelUpdateDecodeErrorZ ChannelUpdate_read(struct LDKu8slice ser);
26290 export function ChannelUpdate_read(ser: number): bigint {
26291 if(!isWasmInitialized) {
26292 throw new Error("initializeWasm() must be awaited first!");
26294 const nativeResponseValue = wasm.TS_ChannelUpdate_read(ser);
26295 return nativeResponseValue;
26297 // struct LDKCVec_u8Z ErrorMessage_write(const struct LDKErrorMessage *NONNULL_PTR obj);
26299 export function ErrorMessage_write(obj: bigint): number {
26300 if(!isWasmInitialized) {
26301 throw new Error("initializeWasm() must be awaited first!");
26303 const nativeResponseValue = wasm.TS_ErrorMessage_write(obj);
26304 return nativeResponseValue;
26306 // struct LDKCResult_ErrorMessageDecodeErrorZ ErrorMessage_read(struct LDKu8slice ser);
26308 export function ErrorMessage_read(ser: number): bigint {
26309 if(!isWasmInitialized) {
26310 throw new Error("initializeWasm() must be awaited first!");
26312 const nativeResponseValue = wasm.TS_ErrorMessage_read(ser);
26313 return nativeResponseValue;
26315 // struct LDKCVec_u8Z WarningMessage_write(const struct LDKWarningMessage *NONNULL_PTR obj);
26317 export function WarningMessage_write(obj: bigint): number {
26318 if(!isWasmInitialized) {
26319 throw new Error("initializeWasm() must be awaited first!");
26321 const nativeResponseValue = wasm.TS_WarningMessage_write(obj);
26322 return nativeResponseValue;
26324 // struct LDKCResult_WarningMessageDecodeErrorZ WarningMessage_read(struct LDKu8slice ser);
26326 export function WarningMessage_read(ser: number): bigint {
26327 if(!isWasmInitialized) {
26328 throw new Error("initializeWasm() must be awaited first!");
26330 const nativeResponseValue = wasm.TS_WarningMessage_read(ser);
26331 return nativeResponseValue;
26333 // struct LDKCVec_u8Z UnsignedNodeAnnouncement_write(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR obj);
26335 export function UnsignedNodeAnnouncement_write(obj: bigint): number {
26336 if(!isWasmInitialized) {
26337 throw new Error("initializeWasm() must be awaited first!");
26339 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_write(obj);
26340 return nativeResponseValue;
26342 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ UnsignedNodeAnnouncement_read(struct LDKu8slice ser);
26344 export function UnsignedNodeAnnouncement_read(ser: number): bigint {
26345 if(!isWasmInitialized) {
26346 throw new Error("initializeWasm() must be awaited first!");
26348 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_read(ser);
26349 return nativeResponseValue;
26351 // struct LDKCVec_u8Z NodeAnnouncement_write(const struct LDKNodeAnnouncement *NONNULL_PTR obj);
26353 export function NodeAnnouncement_write(obj: bigint): number {
26354 if(!isWasmInitialized) {
26355 throw new Error("initializeWasm() must be awaited first!");
26357 const nativeResponseValue = wasm.TS_NodeAnnouncement_write(obj);
26358 return nativeResponseValue;
26360 // struct LDKCResult_NodeAnnouncementDecodeErrorZ NodeAnnouncement_read(struct LDKu8slice ser);
26362 export function NodeAnnouncement_read(ser: number): bigint {
26363 if(!isWasmInitialized) {
26364 throw new Error("initializeWasm() must be awaited first!");
26366 const nativeResponseValue = wasm.TS_NodeAnnouncement_read(ser);
26367 return nativeResponseValue;
26369 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ QueryShortChannelIds_read(struct LDKu8slice ser);
26371 export function QueryShortChannelIds_read(ser: number): bigint {
26372 if(!isWasmInitialized) {
26373 throw new Error("initializeWasm() must be awaited first!");
26375 const nativeResponseValue = wasm.TS_QueryShortChannelIds_read(ser);
26376 return nativeResponseValue;
26378 // struct LDKCVec_u8Z QueryShortChannelIds_write(const struct LDKQueryShortChannelIds *NONNULL_PTR obj);
26380 export function QueryShortChannelIds_write(obj: bigint): number {
26381 if(!isWasmInitialized) {
26382 throw new Error("initializeWasm() must be awaited first!");
26384 const nativeResponseValue = wasm.TS_QueryShortChannelIds_write(obj);
26385 return nativeResponseValue;
26387 // struct LDKCVec_u8Z ReplyShortChannelIdsEnd_write(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR obj);
26389 export function ReplyShortChannelIdsEnd_write(obj: bigint): number {
26390 if(!isWasmInitialized) {
26391 throw new Error("initializeWasm() must be awaited first!");
26393 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_write(obj);
26394 return nativeResponseValue;
26396 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ ReplyShortChannelIdsEnd_read(struct LDKu8slice ser);
26398 export function ReplyShortChannelIdsEnd_read(ser: number): bigint {
26399 if(!isWasmInitialized) {
26400 throw new Error("initializeWasm() must be awaited first!");
26402 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_read(ser);
26403 return nativeResponseValue;
26405 // MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
26407 export function QueryChannelRange_end_blocknum(this_arg: bigint): number {
26408 if(!isWasmInitialized) {
26409 throw new Error("initializeWasm() must be awaited first!");
26411 const nativeResponseValue = wasm.TS_QueryChannelRange_end_blocknum(this_arg);
26412 return nativeResponseValue;
26414 // struct LDKCVec_u8Z QueryChannelRange_write(const struct LDKQueryChannelRange *NONNULL_PTR obj);
26416 export function QueryChannelRange_write(obj: bigint): number {
26417 if(!isWasmInitialized) {
26418 throw new Error("initializeWasm() must be awaited first!");
26420 const nativeResponseValue = wasm.TS_QueryChannelRange_write(obj);
26421 return nativeResponseValue;
26423 // struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
26425 export function QueryChannelRange_read(ser: number): bigint {
26426 if(!isWasmInitialized) {
26427 throw new Error("initializeWasm() must be awaited first!");
26429 const nativeResponseValue = wasm.TS_QueryChannelRange_read(ser);
26430 return nativeResponseValue;
26432 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ ReplyChannelRange_read(struct LDKu8slice ser);
26434 export function ReplyChannelRange_read(ser: number): bigint {
26435 if(!isWasmInitialized) {
26436 throw new Error("initializeWasm() must be awaited first!");
26438 const nativeResponseValue = wasm.TS_ReplyChannelRange_read(ser);
26439 return nativeResponseValue;
26441 // struct LDKCVec_u8Z ReplyChannelRange_write(const struct LDKReplyChannelRange *NONNULL_PTR obj);
26443 export function ReplyChannelRange_write(obj: bigint): number {
26444 if(!isWasmInitialized) {
26445 throw new Error("initializeWasm() must be awaited first!");
26447 const nativeResponseValue = wasm.TS_ReplyChannelRange_write(obj);
26448 return nativeResponseValue;
26450 // struct LDKCVec_u8Z GossipTimestampFilter_write(const struct LDKGossipTimestampFilter *NONNULL_PTR obj);
26452 export function GossipTimestampFilter_write(obj: bigint): number {
26453 if(!isWasmInitialized) {
26454 throw new Error("initializeWasm() must be awaited first!");
26456 const nativeResponseValue = wasm.TS_GossipTimestampFilter_write(obj);
26457 return nativeResponseValue;
26459 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ GossipTimestampFilter_read(struct LDKu8slice ser);
26461 export function GossipTimestampFilter_read(ser: number): bigint {
26462 if(!isWasmInitialized) {
26463 throw new Error("initializeWasm() must be awaited first!");
26465 const nativeResponseValue = wasm.TS_GossipTimestampFilter_read(ser);
26466 return nativeResponseValue;
26468 // void CustomMessageHandler_free(struct LDKCustomMessageHandler this_ptr);
26470 export function CustomMessageHandler_free(this_ptr: bigint): void {
26471 if(!isWasmInitialized) {
26472 throw new Error("initializeWasm() must be awaited first!");
26474 const nativeResponseValue = wasm.TS_CustomMessageHandler_free(this_ptr);
26475 // debug statements here
26477 // void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_obj);
26479 export function IgnoringMessageHandler_free(this_obj: bigint): void {
26480 if(!isWasmInitialized) {
26481 throw new Error("initializeWasm() must be awaited first!");
26483 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_free(this_obj);
26484 // debug statements here
26486 // MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void);
26488 export function IgnoringMessageHandler_new(): bigint {
26489 if(!isWasmInitialized) {
26490 throw new Error("initializeWasm() must be awaited first!");
26492 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_new();
26493 return nativeResponseValue;
26495 // struct LDKMessageSendEventsProvider IgnoringMessageHandler_as_MessageSendEventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
26497 export function IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg: bigint): bigint {
26498 if(!isWasmInitialized) {
26499 throw new Error("initializeWasm() must be awaited first!");
26501 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg);
26502 return nativeResponseValue;
26504 // struct LDKRoutingMessageHandler IgnoringMessageHandler_as_RoutingMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
26506 export function IgnoringMessageHandler_as_RoutingMessageHandler(this_arg: bigint): bigint {
26507 if(!isWasmInitialized) {
26508 throw new Error("initializeWasm() must be awaited first!");
26510 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_RoutingMessageHandler(this_arg);
26511 return nativeResponseValue;
26513 // struct LDKOnionMessageProvider IgnoringMessageHandler_as_OnionMessageProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
26515 export function IgnoringMessageHandler_as_OnionMessageProvider(this_arg: bigint): bigint {
26516 if(!isWasmInitialized) {
26517 throw new Error("initializeWasm() must be awaited first!");
26519 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_OnionMessageProvider(this_arg);
26520 return nativeResponseValue;
26522 // struct LDKOnionMessageHandler IgnoringMessageHandler_as_OnionMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
26524 export function IgnoringMessageHandler_as_OnionMessageHandler(this_arg: bigint): bigint {
26525 if(!isWasmInitialized) {
26526 throw new Error("initializeWasm() must be awaited first!");
26528 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_OnionMessageHandler(this_arg);
26529 return nativeResponseValue;
26531 // struct LDKCustomMessageReader IgnoringMessageHandler_as_CustomMessageReader(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
26533 export function IgnoringMessageHandler_as_CustomMessageReader(this_arg: bigint): bigint {
26534 if(!isWasmInitialized) {
26535 throw new Error("initializeWasm() must be awaited first!");
26537 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageReader(this_arg);
26538 return nativeResponseValue;
26540 // struct LDKCustomMessageHandler IgnoringMessageHandler_as_CustomMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
26542 export function IgnoringMessageHandler_as_CustomMessageHandler(this_arg: bigint): bigint {
26543 if(!isWasmInitialized) {
26544 throw new Error("initializeWasm() must be awaited first!");
26546 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageHandler(this_arg);
26547 return nativeResponseValue;
26549 // void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_obj);
26551 export function ErroringMessageHandler_free(this_obj: bigint): void {
26552 if(!isWasmInitialized) {
26553 throw new Error("initializeWasm() must be awaited first!");
26555 const nativeResponseValue = wasm.TS_ErroringMessageHandler_free(this_obj);
26556 // debug statements here
26558 // MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void);
26560 export function ErroringMessageHandler_new(): bigint {
26561 if(!isWasmInitialized) {
26562 throw new Error("initializeWasm() must be awaited first!");
26564 const nativeResponseValue = wasm.TS_ErroringMessageHandler_new();
26565 return nativeResponseValue;
26567 // struct LDKMessageSendEventsProvider ErroringMessageHandler_as_MessageSendEventsProvider(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
26569 export function ErroringMessageHandler_as_MessageSendEventsProvider(this_arg: bigint): bigint {
26570 if(!isWasmInitialized) {
26571 throw new Error("initializeWasm() must be awaited first!");
26573 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_MessageSendEventsProvider(this_arg);
26574 return nativeResponseValue;
26576 // struct LDKChannelMessageHandler ErroringMessageHandler_as_ChannelMessageHandler(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
26578 export function ErroringMessageHandler_as_ChannelMessageHandler(this_arg: bigint): bigint {
26579 if(!isWasmInitialized) {
26580 throw new Error("initializeWasm() must be awaited first!");
26582 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_ChannelMessageHandler(this_arg);
26583 return nativeResponseValue;
26585 // void MessageHandler_free(struct LDKMessageHandler this_obj);
26587 export function MessageHandler_free(this_obj: bigint): void {
26588 if(!isWasmInitialized) {
26589 throw new Error("initializeWasm() must be awaited first!");
26591 const nativeResponseValue = wasm.TS_MessageHandler_free(this_obj);
26592 // debug statements here
26594 // const struct LDKChannelMessageHandler *MessageHandler_get_chan_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
26596 export function MessageHandler_get_chan_handler(this_ptr: bigint): bigint {
26597 if(!isWasmInitialized) {
26598 throw new Error("initializeWasm() must be awaited first!");
26600 const nativeResponseValue = wasm.TS_MessageHandler_get_chan_handler(this_ptr);
26601 return nativeResponseValue;
26603 // void MessageHandler_set_chan_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKChannelMessageHandler val);
26605 export function MessageHandler_set_chan_handler(this_ptr: bigint, val: bigint): void {
26606 if(!isWasmInitialized) {
26607 throw new Error("initializeWasm() must be awaited first!");
26609 const nativeResponseValue = wasm.TS_MessageHandler_set_chan_handler(this_ptr, val);
26610 // debug statements here
26612 // const struct LDKRoutingMessageHandler *MessageHandler_get_route_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
26614 export function MessageHandler_get_route_handler(this_ptr: bigint): bigint {
26615 if(!isWasmInitialized) {
26616 throw new Error("initializeWasm() must be awaited first!");
26618 const nativeResponseValue = wasm.TS_MessageHandler_get_route_handler(this_ptr);
26619 return nativeResponseValue;
26621 // void MessageHandler_set_route_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKRoutingMessageHandler val);
26623 export function MessageHandler_set_route_handler(this_ptr: bigint, val: bigint): void {
26624 if(!isWasmInitialized) {
26625 throw new Error("initializeWasm() must be awaited first!");
26627 const nativeResponseValue = wasm.TS_MessageHandler_set_route_handler(this_ptr, val);
26628 // debug statements here
26630 // const struct LDKOnionMessageHandler *MessageHandler_get_onion_message_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
26632 export function MessageHandler_get_onion_message_handler(this_ptr: bigint): bigint {
26633 if(!isWasmInitialized) {
26634 throw new Error("initializeWasm() must be awaited first!");
26636 const nativeResponseValue = wasm.TS_MessageHandler_get_onion_message_handler(this_ptr);
26637 return nativeResponseValue;
26639 // void MessageHandler_set_onion_message_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKOnionMessageHandler val);
26641 export function MessageHandler_set_onion_message_handler(this_ptr: bigint, val: bigint): void {
26642 if(!isWasmInitialized) {
26643 throw new Error("initializeWasm() must be awaited first!");
26645 const nativeResponseValue = wasm.TS_MessageHandler_set_onion_message_handler(this_ptr, val);
26646 // debug statements here
26648 // MUST_USE_RES struct LDKMessageHandler MessageHandler_new(struct LDKChannelMessageHandler chan_handler_arg, struct LDKRoutingMessageHandler route_handler_arg, struct LDKOnionMessageHandler onion_message_handler_arg);
26650 export function MessageHandler_new(chan_handler_arg: bigint, route_handler_arg: bigint, onion_message_handler_arg: bigint): bigint {
26651 if(!isWasmInitialized) {
26652 throw new Error("initializeWasm() must be awaited first!");
26654 const nativeResponseValue = wasm.TS_MessageHandler_new(chan_handler_arg, route_handler_arg, onion_message_handler_arg);
26655 return nativeResponseValue;
26657 // uint64_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg);
26659 export function SocketDescriptor_clone_ptr(arg: bigint): bigint {
26660 if(!isWasmInitialized) {
26661 throw new Error("initializeWasm() must be awaited first!");
26663 const nativeResponseValue = wasm.TS_SocketDescriptor_clone_ptr(arg);
26664 return nativeResponseValue;
26666 // struct LDKSocketDescriptor SocketDescriptor_clone(const struct LDKSocketDescriptor *NONNULL_PTR orig);
26668 export function SocketDescriptor_clone(orig: bigint): bigint {
26669 if(!isWasmInitialized) {
26670 throw new Error("initializeWasm() must be awaited first!");
26672 const nativeResponseValue = wasm.TS_SocketDescriptor_clone(orig);
26673 return nativeResponseValue;
26675 // void SocketDescriptor_free(struct LDKSocketDescriptor this_ptr);
26677 export function SocketDescriptor_free(this_ptr: bigint): void {
26678 if(!isWasmInitialized) {
26679 throw new Error("initializeWasm() must be awaited first!");
26681 const nativeResponseValue = wasm.TS_SocketDescriptor_free(this_ptr);
26682 // debug statements here
26684 // void PeerHandleError_free(struct LDKPeerHandleError this_obj);
26686 export function PeerHandleError_free(this_obj: bigint): void {
26687 if(!isWasmInitialized) {
26688 throw new Error("initializeWasm() must be awaited first!");
26690 const nativeResponseValue = wasm.TS_PeerHandleError_free(this_obj);
26691 // debug statements here
26693 // bool PeerHandleError_get_no_connection_possible(const struct LDKPeerHandleError *NONNULL_PTR this_ptr);
26695 export function PeerHandleError_get_no_connection_possible(this_ptr: bigint): boolean {
26696 if(!isWasmInitialized) {
26697 throw new Error("initializeWasm() must be awaited first!");
26699 const nativeResponseValue = wasm.TS_PeerHandleError_get_no_connection_possible(this_ptr);
26700 return nativeResponseValue;
26702 // void PeerHandleError_set_no_connection_possible(struct LDKPeerHandleError *NONNULL_PTR this_ptr, bool val);
26704 export function PeerHandleError_set_no_connection_possible(this_ptr: bigint, val: boolean): void {
26705 if(!isWasmInitialized) {
26706 throw new Error("initializeWasm() must be awaited first!");
26708 const nativeResponseValue = wasm.TS_PeerHandleError_set_no_connection_possible(this_ptr, val);
26709 // debug statements here
26711 // MUST_USE_RES struct LDKPeerHandleError PeerHandleError_new(bool no_connection_possible_arg);
26713 export function PeerHandleError_new(no_connection_possible_arg: boolean): bigint {
26714 if(!isWasmInitialized) {
26715 throw new Error("initializeWasm() must be awaited first!");
26717 const nativeResponseValue = wasm.TS_PeerHandleError_new(no_connection_possible_arg);
26718 return nativeResponseValue;
26720 // uint64_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg);
26722 export function PeerHandleError_clone_ptr(arg: bigint): bigint {
26723 if(!isWasmInitialized) {
26724 throw new Error("initializeWasm() must be awaited first!");
26726 const nativeResponseValue = wasm.TS_PeerHandleError_clone_ptr(arg);
26727 return nativeResponseValue;
26729 // struct LDKPeerHandleError PeerHandleError_clone(const struct LDKPeerHandleError *NONNULL_PTR orig);
26731 export function PeerHandleError_clone(orig: bigint): bigint {
26732 if(!isWasmInitialized) {
26733 throw new Error("initializeWasm() must be awaited first!");
26735 const nativeResponseValue = wasm.TS_PeerHandleError_clone(orig);
26736 return nativeResponseValue;
26738 // void PeerManager_free(struct LDKPeerManager this_obj);
26740 export function PeerManager_free(this_obj: bigint): void {
26741 if(!isWasmInitialized) {
26742 throw new Error("initializeWasm() must be awaited first!");
26744 const nativeResponseValue = wasm.TS_PeerManager_free(this_obj);
26745 // debug statements here
26747 // MUST_USE_RES struct LDKPeerManager PeerManager_new(struct LDKMessageHandler message_handler, struct LDKSecretKey our_node_secret, uint64_t current_time, const uint8_t (*ephemeral_random_data)[32], struct LDKLogger logger, struct LDKCustomMessageHandler custom_message_handler);
26749 export function PeerManager_new(message_handler: bigint, our_node_secret: number, current_time: bigint, ephemeral_random_data: number, logger: bigint, custom_message_handler: bigint): bigint {
26750 if(!isWasmInitialized) {
26751 throw new Error("initializeWasm() must be awaited first!");
26753 const nativeResponseValue = wasm.TS_PeerManager_new(message_handler, our_node_secret, current_time, ephemeral_random_data, logger, custom_message_handler);
26754 return nativeResponseValue;
26756 // MUST_USE_RES struct LDKCVec_PublicKeyZ PeerManager_get_peer_node_ids(const struct LDKPeerManager *NONNULL_PTR this_arg);
26758 export function PeerManager_get_peer_node_ids(this_arg: bigint): number {
26759 if(!isWasmInitialized) {
26760 throw new Error("initializeWasm() must be awaited first!");
26762 const nativeResponseValue = wasm.TS_PeerManager_get_peer_node_ids(this_arg);
26763 return nativeResponseValue;
26765 // MUST_USE_RES struct LDKCResult_CVec_u8ZPeerHandleErrorZ PeerManager_new_outbound_connection(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKSocketDescriptor descriptor, struct LDKCOption_NetAddressZ remote_network_address);
26767 export function PeerManager_new_outbound_connection(this_arg: bigint, their_node_id: number, descriptor: bigint, remote_network_address: bigint): bigint {
26768 if(!isWasmInitialized) {
26769 throw new Error("initializeWasm() must be awaited first!");
26771 const nativeResponseValue = wasm.TS_PeerManager_new_outbound_connection(this_arg, their_node_id, descriptor, remote_network_address);
26772 return nativeResponseValue;
26774 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_new_inbound_connection(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor descriptor, struct LDKCOption_NetAddressZ remote_network_address);
26776 export function PeerManager_new_inbound_connection(this_arg: bigint, descriptor: bigint, remote_network_address: bigint): bigint {
26777 if(!isWasmInitialized) {
26778 throw new Error("initializeWasm() must be awaited first!");
26780 const nativeResponseValue = wasm.TS_PeerManager_new_inbound_connection(this_arg, descriptor, remote_network_address);
26781 return nativeResponseValue;
26783 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_write_buffer_space_avail(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor *NONNULL_PTR descriptor);
26785 export function PeerManager_write_buffer_space_avail(this_arg: bigint, descriptor: bigint): bigint {
26786 if(!isWasmInitialized) {
26787 throw new Error("initializeWasm() must be awaited first!");
26789 const nativeResponseValue = wasm.TS_PeerManager_write_buffer_space_avail(this_arg, descriptor);
26790 return nativeResponseValue;
26792 // 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);
26794 export function PeerManager_read_event(this_arg: bigint, peer_descriptor: bigint, data: number): bigint {
26795 if(!isWasmInitialized) {
26796 throw new Error("initializeWasm() must be awaited first!");
26798 const nativeResponseValue = wasm.TS_PeerManager_read_event(this_arg, peer_descriptor, data);
26799 return nativeResponseValue;
26801 // void PeerManager_process_events(const struct LDKPeerManager *NONNULL_PTR this_arg);
26803 export function PeerManager_process_events(this_arg: bigint): void {
26804 if(!isWasmInitialized) {
26805 throw new Error("initializeWasm() must be awaited first!");
26807 const nativeResponseValue = wasm.TS_PeerManager_process_events(this_arg);
26808 // debug statements here
26810 // void PeerManager_socket_disconnected(const struct LDKPeerManager *NONNULL_PTR this_arg, const struct LDKSocketDescriptor *NONNULL_PTR descriptor);
26812 export function PeerManager_socket_disconnected(this_arg: bigint, descriptor: bigint): void {
26813 if(!isWasmInitialized) {
26814 throw new Error("initializeWasm() must be awaited first!");
26816 const nativeResponseValue = wasm.TS_PeerManager_socket_disconnected(this_arg, descriptor);
26817 // debug statements here
26819 // void PeerManager_disconnect_by_node_id(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id, bool no_connection_possible);
26821 export function PeerManager_disconnect_by_node_id(this_arg: bigint, node_id: number, no_connection_possible: boolean): void {
26822 if(!isWasmInitialized) {
26823 throw new Error("initializeWasm() must be awaited first!");
26825 const nativeResponseValue = wasm.TS_PeerManager_disconnect_by_node_id(this_arg, node_id, no_connection_possible);
26826 // debug statements here
26828 // void PeerManager_disconnect_all_peers(const struct LDKPeerManager *NONNULL_PTR this_arg);
26830 export function PeerManager_disconnect_all_peers(this_arg: bigint): void {
26831 if(!isWasmInitialized) {
26832 throw new Error("initializeWasm() must be awaited first!");
26834 const nativeResponseValue = wasm.TS_PeerManager_disconnect_all_peers(this_arg);
26835 // debug statements here
26837 // void PeerManager_timer_tick_occurred(const struct LDKPeerManager *NONNULL_PTR this_arg);
26839 export function PeerManager_timer_tick_occurred(this_arg: bigint): void {
26840 if(!isWasmInitialized) {
26841 throw new Error("initializeWasm() must be awaited first!");
26843 const nativeResponseValue = wasm.TS_PeerManager_timer_tick_occurred(this_arg);
26844 // debug statements here
26846 // void PeerManager_broadcast_node_announcement(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKThreeBytes rgb, struct LDKThirtyTwoBytes alias, struct LDKCVec_NetAddressZ addresses);
26848 export function PeerManager_broadcast_node_announcement(this_arg: bigint, rgb: number, alias: number, addresses: number): void {
26849 if(!isWasmInitialized) {
26850 throw new Error("initializeWasm() must be awaited first!");
26852 const nativeResponseValue = wasm.TS_PeerManager_broadcast_node_announcement(this_arg, rgb, alias, addresses);
26853 // debug statements here
26855 // uint64_t htlc_success_tx_weight(bool opt_anchors);
26857 export function htlc_success_tx_weight(opt_anchors: boolean): bigint {
26858 if(!isWasmInitialized) {
26859 throw new Error("initializeWasm() must be awaited first!");
26861 const nativeResponseValue = wasm.TS_htlc_success_tx_weight(opt_anchors);
26862 return nativeResponseValue;
26864 // uint64_t htlc_timeout_tx_weight(bool opt_anchors);
26866 export function htlc_timeout_tx_weight(opt_anchors: boolean): bigint {
26867 if(!isWasmInitialized) {
26868 throw new Error("initializeWasm() must be awaited first!");
26870 const nativeResponseValue = wasm.TS_htlc_timeout_tx_weight(opt_anchors);
26871 return nativeResponseValue;
26873 // struct LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx);
26875 export function build_commitment_secret(commitment_seed: number, idx: bigint): number {
26876 if(!isWasmInitialized) {
26877 throw new Error("initializeWasm() must be awaited first!");
26879 const nativeResponseValue = wasm.TS_build_commitment_secret(commitment_seed, idx);
26880 return nativeResponseValue;
26882 // 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);
26884 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: bigint): number {
26885 if(!isWasmInitialized) {
26886 throw new Error("initializeWasm() must be awaited first!");
26888 const nativeResponseValue = wasm.TS_build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
26889 return nativeResponseValue;
26891 // void CounterpartyCommitmentSecrets_free(struct LDKCounterpartyCommitmentSecrets this_obj);
26893 export function CounterpartyCommitmentSecrets_free(this_obj: bigint): void {
26894 if(!isWasmInitialized) {
26895 throw new Error("initializeWasm() must be awaited first!");
26897 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_free(this_obj);
26898 // debug statements here
26900 // uint64_t CounterpartyCommitmentSecrets_clone_ptr(LDKCounterpartyCommitmentSecrets *NONNULL_PTR arg);
26902 export function CounterpartyCommitmentSecrets_clone_ptr(arg: bigint): bigint {
26903 if(!isWasmInitialized) {
26904 throw new Error("initializeWasm() must be awaited first!");
26906 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone_ptr(arg);
26907 return nativeResponseValue;
26909 // struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_clone(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR orig);
26911 export function CounterpartyCommitmentSecrets_clone(orig: bigint): bigint {
26912 if(!isWasmInitialized) {
26913 throw new Error("initializeWasm() must be awaited first!");
26915 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone(orig);
26916 return nativeResponseValue;
26918 // MUST_USE_RES struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_new(void);
26920 export function CounterpartyCommitmentSecrets_new(): bigint {
26921 if(!isWasmInitialized) {
26922 throw new Error("initializeWasm() must be awaited first!");
26924 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_new();
26925 return nativeResponseValue;
26927 // MUST_USE_RES uint64_t CounterpartyCommitmentSecrets_get_min_seen_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg);
26929 export function CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg: bigint): bigint {
26930 if(!isWasmInitialized) {
26931 throw new Error("initializeWasm() must be awaited first!");
26933 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg);
26934 return nativeResponseValue;
26936 // MUST_USE_RES struct LDKCResult_NoneNoneZ CounterpartyCommitmentSecrets_provide_secret(struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx, struct LDKThirtyTwoBytes secret);
26938 export function CounterpartyCommitmentSecrets_provide_secret(this_arg: bigint, idx: bigint, secret: number): bigint {
26939 if(!isWasmInitialized) {
26940 throw new Error("initializeWasm() must be awaited first!");
26942 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_provide_secret(this_arg, idx, secret);
26943 return nativeResponseValue;
26945 // MUST_USE_RES struct LDKThirtyTwoBytes CounterpartyCommitmentSecrets_get_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx);
26947 export function CounterpartyCommitmentSecrets_get_secret(this_arg: bigint, idx: bigint): number {
26948 if(!isWasmInitialized) {
26949 throw new Error("initializeWasm() must be awaited first!");
26951 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_secret(this_arg, idx);
26952 return nativeResponseValue;
26954 // struct LDKCVec_u8Z CounterpartyCommitmentSecrets_write(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR obj);
26956 export function CounterpartyCommitmentSecrets_write(obj: bigint): number {
26957 if(!isWasmInitialized) {
26958 throw new Error("initializeWasm() must be awaited first!");
26960 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_write(obj);
26961 return nativeResponseValue;
26963 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CounterpartyCommitmentSecrets_read(struct LDKu8slice ser);
26965 export function CounterpartyCommitmentSecrets_read(ser: number): bigint {
26966 if(!isWasmInitialized) {
26967 throw new Error("initializeWasm() must be awaited first!");
26969 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_read(ser);
26970 return nativeResponseValue;
26972 // struct LDKCResult_SecretKeyErrorZ derive_private_key(struct LDKPublicKey per_commitment_point, const uint8_t (*base_secret)[32]);
26974 export function derive_private_key(per_commitment_point: number, base_secret: number): bigint {
26975 if(!isWasmInitialized) {
26976 throw new Error("initializeWasm() must be awaited first!");
26978 const nativeResponseValue = wasm.TS_derive_private_key(per_commitment_point, base_secret);
26979 return nativeResponseValue;
26981 // struct LDKCResult_PublicKeyErrorZ derive_public_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey base_point);
26983 export function derive_public_key(per_commitment_point: number, base_point: number): bigint {
26984 if(!isWasmInitialized) {
26985 throw new Error("initializeWasm() must be awaited first!");
26987 const nativeResponseValue = wasm.TS_derive_public_key(per_commitment_point, base_point);
26988 return nativeResponseValue;
26990 // struct LDKCResult_SecretKeyErrorZ derive_private_revocation_key(const uint8_t (*per_commitment_secret)[32], const uint8_t (*countersignatory_revocation_base_secret)[32]);
26992 export function derive_private_revocation_key(per_commitment_secret: number, countersignatory_revocation_base_secret: number): bigint {
26993 if(!isWasmInitialized) {
26994 throw new Error("initializeWasm() must be awaited first!");
26996 const nativeResponseValue = wasm.TS_derive_private_revocation_key(per_commitment_secret, countersignatory_revocation_base_secret);
26997 return nativeResponseValue;
26999 // struct LDKCResult_PublicKeyErrorZ derive_public_revocation_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey countersignatory_revocation_base_point);
27001 export function derive_public_revocation_key(per_commitment_point: number, countersignatory_revocation_base_point: number): bigint {
27002 if(!isWasmInitialized) {
27003 throw new Error("initializeWasm() must be awaited first!");
27005 const nativeResponseValue = wasm.TS_derive_public_revocation_key(per_commitment_point, countersignatory_revocation_base_point);
27006 return nativeResponseValue;
27008 // void TxCreationKeys_free(struct LDKTxCreationKeys this_obj);
27010 export function TxCreationKeys_free(this_obj: bigint): void {
27011 if(!isWasmInitialized) {
27012 throw new Error("initializeWasm() must be awaited first!");
27014 const nativeResponseValue = wasm.TS_TxCreationKeys_free(this_obj);
27015 // debug statements here
27017 // struct LDKPublicKey TxCreationKeys_get_per_commitment_point(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
27019 export function TxCreationKeys_get_per_commitment_point(this_ptr: bigint): number {
27020 if(!isWasmInitialized) {
27021 throw new Error("initializeWasm() must be awaited first!");
27023 const nativeResponseValue = wasm.TS_TxCreationKeys_get_per_commitment_point(this_ptr);
27024 return nativeResponseValue;
27026 // void TxCreationKeys_set_per_commitment_point(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
27028 export function TxCreationKeys_set_per_commitment_point(this_ptr: bigint, val: number): void {
27029 if(!isWasmInitialized) {
27030 throw new Error("initializeWasm() must be awaited first!");
27032 const nativeResponseValue = wasm.TS_TxCreationKeys_set_per_commitment_point(this_ptr, val);
27033 // debug statements here
27035 // struct LDKPublicKey TxCreationKeys_get_revocation_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
27037 export function TxCreationKeys_get_revocation_key(this_ptr: bigint): number {
27038 if(!isWasmInitialized) {
27039 throw new Error("initializeWasm() must be awaited first!");
27041 const nativeResponseValue = wasm.TS_TxCreationKeys_get_revocation_key(this_ptr);
27042 return nativeResponseValue;
27044 // void TxCreationKeys_set_revocation_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
27046 export function TxCreationKeys_set_revocation_key(this_ptr: bigint, val: number): void {
27047 if(!isWasmInitialized) {
27048 throw new Error("initializeWasm() must be awaited first!");
27050 const nativeResponseValue = wasm.TS_TxCreationKeys_set_revocation_key(this_ptr, val);
27051 // debug statements here
27053 // struct LDKPublicKey TxCreationKeys_get_broadcaster_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
27055 export function TxCreationKeys_get_broadcaster_htlc_key(this_ptr: bigint): number {
27056 if(!isWasmInitialized) {
27057 throw new Error("initializeWasm() must be awaited first!");
27059 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_htlc_key(this_ptr);
27060 return nativeResponseValue;
27062 // void TxCreationKeys_set_broadcaster_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
27064 export function TxCreationKeys_set_broadcaster_htlc_key(this_ptr: bigint, val: number): void {
27065 if(!isWasmInitialized) {
27066 throw new Error("initializeWasm() must be awaited first!");
27068 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_htlc_key(this_ptr, val);
27069 // debug statements here
27071 // struct LDKPublicKey TxCreationKeys_get_countersignatory_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
27073 export function TxCreationKeys_get_countersignatory_htlc_key(this_ptr: bigint): number {
27074 if(!isWasmInitialized) {
27075 throw new Error("initializeWasm() must be awaited first!");
27077 const nativeResponseValue = wasm.TS_TxCreationKeys_get_countersignatory_htlc_key(this_ptr);
27078 return nativeResponseValue;
27080 // void TxCreationKeys_set_countersignatory_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
27082 export function TxCreationKeys_set_countersignatory_htlc_key(this_ptr: bigint, val: number): void {
27083 if(!isWasmInitialized) {
27084 throw new Error("initializeWasm() must be awaited first!");
27086 const nativeResponseValue = wasm.TS_TxCreationKeys_set_countersignatory_htlc_key(this_ptr, val);
27087 // debug statements here
27089 // struct LDKPublicKey TxCreationKeys_get_broadcaster_delayed_payment_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
27091 export function TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr: bigint): number {
27092 if(!isWasmInitialized) {
27093 throw new Error("initializeWasm() must be awaited first!");
27095 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr);
27096 return nativeResponseValue;
27098 // void TxCreationKeys_set_broadcaster_delayed_payment_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
27100 export function TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr: bigint, val: number): void {
27101 if(!isWasmInitialized) {
27102 throw new Error("initializeWasm() must be awaited first!");
27104 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr, val);
27105 // debug statements here
27107 // 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);
27109 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): bigint {
27110 if(!isWasmInitialized) {
27111 throw new Error("initializeWasm() must be awaited first!");
27113 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);
27114 return nativeResponseValue;
27116 // uint64_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg);
27118 export function TxCreationKeys_clone_ptr(arg: bigint): bigint {
27119 if(!isWasmInitialized) {
27120 throw new Error("initializeWasm() must be awaited first!");
27122 const nativeResponseValue = wasm.TS_TxCreationKeys_clone_ptr(arg);
27123 return nativeResponseValue;
27125 // struct LDKTxCreationKeys TxCreationKeys_clone(const struct LDKTxCreationKeys *NONNULL_PTR orig);
27127 export function TxCreationKeys_clone(orig: bigint): bigint {
27128 if(!isWasmInitialized) {
27129 throw new Error("initializeWasm() must be awaited first!");
27131 const nativeResponseValue = wasm.TS_TxCreationKeys_clone(orig);
27132 return nativeResponseValue;
27134 // struct LDKCVec_u8Z TxCreationKeys_write(const struct LDKTxCreationKeys *NONNULL_PTR obj);
27136 export function TxCreationKeys_write(obj: bigint): number {
27137 if(!isWasmInitialized) {
27138 throw new Error("initializeWasm() must be awaited first!");
27140 const nativeResponseValue = wasm.TS_TxCreationKeys_write(obj);
27141 return nativeResponseValue;
27143 // struct LDKCResult_TxCreationKeysDecodeErrorZ TxCreationKeys_read(struct LDKu8slice ser);
27145 export function TxCreationKeys_read(ser: number): bigint {
27146 if(!isWasmInitialized) {
27147 throw new Error("initializeWasm() must be awaited first!");
27149 const nativeResponseValue = wasm.TS_TxCreationKeys_read(ser);
27150 return nativeResponseValue;
27152 // void ChannelPublicKeys_free(struct LDKChannelPublicKeys this_obj);
27154 export function ChannelPublicKeys_free(this_obj: bigint): void {
27155 if(!isWasmInitialized) {
27156 throw new Error("initializeWasm() must be awaited first!");
27158 const nativeResponseValue = wasm.TS_ChannelPublicKeys_free(this_obj);
27159 // debug statements here
27161 // struct LDKPublicKey ChannelPublicKeys_get_funding_pubkey(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
27163 export function ChannelPublicKeys_get_funding_pubkey(this_ptr: bigint): number {
27164 if(!isWasmInitialized) {
27165 throw new Error("initializeWasm() must be awaited first!");
27167 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_funding_pubkey(this_ptr);
27168 return nativeResponseValue;
27170 // void ChannelPublicKeys_set_funding_pubkey(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
27172 export function ChannelPublicKeys_set_funding_pubkey(this_ptr: bigint, val: number): void {
27173 if(!isWasmInitialized) {
27174 throw new Error("initializeWasm() must be awaited first!");
27176 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_funding_pubkey(this_ptr, val);
27177 // debug statements here
27179 // struct LDKPublicKey ChannelPublicKeys_get_revocation_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
27181 export function ChannelPublicKeys_get_revocation_basepoint(this_ptr: bigint): number {
27182 if(!isWasmInitialized) {
27183 throw new Error("initializeWasm() must be awaited first!");
27185 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_revocation_basepoint(this_ptr);
27186 return nativeResponseValue;
27188 // void ChannelPublicKeys_set_revocation_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
27190 export function ChannelPublicKeys_set_revocation_basepoint(this_ptr: bigint, val: number): void {
27191 if(!isWasmInitialized) {
27192 throw new Error("initializeWasm() must be awaited first!");
27194 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_revocation_basepoint(this_ptr, val);
27195 // debug statements here
27197 // struct LDKPublicKey ChannelPublicKeys_get_payment_point(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
27199 export function ChannelPublicKeys_get_payment_point(this_ptr: bigint): number {
27200 if(!isWasmInitialized) {
27201 throw new Error("initializeWasm() must be awaited first!");
27203 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_payment_point(this_ptr);
27204 return nativeResponseValue;
27206 // void ChannelPublicKeys_set_payment_point(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
27208 export function ChannelPublicKeys_set_payment_point(this_ptr: bigint, val: number): void {
27209 if(!isWasmInitialized) {
27210 throw new Error("initializeWasm() must be awaited first!");
27212 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_payment_point(this_ptr, val);
27213 // debug statements here
27215 // struct LDKPublicKey ChannelPublicKeys_get_delayed_payment_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
27217 export function ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr: bigint): number {
27218 if(!isWasmInitialized) {
27219 throw new Error("initializeWasm() must be awaited first!");
27221 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr);
27222 return nativeResponseValue;
27224 // void ChannelPublicKeys_set_delayed_payment_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
27226 export function ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
27227 if(!isWasmInitialized) {
27228 throw new Error("initializeWasm() must be awaited first!");
27230 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr, val);
27231 // debug statements here
27233 // struct LDKPublicKey ChannelPublicKeys_get_htlc_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
27235 export function ChannelPublicKeys_get_htlc_basepoint(this_ptr: bigint): number {
27236 if(!isWasmInitialized) {
27237 throw new Error("initializeWasm() must be awaited first!");
27239 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_htlc_basepoint(this_ptr);
27240 return nativeResponseValue;
27242 // void ChannelPublicKeys_set_htlc_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
27244 export function ChannelPublicKeys_set_htlc_basepoint(this_ptr: bigint, val: number): void {
27245 if(!isWasmInitialized) {
27246 throw new Error("initializeWasm() must be awaited first!");
27248 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_htlc_basepoint(this_ptr, val);
27249 // debug statements here
27251 // 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);
27253 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): bigint {
27254 if(!isWasmInitialized) {
27255 throw new Error("initializeWasm() must be awaited first!");
27257 const nativeResponseValue = wasm.TS_ChannelPublicKeys_new(funding_pubkey_arg, revocation_basepoint_arg, payment_point_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg);
27258 return nativeResponseValue;
27260 // uint64_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg);
27262 export function ChannelPublicKeys_clone_ptr(arg: bigint): bigint {
27263 if(!isWasmInitialized) {
27264 throw new Error("initializeWasm() must be awaited first!");
27266 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone_ptr(arg);
27267 return nativeResponseValue;
27269 // struct LDKChannelPublicKeys ChannelPublicKeys_clone(const struct LDKChannelPublicKeys *NONNULL_PTR orig);
27271 export function ChannelPublicKeys_clone(orig: bigint): bigint {
27272 if(!isWasmInitialized) {
27273 throw new Error("initializeWasm() must be awaited first!");
27275 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone(orig);
27276 return nativeResponseValue;
27278 // struct LDKCVec_u8Z ChannelPublicKeys_write(const struct LDKChannelPublicKeys *NONNULL_PTR obj);
27280 export function ChannelPublicKeys_write(obj: bigint): number {
27281 if(!isWasmInitialized) {
27282 throw new Error("initializeWasm() must be awaited first!");
27284 const nativeResponseValue = wasm.TS_ChannelPublicKeys_write(obj);
27285 return nativeResponseValue;
27287 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ ChannelPublicKeys_read(struct LDKu8slice ser);
27289 export function ChannelPublicKeys_read(ser: number): bigint {
27290 if(!isWasmInitialized) {
27291 throw new Error("initializeWasm() must be awaited first!");
27293 const nativeResponseValue = wasm.TS_ChannelPublicKeys_read(ser);
27294 return nativeResponseValue;
27296 // 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);
27298 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): bigint {
27299 if(!isWasmInitialized) {
27300 throw new Error("initializeWasm() must be awaited first!");
27302 const nativeResponseValue = wasm.TS_TxCreationKeys_derive_new(per_commitment_point, broadcaster_delayed_payment_base, broadcaster_htlc_base, countersignatory_revocation_base, countersignatory_htlc_base);
27303 return nativeResponseValue;
27305 // 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);
27307 export function TxCreationKeys_from_channel_static_keys(per_commitment_point: number, broadcaster_keys: bigint, countersignatory_keys: bigint): bigint {
27308 if(!isWasmInitialized) {
27309 throw new Error("initializeWasm() must be awaited first!");
27311 const nativeResponseValue = wasm.TS_TxCreationKeys_from_channel_static_keys(per_commitment_point, broadcaster_keys, countersignatory_keys);
27312 return nativeResponseValue;
27314 // struct LDKCVec_u8Z get_revokeable_redeemscript(struct LDKPublicKey revocation_key, uint16_t contest_delay, struct LDKPublicKey broadcaster_delayed_payment_key);
27316 export function get_revokeable_redeemscript(revocation_key: number, contest_delay: number, broadcaster_delayed_payment_key: number): number {
27317 if(!isWasmInitialized) {
27318 throw new Error("initializeWasm() must be awaited first!");
27320 const nativeResponseValue = wasm.TS_get_revokeable_redeemscript(revocation_key, contest_delay, broadcaster_delayed_payment_key);
27321 return nativeResponseValue;
27323 // void HTLCOutputInCommitment_free(struct LDKHTLCOutputInCommitment this_obj);
27325 export function HTLCOutputInCommitment_free(this_obj: bigint): void {
27326 if(!isWasmInitialized) {
27327 throw new Error("initializeWasm() must be awaited first!");
27329 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_free(this_obj);
27330 // debug statements here
27332 // bool HTLCOutputInCommitment_get_offered(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
27334 export function HTLCOutputInCommitment_get_offered(this_ptr: bigint): boolean {
27335 if(!isWasmInitialized) {
27336 throw new Error("initializeWasm() must be awaited first!");
27338 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_offered(this_ptr);
27339 return nativeResponseValue;
27341 // void HTLCOutputInCommitment_set_offered(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, bool val);
27343 export function HTLCOutputInCommitment_set_offered(this_ptr: bigint, val: boolean): void {
27344 if(!isWasmInitialized) {
27345 throw new Error("initializeWasm() must be awaited first!");
27347 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_offered(this_ptr, val);
27348 // debug statements here
27350 // uint64_t HTLCOutputInCommitment_get_amount_msat(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
27352 export function HTLCOutputInCommitment_get_amount_msat(this_ptr: bigint): bigint {
27353 if(!isWasmInitialized) {
27354 throw new Error("initializeWasm() must be awaited first!");
27356 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_amount_msat(this_ptr);
27357 return nativeResponseValue;
27359 // void HTLCOutputInCommitment_set_amount_msat(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint64_t val);
27361 export function HTLCOutputInCommitment_set_amount_msat(this_ptr: bigint, val: bigint): void {
27362 if(!isWasmInitialized) {
27363 throw new Error("initializeWasm() must be awaited first!");
27365 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_amount_msat(this_ptr, val);
27366 // debug statements here
27368 // uint32_t HTLCOutputInCommitment_get_cltv_expiry(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
27370 export function HTLCOutputInCommitment_get_cltv_expiry(this_ptr: bigint): number {
27371 if(!isWasmInitialized) {
27372 throw new Error("initializeWasm() must be awaited first!");
27374 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_cltv_expiry(this_ptr);
27375 return nativeResponseValue;
27377 // void HTLCOutputInCommitment_set_cltv_expiry(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint32_t val);
27379 export function HTLCOutputInCommitment_set_cltv_expiry(this_ptr: bigint, val: number): void {
27380 if(!isWasmInitialized) {
27381 throw new Error("initializeWasm() must be awaited first!");
27383 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_cltv_expiry(this_ptr, val);
27384 // debug statements here
27386 // const uint8_t (*HTLCOutputInCommitment_get_payment_hash(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr))[32];
27388 export function HTLCOutputInCommitment_get_payment_hash(this_ptr: bigint): number {
27389 if(!isWasmInitialized) {
27390 throw new Error("initializeWasm() must be awaited first!");
27392 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_payment_hash(this_ptr);
27393 return nativeResponseValue;
27395 // void HTLCOutputInCommitment_set_payment_hash(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
27397 export function HTLCOutputInCommitment_set_payment_hash(this_ptr: bigint, val: number): void {
27398 if(!isWasmInitialized) {
27399 throw new Error("initializeWasm() must be awaited first!");
27401 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_payment_hash(this_ptr, val);
27402 // debug statements here
27404 // struct LDKCOption_u32Z HTLCOutputInCommitment_get_transaction_output_index(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
27406 export function HTLCOutputInCommitment_get_transaction_output_index(this_ptr: bigint): bigint {
27407 if(!isWasmInitialized) {
27408 throw new Error("initializeWasm() must be awaited first!");
27410 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_transaction_output_index(this_ptr);
27411 return nativeResponseValue;
27413 // void HTLCOutputInCommitment_set_transaction_output_index(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
27415 export function HTLCOutputInCommitment_set_transaction_output_index(this_ptr: bigint, val: bigint): void {
27416 if(!isWasmInitialized) {
27417 throw new Error("initializeWasm() must be awaited first!");
27419 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_transaction_output_index(this_ptr, val);
27420 // debug statements here
27422 // 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);
27424 export function HTLCOutputInCommitment_new(offered_arg: boolean, amount_msat_arg: bigint, cltv_expiry_arg: number, payment_hash_arg: number, transaction_output_index_arg: bigint): bigint {
27425 if(!isWasmInitialized) {
27426 throw new Error("initializeWasm() must be awaited first!");
27428 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg, transaction_output_index_arg);
27429 return nativeResponseValue;
27431 // uint64_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg);
27433 export function HTLCOutputInCommitment_clone_ptr(arg: bigint): bigint {
27434 if(!isWasmInitialized) {
27435 throw new Error("initializeWasm() must be awaited first!");
27437 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone_ptr(arg);
27438 return nativeResponseValue;
27440 // struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_clone(const struct LDKHTLCOutputInCommitment *NONNULL_PTR orig);
27442 export function HTLCOutputInCommitment_clone(orig: bigint): bigint {
27443 if(!isWasmInitialized) {
27444 throw new Error("initializeWasm() must be awaited first!");
27446 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone(orig);
27447 return nativeResponseValue;
27449 // struct LDKCVec_u8Z HTLCOutputInCommitment_write(const struct LDKHTLCOutputInCommitment *NONNULL_PTR obj);
27451 export function HTLCOutputInCommitment_write(obj: bigint): number {
27452 if(!isWasmInitialized) {
27453 throw new Error("initializeWasm() must be awaited first!");
27455 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_write(obj);
27456 return nativeResponseValue;
27458 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ HTLCOutputInCommitment_read(struct LDKu8slice ser);
27460 export function HTLCOutputInCommitment_read(ser: number): bigint {
27461 if(!isWasmInitialized) {
27462 throw new Error("initializeWasm() must be awaited first!");
27464 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_read(ser);
27465 return nativeResponseValue;
27467 // struct LDKCVec_u8Z get_htlc_redeemscript(const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc, bool opt_anchors, const struct LDKTxCreationKeys *NONNULL_PTR keys);
27469 export function get_htlc_redeemscript(htlc: bigint, opt_anchors: boolean, keys: bigint): number {
27470 if(!isWasmInitialized) {
27471 throw new Error("initializeWasm() must be awaited first!");
27473 const nativeResponseValue = wasm.TS_get_htlc_redeemscript(htlc, opt_anchors, keys);
27474 return nativeResponseValue;
27476 // struct LDKCVec_u8Z make_funding_redeemscript(struct LDKPublicKey broadcaster, struct LDKPublicKey countersignatory);
27478 export function make_funding_redeemscript(broadcaster: number, countersignatory: number): number {
27479 if(!isWasmInitialized) {
27480 throw new Error("initializeWasm() must be awaited first!");
27482 const nativeResponseValue = wasm.TS_make_funding_redeemscript(broadcaster, countersignatory);
27483 return nativeResponseValue;
27485 // 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);
27487 export function build_htlc_transaction(commitment_txid: number, feerate_per_kw: number, contest_delay: number, htlc: bigint, opt_anchors: boolean, broadcaster_delayed_payment_key: number, revocation_key: number): number {
27488 if(!isWasmInitialized) {
27489 throw new Error("initializeWasm() must be awaited first!");
27491 const nativeResponseValue = wasm.TS_build_htlc_transaction(commitment_txid, feerate_per_kw, contest_delay, htlc, opt_anchors, broadcaster_delayed_payment_key, revocation_key);
27492 return nativeResponseValue;
27494 // struct LDKCVec_u8Z get_anchor_redeemscript(struct LDKPublicKey funding_pubkey);
27496 export function get_anchor_redeemscript(funding_pubkey: number): number {
27497 if(!isWasmInitialized) {
27498 throw new Error("initializeWasm() must be awaited first!");
27500 const nativeResponseValue = wasm.TS_get_anchor_redeemscript(funding_pubkey);
27501 return nativeResponseValue;
27503 // void ChannelTransactionParameters_free(struct LDKChannelTransactionParameters this_obj);
27505 export function ChannelTransactionParameters_free(this_obj: bigint): void {
27506 if(!isWasmInitialized) {
27507 throw new Error("initializeWasm() must be awaited first!");
27509 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_free(this_obj);
27510 // debug statements here
27512 // struct LDKChannelPublicKeys ChannelTransactionParameters_get_holder_pubkeys(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
27514 export function ChannelTransactionParameters_get_holder_pubkeys(this_ptr: bigint): bigint {
27515 if(!isWasmInitialized) {
27516 throw new Error("initializeWasm() must be awaited first!");
27518 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_pubkeys(this_ptr);
27519 return nativeResponseValue;
27521 // void ChannelTransactionParameters_set_holder_pubkeys(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
27523 export function ChannelTransactionParameters_set_holder_pubkeys(this_ptr: bigint, val: bigint): void {
27524 if(!isWasmInitialized) {
27525 throw new Error("initializeWasm() must be awaited first!");
27527 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_pubkeys(this_ptr, val);
27528 // debug statements here
27530 // uint16_t ChannelTransactionParameters_get_holder_selected_contest_delay(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
27532 export function ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr: bigint): number {
27533 if(!isWasmInitialized) {
27534 throw new Error("initializeWasm() must be awaited first!");
27536 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr);
27537 return nativeResponseValue;
27539 // void ChannelTransactionParameters_set_holder_selected_contest_delay(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
27541 export function ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr: bigint, val: number): void {
27542 if(!isWasmInitialized) {
27543 throw new Error("initializeWasm() must be awaited first!");
27545 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr, val);
27546 // debug statements here
27548 // bool ChannelTransactionParameters_get_is_outbound_from_holder(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
27550 export function ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr: bigint): boolean {
27551 if(!isWasmInitialized) {
27552 throw new Error("initializeWasm() must be awaited first!");
27554 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr);
27555 return nativeResponseValue;
27557 // void ChannelTransactionParameters_set_is_outbound_from_holder(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, bool val);
27559 export function ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr: bigint, val: boolean): void {
27560 if(!isWasmInitialized) {
27561 throw new Error("initializeWasm() must be awaited first!");
27563 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr, val);
27564 // debug statements here
27566 // struct LDKCounterpartyChannelTransactionParameters ChannelTransactionParameters_get_counterparty_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
27568 export function ChannelTransactionParameters_get_counterparty_parameters(this_ptr: bigint): bigint {
27569 if(!isWasmInitialized) {
27570 throw new Error("initializeWasm() must be awaited first!");
27572 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_counterparty_parameters(this_ptr);
27573 return nativeResponseValue;
27575 // void ChannelTransactionParameters_set_counterparty_parameters(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKCounterpartyChannelTransactionParameters val);
27577 export function ChannelTransactionParameters_set_counterparty_parameters(this_ptr: bigint, val: bigint): void {
27578 if(!isWasmInitialized) {
27579 throw new Error("initializeWasm() must be awaited first!");
27581 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_counterparty_parameters(this_ptr, val);
27582 // debug statements here
27584 // struct LDKOutPoint ChannelTransactionParameters_get_funding_outpoint(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
27586 export function ChannelTransactionParameters_get_funding_outpoint(this_ptr: bigint): bigint {
27587 if(!isWasmInitialized) {
27588 throw new Error("initializeWasm() must be awaited first!");
27590 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_funding_outpoint(this_ptr);
27591 return nativeResponseValue;
27593 // void ChannelTransactionParameters_set_funding_outpoint(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKOutPoint val);
27595 export function ChannelTransactionParameters_set_funding_outpoint(this_ptr: bigint, val: bigint): void {
27596 if(!isWasmInitialized) {
27597 throw new Error("initializeWasm() must be awaited first!");
27599 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_funding_outpoint(this_ptr, val);
27600 // debug statements here
27602 // enum LDKCOption_NoneZ ChannelTransactionParameters_get_opt_anchors(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
27604 export function ChannelTransactionParameters_get_opt_anchors(this_ptr: bigint): COption_NoneZ {
27605 if(!isWasmInitialized) {
27606 throw new Error("initializeWasm() must be awaited first!");
27608 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_opt_anchors(this_ptr);
27609 return nativeResponseValue;
27611 // void ChannelTransactionParameters_set_opt_anchors(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
27613 export function ChannelTransactionParameters_set_opt_anchors(this_ptr: bigint, val: COption_NoneZ): void {
27614 if(!isWasmInitialized) {
27615 throw new Error("initializeWasm() must be awaited first!");
27617 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_opt_anchors(this_ptr, val);
27618 // debug statements here
27620 // 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);
27622 export function ChannelTransactionParameters_new(holder_pubkeys_arg: bigint, holder_selected_contest_delay_arg: number, is_outbound_from_holder_arg: boolean, counterparty_parameters_arg: bigint, funding_outpoint_arg: bigint, opt_anchors_arg: COption_NoneZ): bigint {
27623 if(!isWasmInitialized) {
27624 throw new Error("initializeWasm() must be awaited first!");
27626 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);
27627 return nativeResponseValue;
27629 // uint64_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg);
27631 export function ChannelTransactionParameters_clone_ptr(arg: bigint): bigint {
27632 if(!isWasmInitialized) {
27633 throw new Error("initializeWasm() must be awaited first!");
27635 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone_ptr(arg);
27636 return nativeResponseValue;
27638 // struct LDKChannelTransactionParameters ChannelTransactionParameters_clone(const struct LDKChannelTransactionParameters *NONNULL_PTR orig);
27640 export function ChannelTransactionParameters_clone(orig: bigint): bigint {
27641 if(!isWasmInitialized) {
27642 throw new Error("initializeWasm() must be awaited first!");
27644 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone(orig);
27645 return nativeResponseValue;
27647 // void CounterpartyChannelTransactionParameters_free(struct LDKCounterpartyChannelTransactionParameters this_obj);
27649 export function CounterpartyChannelTransactionParameters_free(this_obj: bigint): void {
27650 if(!isWasmInitialized) {
27651 throw new Error("initializeWasm() must be awaited first!");
27653 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_free(this_obj);
27654 // debug statements here
27656 // struct LDKChannelPublicKeys CounterpartyChannelTransactionParameters_get_pubkeys(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
27658 export function CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr: bigint): bigint {
27659 if(!isWasmInitialized) {
27660 throw new Error("initializeWasm() must be awaited first!");
27662 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr);
27663 return nativeResponseValue;
27665 // void CounterpartyChannelTransactionParameters_set_pubkeys(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
27667 export function CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr: bigint, val: bigint): void {
27668 if(!isWasmInitialized) {
27669 throw new Error("initializeWasm() must be awaited first!");
27671 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr, val);
27672 // debug statements here
27674 // uint16_t CounterpartyChannelTransactionParameters_get_selected_contest_delay(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
27676 export function CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr: bigint): number {
27677 if(!isWasmInitialized) {
27678 throw new Error("initializeWasm() must be awaited first!");
27680 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr);
27681 return nativeResponseValue;
27683 // void CounterpartyChannelTransactionParameters_set_selected_contest_delay(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
27685 export function CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr: bigint, val: number): void {
27686 if(!isWasmInitialized) {
27687 throw new Error("initializeWasm() must be awaited first!");
27689 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr, val);
27690 // debug statements here
27692 // MUST_USE_RES struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_new(struct LDKChannelPublicKeys pubkeys_arg, uint16_t selected_contest_delay_arg);
27694 export function CounterpartyChannelTransactionParameters_new(pubkeys_arg: bigint, selected_contest_delay_arg: number): bigint {
27695 if(!isWasmInitialized) {
27696 throw new Error("initializeWasm() must be awaited first!");
27698 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_new(pubkeys_arg, selected_contest_delay_arg);
27699 return nativeResponseValue;
27701 // uint64_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg);
27703 export function CounterpartyChannelTransactionParameters_clone_ptr(arg: bigint): bigint {
27704 if(!isWasmInitialized) {
27705 throw new Error("initializeWasm() must be awaited first!");
27707 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone_ptr(arg);
27708 return nativeResponseValue;
27710 // struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_clone(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR orig);
27712 export function CounterpartyChannelTransactionParameters_clone(orig: bigint): bigint {
27713 if(!isWasmInitialized) {
27714 throw new Error("initializeWasm() must be awaited first!");
27716 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone(orig);
27717 return nativeResponseValue;
27719 // MUST_USE_RES bool ChannelTransactionParameters_is_populated(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
27721 export function ChannelTransactionParameters_is_populated(this_arg: bigint): boolean {
27722 if(!isWasmInitialized) {
27723 throw new Error("initializeWasm() must be awaited first!");
27725 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_is_populated(this_arg);
27726 return nativeResponseValue;
27728 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_holder_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
27730 export function ChannelTransactionParameters_as_holder_broadcastable(this_arg: bigint): bigint {
27731 if(!isWasmInitialized) {
27732 throw new Error("initializeWasm() must be awaited first!");
27734 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_holder_broadcastable(this_arg);
27735 return nativeResponseValue;
27737 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_counterparty_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
27739 export function ChannelTransactionParameters_as_counterparty_broadcastable(this_arg: bigint): bigint {
27740 if(!isWasmInitialized) {
27741 throw new Error("initializeWasm() must be awaited first!");
27743 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_counterparty_broadcastable(this_arg);
27744 return nativeResponseValue;
27746 // struct LDKCVec_u8Z CounterpartyChannelTransactionParameters_write(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR obj);
27748 export function CounterpartyChannelTransactionParameters_write(obj: bigint): number {
27749 if(!isWasmInitialized) {
27750 throw new Error("initializeWasm() must be awaited first!");
27752 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_write(obj);
27753 return nativeResponseValue;
27755 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CounterpartyChannelTransactionParameters_read(struct LDKu8slice ser);
27757 export function CounterpartyChannelTransactionParameters_read(ser: number): bigint {
27758 if(!isWasmInitialized) {
27759 throw new Error("initializeWasm() must be awaited first!");
27761 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_read(ser);
27762 return nativeResponseValue;
27764 // struct LDKCVec_u8Z ChannelTransactionParameters_write(const struct LDKChannelTransactionParameters *NONNULL_PTR obj);
27766 export function ChannelTransactionParameters_write(obj: bigint): number {
27767 if(!isWasmInitialized) {
27768 throw new Error("initializeWasm() must be awaited first!");
27770 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_write(obj);
27771 return nativeResponseValue;
27773 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ ChannelTransactionParameters_read(struct LDKu8slice ser);
27775 export function ChannelTransactionParameters_read(ser: number): bigint {
27776 if(!isWasmInitialized) {
27777 throw new Error("initializeWasm() must be awaited first!");
27779 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_read(ser);
27780 return nativeResponseValue;
27782 // void DirectedChannelTransactionParameters_free(struct LDKDirectedChannelTransactionParameters this_obj);
27784 export function DirectedChannelTransactionParameters_free(this_obj: bigint): void {
27785 if(!isWasmInitialized) {
27786 throw new Error("initializeWasm() must be awaited first!");
27788 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_free(this_obj);
27789 // debug statements here
27791 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_broadcaster_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
27793 export function DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg: bigint): bigint {
27794 if(!isWasmInitialized) {
27795 throw new Error("initializeWasm() must be awaited first!");
27797 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg);
27798 return nativeResponseValue;
27800 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_countersignatory_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
27802 export function DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg: bigint): bigint {
27803 if(!isWasmInitialized) {
27804 throw new Error("initializeWasm() must be awaited first!");
27806 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg);
27807 return nativeResponseValue;
27809 // MUST_USE_RES uint16_t DirectedChannelTransactionParameters_contest_delay(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
27811 export function DirectedChannelTransactionParameters_contest_delay(this_arg: bigint): number {
27812 if(!isWasmInitialized) {
27813 throw new Error("initializeWasm() must be awaited first!");
27815 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_contest_delay(this_arg);
27816 return nativeResponseValue;
27818 // MUST_USE_RES bool DirectedChannelTransactionParameters_is_outbound(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
27820 export function DirectedChannelTransactionParameters_is_outbound(this_arg: bigint): boolean {
27821 if(!isWasmInitialized) {
27822 throw new Error("initializeWasm() must be awaited first!");
27824 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_is_outbound(this_arg);
27825 return nativeResponseValue;
27827 // MUST_USE_RES struct LDKOutPoint DirectedChannelTransactionParameters_funding_outpoint(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
27829 export function DirectedChannelTransactionParameters_funding_outpoint(this_arg: bigint): bigint {
27830 if(!isWasmInitialized) {
27831 throw new Error("initializeWasm() must be awaited first!");
27833 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_funding_outpoint(this_arg);
27834 return nativeResponseValue;
27836 // MUST_USE_RES bool DirectedChannelTransactionParameters_opt_anchors(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
27838 export function DirectedChannelTransactionParameters_opt_anchors(this_arg: bigint): boolean {
27839 if(!isWasmInitialized) {
27840 throw new Error("initializeWasm() must be awaited first!");
27842 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_opt_anchors(this_arg);
27843 return nativeResponseValue;
27845 // void HolderCommitmentTransaction_free(struct LDKHolderCommitmentTransaction this_obj);
27847 export function HolderCommitmentTransaction_free(this_obj: bigint): void {
27848 if(!isWasmInitialized) {
27849 throw new Error("initializeWasm() must be awaited first!");
27851 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_free(this_obj);
27852 // debug statements here
27854 // struct LDKSignature HolderCommitmentTransaction_get_counterparty_sig(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
27856 export function HolderCommitmentTransaction_get_counterparty_sig(this_ptr: bigint): number {
27857 if(!isWasmInitialized) {
27858 throw new Error("initializeWasm() must be awaited first!");
27860 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_sig(this_ptr);
27861 return nativeResponseValue;
27863 // void HolderCommitmentTransaction_set_counterparty_sig(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKSignature val);
27865 export function HolderCommitmentTransaction_set_counterparty_sig(this_ptr: bigint, val: number): void {
27866 if(!isWasmInitialized) {
27867 throw new Error("initializeWasm() must be awaited first!");
27869 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_sig(this_ptr, val);
27870 // debug statements here
27872 // struct LDKCVec_SignatureZ HolderCommitmentTransaction_get_counterparty_htlc_sigs(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
27874 export function HolderCommitmentTransaction_get_counterparty_htlc_sigs(this_ptr: bigint): number {
27875 if(!isWasmInitialized) {
27876 throw new Error("initializeWasm() must be awaited first!");
27878 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_htlc_sigs(this_ptr);
27879 return nativeResponseValue;
27881 // void HolderCommitmentTransaction_set_counterparty_htlc_sigs(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
27883 export function HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr: bigint, val: number): void {
27884 if(!isWasmInitialized) {
27885 throw new Error("initializeWasm() must be awaited first!");
27887 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr, val);
27888 // debug statements here
27890 // uint64_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg);
27892 export function HolderCommitmentTransaction_clone_ptr(arg: bigint): bigint {
27893 if(!isWasmInitialized) {
27894 throw new Error("initializeWasm() must be awaited first!");
27896 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone_ptr(arg);
27897 return nativeResponseValue;
27899 // struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_clone(const struct LDKHolderCommitmentTransaction *NONNULL_PTR orig);
27901 export function HolderCommitmentTransaction_clone(orig: bigint): bigint {
27902 if(!isWasmInitialized) {
27903 throw new Error("initializeWasm() must be awaited first!");
27905 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone(orig);
27906 return nativeResponseValue;
27908 // struct LDKCVec_u8Z HolderCommitmentTransaction_write(const struct LDKHolderCommitmentTransaction *NONNULL_PTR obj);
27910 export function HolderCommitmentTransaction_write(obj: bigint): number {
27911 if(!isWasmInitialized) {
27912 throw new Error("initializeWasm() must be awaited first!");
27914 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_write(obj);
27915 return nativeResponseValue;
27917 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ HolderCommitmentTransaction_read(struct LDKu8slice ser);
27919 export function HolderCommitmentTransaction_read(ser: number): bigint {
27920 if(!isWasmInitialized) {
27921 throw new Error("initializeWasm() must be awaited first!");
27923 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_read(ser);
27924 return nativeResponseValue;
27926 // 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);
27928 export function HolderCommitmentTransaction_new(commitment_tx: bigint, counterparty_sig: number, counterparty_htlc_sigs: number, holder_funding_key: number, counterparty_funding_key: number): bigint {
27929 if(!isWasmInitialized) {
27930 throw new Error("initializeWasm() must be awaited first!");
27932 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_new(commitment_tx, counterparty_sig, counterparty_htlc_sigs, holder_funding_key, counterparty_funding_key);
27933 return nativeResponseValue;
27935 // void BuiltCommitmentTransaction_free(struct LDKBuiltCommitmentTransaction this_obj);
27937 export function BuiltCommitmentTransaction_free(this_obj: bigint): void {
27938 if(!isWasmInitialized) {
27939 throw new Error("initializeWasm() must be awaited first!");
27941 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_free(this_obj);
27942 // debug statements here
27944 // struct LDKTransaction BuiltCommitmentTransaction_get_transaction(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr);
27946 export function BuiltCommitmentTransaction_get_transaction(this_ptr: bigint): number {
27947 if(!isWasmInitialized) {
27948 throw new Error("initializeWasm() must be awaited first!");
27950 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_transaction(this_ptr);
27951 return nativeResponseValue;
27953 // void BuiltCommitmentTransaction_set_transaction(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKTransaction val);
27955 export function BuiltCommitmentTransaction_set_transaction(this_ptr: bigint, val: number): void {
27956 if(!isWasmInitialized) {
27957 throw new Error("initializeWasm() must be awaited first!");
27959 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_transaction(this_ptr, val);
27960 // debug statements here
27962 // const uint8_t (*BuiltCommitmentTransaction_get_txid(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr))[32];
27964 export function BuiltCommitmentTransaction_get_txid(this_ptr: bigint): number {
27965 if(!isWasmInitialized) {
27966 throw new Error("initializeWasm() must be awaited first!");
27968 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_txid(this_ptr);
27969 return nativeResponseValue;
27971 // void BuiltCommitmentTransaction_set_txid(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
27973 export function BuiltCommitmentTransaction_set_txid(this_ptr: bigint, val: number): void {
27974 if(!isWasmInitialized) {
27975 throw new Error("initializeWasm() must be awaited first!");
27977 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_txid(this_ptr, val);
27978 // debug statements here
27980 // MUST_USE_RES struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_new(struct LDKTransaction transaction_arg, struct LDKThirtyTwoBytes txid_arg);
27982 export function BuiltCommitmentTransaction_new(transaction_arg: number, txid_arg: number): bigint {
27983 if(!isWasmInitialized) {
27984 throw new Error("initializeWasm() must be awaited first!");
27986 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_new(transaction_arg, txid_arg);
27987 return nativeResponseValue;
27989 // uint64_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg);
27991 export function BuiltCommitmentTransaction_clone_ptr(arg: bigint): bigint {
27992 if(!isWasmInitialized) {
27993 throw new Error("initializeWasm() must be awaited first!");
27995 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone_ptr(arg);
27996 return nativeResponseValue;
27998 // struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_clone(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR orig);
28000 export function BuiltCommitmentTransaction_clone(orig: bigint): bigint {
28001 if(!isWasmInitialized) {
28002 throw new Error("initializeWasm() must be awaited first!");
28004 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone(orig);
28005 return nativeResponseValue;
28007 // struct LDKCVec_u8Z BuiltCommitmentTransaction_write(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR obj);
28009 export function BuiltCommitmentTransaction_write(obj: bigint): number {
28010 if(!isWasmInitialized) {
28011 throw new Error("initializeWasm() must be awaited first!");
28013 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_write(obj);
28014 return nativeResponseValue;
28016 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ BuiltCommitmentTransaction_read(struct LDKu8slice ser);
28018 export function BuiltCommitmentTransaction_read(ser: number): bigint {
28019 if(!isWasmInitialized) {
28020 throw new Error("initializeWasm() must be awaited first!");
28022 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_read(ser);
28023 return nativeResponseValue;
28025 // 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);
28027 export function BuiltCommitmentTransaction_get_sighash_all(this_arg: bigint, funding_redeemscript: number, channel_value_satoshis: bigint): number {
28028 if(!isWasmInitialized) {
28029 throw new Error("initializeWasm() must be awaited first!");
28031 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
28032 return nativeResponseValue;
28034 // 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);
28036 export function BuiltCommitmentTransaction_sign(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
28037 if(!isWasmInitialized) {
28038 throw new Error("initializeWasm() must be awaited first!");
28040 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
28041 return nativeResponseValue;
28043 // void ClosingTransaction_free(struct LDKClosingTransaction this_obj);
28045 export function ClosingTransaction_free(this_obj: bigint): void {
28046 if(!isWasmInitialized) {
28047 throw new Error("initializeWasm() must be awaited first!");
28049 const nativeResponseValue = wasm.TS_ClosingTransaction_free(this_obj);
28050 // debug statements here
28052 // uint64_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg);
28054 export function ClosingTransaction_clone_ptr(arg: bigint): bigint {
28055 if(!isWasmInitialized) {
28056 throw new Error("initializeWasm() must be awaited first!");
28058 const nativeResponseValue = wasm.TS_ClosingTransaction_clone_ptr(arg);
28059 return nativeResponseValue;
28061 // struct LDKClosingTransaction ClosingTransaction_clone(const struct LDKClosingTransaction *NONNULL_PTR orig);
28063 export function ClosingTransaction_clone(orig: bigint): bigint {
28064 if(!isWasmInitialized) {
28065 throw new Error("initializeWasm() must be awaited first!");
28067 const nativeResponseValue = wasm.TS_ClosingTransaction_clone(orig);
28068 return nativeResponseValue;
28070 // uint64_t ClosingTransaction_hash(const struct LDKClosingTransaction *NONNULL_PTR o);
28072 export function ClosingTransaction_hash(o: bigint): bigint {
28073 if(!isWasmInitialized) {
28074 throw new Error("initializeWasm() must be awaited first!");
28076 const nativeResponseValue = wasm.TS_ClosingTransaction_hash(o);
28077 return nativeResponseValue;
28079 // 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);
28081 export function ClosingTransaction_new(to_holder_value_sat: bigint, to_counterparty_value_sat: bigint, to_holder_script: number, to_counterparty_script: number, funding_outpoint: bigint): bigint {
28082 if(!isWasmInitialized) {
28083 throw new Error("initializeWasm() must be awaited first!");
28085 const nativeResponseValue = wasm.TS_ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
28086 return nativeResponseValue;
28088 // MUST_USE_RES struct LDKTrustedClosingTransaction ClosingTransaction_trust(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
28090 export function ClosingTransaction_trust(this_arg: bigint): bigint {
28091 if(!isWasmInitialized) {
28092 throw new Error("initializeWasm() must be awaited first!");
28094 const nativeResponseValue = wasm.TS_ClosingTransaction_trust(this_arg);
28095 return nativeResponseValue;
28097 // MUST_USE_RES struct LDKCResult_TrustedClosingTransactionNoneZ ClosingTransaction_verify(const struct LDKClosingTransaction *NONNULL_PTR this_arg, struct LDKOutPoint funding_outpoint);
28099 export function ClosingTransaction_verify(this_arg: bigint, funding_outpoint: bigint): bigint {
28100 if(!isWasmInitialized) {
28101 throw new Error("initializeWasm() must be awaited first!");
28103 const nativeResponseValue = wasm.TS_ClosingTransaction_verify(this_arg, funding_outpoint);
28104 return nativeResponseValue;
28106 // MUST_USE_RES uint64_t ClosingTransaction_to_holder_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
28108 export function ClosingTransaction_to_holder_value_sat(this_arg: bigint): bigint {
28109 if(!isWasmInitialized) {
28110 throw new Error("initializeWasm() must be awaited first!");
28112 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_value_sat(this_arg);
28113 return nativeResponseValue;
28115 // MUST_USE_RES uint64_t ClosingTransaction_to_counterparty_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
28117 export function ClosingTransaction_to_counterparty_value_sat(this_arg: bigint): bigint {
28118 if(!isWasmInitialized) {
28119 throw new Error("initializeWasm() must be awaited first!");
28121 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_value_sat(this_arg);
28122 return nativeResponseValue;
28124 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_holder_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
28126 export function ClosingTransaction_to_holder_script(this_arg: bigint): number {
28127 if(!isWasmInitialized) {
28128 throw new Error("initializeWasm() must be awaited first!");
28130 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_script(this_arg);
28131 return nativeResponseValue;
28133 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_counterparty_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
28135 export function ClosingTransaction_to_counterparty_script(this_arg: bigint): number {
28136 if(!isWasmInitialized) {
28137 throw new Error("initializeWasm() must be awaited first!");
28139 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_script(this_arg);
28140 return nativeResponseValue;
28142 // void TrustedClosingTransaction_free(struct LDKTrustedClosingTransaction this_obj);
28144 export function TrustedClosingTransaction_free(this_obj: bigint): void {
28145 if(!isWasmInitialized) {
28146 throw new Error("initializeWasm() must be awaited first!");
28148 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_free(this_obj);
28149 // debug statements here
28151 // MUST_USE_RES struct LDKTransaction TrustedClosingTransaction_built_transaction(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg);
28153 export function TrustedClosingTransaction_built_transaction(this_arg: bigint): number {
28154 if(!isWasmInitialized) {
28155 throw new Error("initializeWasm() must be awaited first!");
28157 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_built_transaction(this_arg);
28158 return nativeResponseValue;
28160 // 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);
28162 export function TrustedClosingTransaction_get_sighash_all(this_arg: bigint, funding_redeemscript: number, channel_value_satoshis: bigint): number {
28163 if(!isWasmInitialized) {
28164 throw new Error("initializeWasm() must be awaited first!");
28166 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
28167 return nativeResponseValue;
28169 // 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);
28171 export function TrustedClosingTransaction_sign(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
28172 if(!isWasmInitialized) {
28173 throw new Error("initializeWasm() must be awaited first!");
28175 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
28176 return nativeResponseValue;
28178 // void CommitmentTransaction_free(struct LDKCommitmentTransaction this_obj);
28180 export function CommitmentTransaction_free(this_obj: bigint): void {
28181 if(!isWasmInitialized) {
28182 throw new Error("initializeWasm() must be awaited first!");
28184 const nativeResponseValue = wasm.TS_CommitmentTransaction_free(this_obj);
28185 // debug statements here
28187 // uint64_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg);
28189 export function CommitmentTransaction_clone_ptr(arg: bigint): bigint {
28190 if(!isWasmInitialized) {
28191 throw new Error("initializeWasm() must be awaited first!");
28193 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone_ptr(arg);
28194 return nativeResponseValue;
28196 // struct LDKCommitmentTransaction CommitmentTransaction_clone(const struct LDKCommitmentTransaction *NONNULL_PTR orig);
28198 export function CommitmentTransaction_clone(orig: bigint): bigint {
28199 if(!isWasmInitialized) {
28200 throw new Error("initializeWasm() must be awaited first!");
28202 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone(orig);
28203 return nativeResponseValue;
28205 // struct LDKCVec_u8Z CommitmentTransaction_write(const struct LDKCommitmentTransaction *NONNULL_PTR obj);
28207 export function CommitmentTransaction_write(obj: bigint): number {
28208 if(!isWasmInitialized) {
28209 throw new Error("initializeWasm() must be awaited first!");
28211 const nativeResponseValue = wasm.TS_CommitmentTransaction_write(obj);
28212 return nativeResponseValue;
28214 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CommitmentTransaction_read(struct LDKu8slice ser);
28216 export function CommitmentTransaction_read(ser: number): bigint {
28217 if(!isWasmInitialized) {
28218 throw new Error("initializeWasm() must be awaited first!");
28220 const nativeResponseValue = wasm.TS_CommitmentTransaction_read(ser);
28221 return nativeResponseValue;
28223 // MUST_USE_RES uint64_t CommitmentTransaction_commitment_number(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
28225 export function CommitmentTransaction_commitment_number(this_arg: bigint): bigint {
28226 if(!isWasmInitialized) {
28227 throw new Error("initializeWasm() must be awaited first!");
28229 const nativeResponseValue = wasm.TS_CommitmentTransaction_commitment_number(this_arg);
28230 return nativeResponseValue;
28232 // MUST_USE_RES uint64_t CommitmentTransaction_to_broadcaster_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
28234 export function CommitmentTransaction_to_broadcaster_value_sat(this_arg: bigint): bigint {
28235 if(!isWasmInitialized) {
28236 throw new Error("initializeWasm() must be awaited first!");
28238 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_broadcaster_value_sat(this_arg);
28239 return nativeResponseValue;
28241 // MUST_USE_RES uint64_t CommitmentTransaction_to_countersignatory_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
28243 export function CommitmentTransaction_to_countersignatory_value_sat(this_arg: bigint): bigint {
28244 if(!isWasmInitialized) {
28245 throw new Error("initializeWasm() must be awaited first!");
28247 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_countersignatory_value_sat(this_arg);
28248 return nativeResponseValue;
28250 // MUST_USE_RES uint32_t CommitmentTransaction_feerate_per_kw(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
28252 export function CommitmentTransaction_feerate_per_kw(this_arg: bigint): number {
28253 if(!isWasmInitialized) {
28254 throw new Error("initializeWasm() must be awaited first!");
28256 const nativeResponseValue = wasm.TS_CommitmentTransaction_feerate_per_kw(this_arg);
28257 return nativeResponseValue;
28259 // MUST_USE_RES struct LDKTrustedCommitmentTransaction CommitmentTransaction_trust(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
28261 export function CommitmentTransaction_trust(this_arg: bigint): bigint {
28262 if(!isWasmInitialized) {
28263 throw new Error("initializeWasm() must be awaited first!");
28265 const nativeResponseValue = wasm.TS_CommitmentTransaction_trust(this_arg);
28266 return nativeResponseValue;
28268 // 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);
28270 export function CommitmentTransaction_verify(this_arg: bigint, channel_parameters: bigint, broadcaster_keys: bigint, countersignatory_keys: bigint): bigint {
28271 if(!isWasmInitialized) {
28272 throw new Error("initializeWasm() must be awaited first!");
28274 const nativeResponseValue = wasm.TS_CommitmentTransaction_verify(this_arg, channel_parameters, broadcaster_keys, countersignatory_keys);
28275 return nativeResponseValue;
28277 // void TrustedCommitmentTransaction_free(struct LDKTrustedCommitmentTransaction this_obj);
28279 export function TrustedCommitmentTransaction_free(this_obj: bigint): void {
28280 if(!isWasmInitialized) {
28281 throw new Error("initializeWasm() must be awaited first!");
28283 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_free(this_obj);
28284 // debug statements here
28286 // MUST_USE_RES struct LDKThirtyTwoBytes TrustedCommitmentTransaction_txid(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
28288 export function TrustedCommitmentTransaction_txid(this_arg: bigint): number {
28289 if(!isWasmInitialized) {
28290 throw new Error("initializeWasm() must be awaited first!");
28292 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_txid(this_arg);
28293 return nativeResponseValue;
28295 // MUST_USE_RES struct LDKBuiltCommitmentTransaction TrustedCommitmentTransaction_built_transaction(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
28297 export function TrustedCommitmentTransaction_built_transaction(this_arg: bigint): bigint {
28298 if(!isWasmInitialized) {
28299 throw new Error("initializeWasm() must be awaited first!");
28301 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_built_transaction(this_arg);
28302 return nativeResponseValue;
28304 // MUST_USE_RES struct LDKTxCreationKeys TrustedCommitmentTransaction_keys(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
28306 export function TrustedCommitmentTransaction_keys(this_arg: bigint): bigint {
28307 if(!isWasmInitialized) {
28308 throw new Error("initializeWasm() must be awaited first!");
28310 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_keys(this_arg);
28311 return nativeResponseValue;
28313 // MUST_USE_RES bool TrustedCommitmentTransaction_opt_anchors(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
28315 export function TrustedCommitmentTransaction_opt_anchors(this_arg: bigint): boolean {
28316 if(!isWasmInitialized) {
28317 throw new Error("initializeWasm() must be awaited first!");
28319 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_opt_anchors(this_arg);
28320 return nativeResponseValue;
28322 // 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);
28324 export function TrustedCommitmentTransaction_get_htlc_sigs(this_arg: bigint, htlc_base_key: number, channel_parameters: bigint): bigint {
28325 if(!isWasmInitialized) {
28326 throw new Error("initializeWasm() must be awaited first!");
28328 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_get_htlc_sigs(this_arg, htlc_base_key, channel_parameters);
28329 return nativeResponseValue;
28331 // uint64_t get_commitment_transaction_number_obscure_factor(struct LDKPublicKey broadcaster_payment_basepoint, struct LDKPublicKey countersignatory_payment_basepoint, bool outbound_from_broadcaster);
28333 export function get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint: number, countersignatory_payment_basepoint: number, outbound_from_broadcaster: boolean): bigint {
28334 if(!isWasmInitialized) {
28335 throw new Error("initializeWasm() must be awaited first!");
28337 const nativeResponseValue = wasm.TS_get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint, countersignatory_payment_basepoint, outbound_from_broadcaster);
28338 return nativeResponseValue;
28340 // bool InitFeatures_eq(const struct LDKInitFeatures *NONNULL_PTR a, const struct LDKInitFeatures *NONNULL_PTR b);
28342 export function InitFeatures_eq(a: bigint, b: bigint): boolean {
28343 if(!isWasmInitialized) {
28344 throw new Error("initializeWasm() must be awaited first!");
28346 const nativeResponseValue = wasm.TS_InitFeatures_eq(a, b);
28347 return nativeResponseValue;
28349 // bool NodeFeatures_eq(const struct LDKNodeFeatures *NONNULL_PTR a, const struct LDKNodeFeatures *NONNULL_PTR b);
28351 export function NodeFeatures_eq(a: bigint, b: bigint): boolean {
28352 if(!isWasmInitialized) {
28353 throw new Error("initializeWasm() must be awaited first!");
28355 const nativeResponseValue = wasm.TS_NodeFeatures_eq(a, b);
28356 return nativeResponseValue;
28358 // bool ChannelFeatures_eq(const struct LDKChannelFeatures *NONNULL_PTR a, const struct LDKChannelFeatures *NONNULL_PTR b);
28360 export function ChannelFeatures_eq(a: bigint, b: bigint): boolean {
28361 if(!isWasmInitialized) {
28362 throw new Error("initializeWasm() must be awaited first!");
28364 const nativeResponseValue = wasm.TS_ChannelFeatures_eq(a, b);
28365 return nativeResponseValue;
28367 // bool InvoiceFeatures_eq(const struct LDKInvoiceFeatures *NONNULL_PTR a, const struct LDKInvoiceFeatures *NONNULL_PTR b);
28369 export function InvoiceFeatures_eq(a: bigint, b: bigint): boolean {
28370 if(!isWasmInitialized) {
28371 throw new Error("initializeWasm() must be awaited first!");
28373 const nativeResponseValue = wasm.TS_InvoiceFeatures_eq(a, b);
28374 return nativeResponseValue;
28376 // bool ChannelTypeFeatures_eq(const struct LDKChannelTypeFeatures *NONNULL_PTR a, const struct LDKChannelTypeFeatures *NONNULL_PTR b);
28378 export function ChannelTypeFeatures_eq(a: bigint, b: bigint): boolean {
28379 if(!isWasmInitialized) {
28380 throw new Error("initializeWasm() must be awaited first!");
28382 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_eq(a, b);
28383 return nativeResponseValue;
28385 // uint64_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg);
28387 export function InitFeatures_clone_ptr(arg: bigint): bigint {
28388 if(!isWasmInitialized) {
28389 throw new Error("initializeWasm() must be awaited first!");
28391 const nativeResponseValue = wasm.TS_InitFeatures_clone_ptr(arg);
28392 return nativeResponseValue;
28394 // struct LDKInitFeatures InitFeatures_clone(const struct LDKInitFeatures *NONNULL_PTR orig);
28396 export function InitFeatures_clone(orig: bigint): bigint {
28397 if(!isWasmInitialized) {
28398 throw new Error("initializeWasm() must be awaited first!");
28400 const nativeResponseValue = wasm.TS_InitFeatures_clone(orig);
28401 return nativeResponseValue;
28403 // uint64_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg);
28405 export function NodeFeatures_clone_ptr(arg: bigint): bigint {
28406 if(!isWasmInitialized) {
28407 throw new Error("initializeWasm() must be awaited first!");
28409 const nativeResponseValue = wasm.TS_NodeFeatures_clone_ptr(arg);
28410 return nativeResponseValue;
28412 // struct LDKNodeFeatures NodeFeatures_clone(const struct LDKNodeFeatures *NONNULL_PTR orig);
28414 export function NodeFeatures_clone(orig: bigint): bigint {
28415 if(!isWasmInitialized) {
28416 throw new Error("initializeWasm() must be awaited first!");
28418 const nativeResponseValue = wasm.TS_NodeFeatures_clone(orig);
28419 return nativeResponseValue;
28421 // uint64_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg);
28423 export function ChannelFeatures_clone_ptr(arg: bigint): bigint {
28424 if(!isWasmInitialized) {
28425 throw new Error("initializeWasm() must be awaited first!");
28427 const nativeResponseValue = wasm.TS_ChannelFeatures_clone_ptr(arg);
28428 return nativeResponseValue;
28430 // struct LDKChannelFeatures ChannelFeatures_clone(const struct LDKChannelFeatures *NONNULL_PTR orig);
28432 export function ChannelFeatures_clone(orig: bigint): bigint {
28433 if(!isWasmInitialized) {
28434 throw new Error("initializeWasm() must be awaited first!");
28436 const nativeResponseValue = wasm.TS_ChannelFeatures_clone(orig);
28437 return nativeResponseValue;
28439 // uint64_t InvoiceFeatures_clone_ptr(LDKInvoiceFeatures *NONNULL_PTR arg);
28441 export function InvoiceFeatures_clone_ptr(arg: bigint): bigint {
28442 if(!isWasmInitialized) {
28443 throw new Error("initializeWasm() must be awaited first!");
28445 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone_ptr(arg);
28446 return nativeResponseValue;
28448 // struct LDKInvoiceFeatures InvoiceFeatures_clone(const struct LDKInvoiceFeatures *NONNULL_PTR orig);
28450 export function InvoiceFeatures_clone(orig: bigint): bigint {
28451 if(!isWasmInitialized) {
28452 throw new Error("initializeWasm() must be awaited first!");
28454 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone(orig);
28455 return nativeResponseValue;
28457 // uint64_t ChannelTypeFeatures_clone_ptr(LDKChannelTypeFeatures *NONNULL_PTR arg);
28459 export function ChannelTypeFeatures_clone_ptr(arg: bigint): bigint {
28460 if(!isWasmInitialized) {
28461 throw new Error("initializeWasm() must be awaited first!");
28463 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone_ptr(arg);
28464 return nativeResponseValue;
28466 // struct LDKChannelTypeFeatures ChannelTypeFeatures_clone(const struct LDKChannelTypeFeatures *NONNULL_PTR orig);
28468 export function ChannelTypeFeatures_clone(orig: bigint): bigint {
28469 if(!isWasmInitialized) {
28470 throw new Error("initializeWasm() must be awaited first!");
28472 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone(orig);
28473 return nativeResponseValue;
28475 // void InitFeatures_free(struct LDKInitFeatures this_obj);
28477 export function InitFeatures_free(this_obj: bigint): void {
28478 if(!isWasmInitialized) {
28479 throw new Error("initializeWasm() must be awaited first!");
28481 const nativeResponseValue = wasm.TS_InitFeatures_free(this_obj);
28482 // debug statements here
28484 // void NodeFeatures_free(struct LDKNodeFeatures this_obj);
28486 export function NodeFeatures_free(this_obj: bigint): void {
28487 if(!isWasmInitialized) {
28488 throw new Error("initializeWasm() must be awaited first!");
28490 const nativeResponseValue = wasm.TS_NodeFeatures_free(this_obj);
28491 // debug statements here
28493 // void ChannelFeatures_free(struct LDKChannelFeatures this_obj);
28495 export function ChannelFeatures_free(this_obj: bigint): void {
28496 if(!isWasmInitialized) {
28497 throw new Error("initializeWasm() must be awaited first!");
28499 const nativeResponseValue = wasm.TS_ChannelFeatures_free(this_obj);
28500 // debug statements here
28502 // void InvoiceFeatures_free(struct LDKInvoiceFeatures this_obj);
28504 export function InvoiceFeatures_free(this_obj: bigint): void {
28505 if(!isWasmInitialized) {
28506 throw new Error("initializeWasm() must be awaited first!");
28508 const nativeResponseValue = wasm.TS_InvoiceFeatures_free(this_obj);
28509 // debug statements here
28511 // void ChannelTypeFeatures_free(struct LDKChannelTypeFeatures this_obj);
28513 export function ChannelTypeFeatures_free(this_obj: bigint): void {
28514 if(!isWasmInitialized) {
28515 throw new Error("initializeWasm() must be awaited first!");
28517 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_free(this_obj);
28518 // debug statements here
28520 // MUST_USE_RES struct LDKInitFeatures InitFeatures_known_channel_features(void);
28522 export function InitFeatures_known_channel_features(): bigint {
28523 if(!isWasmInitialized) {
28524 throw new Error("initializeWasm() must be awaited first!");
28526 const nativeResponseValue = wasm.TS_InitFeatures_known_channel_features();
28527 return nativeResponseValue;
28529 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_known_channel_features(void);
28531 export function NodeFeatures_known_channel_features(): bigint {
28532 if(!isWasmInitialized) {
28533 throw new Error("initializeWasm() must be awaited first!");
28535 const nativeResponseValue = wasm.TS_NodeFeatures_known_channel_features();
28536 return nativeResponseValue;
28538 // MUST_USE_RES struct LDKInitFeatures InitFeatures_empty(void);
28540 export function InitFeatures_empty(): bigint {
28541 if(!isWasmInitialized) {
28542 throw new Error("initializeWasm() must be awaited first!");
28544 const nativeResponseValue = wasm.TS_InitFeatures_empty();
28545 return nativeResponseValue;
28547 // MUST_USE_RES struct LDKInitFeatures InitFeatures_known(void);
28549 export function InitFeatures_known(): bigint {
28550 if(!isWasmInitialized) {
28551 throw new Error("initializeWasm() must be awaited first!");
28553 const nativeResponseValue = wasm.TS_InitFeatures_known();
28554 return nativeResponseValue;
28556 // MUST_USE_RES bool InitFeatures_requires_unknown_bits(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28558 export function InitFeatures_requires_unknown_bits(this_arg: bigint): boolean {
28559 if(!isWasmInitialized) {
28560 throw new Error("initializeWasm() must be awaited first!");
28562 const nativeResponseValue = wasm.TS_InitFeatures_requires_unknown_bits(this_arg);
28563 return nativeResponseValue;
28565 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_empty(void);
28567 export function NodeFeatures_empty(): bigint {
28568 if(!isWasmInitialized) {
28569 throw new Error("initializeWasm() must be awaited first!");
28571 const nativeResponseValue = wasm.TS_NodeFeatures_empty();
28572 return nativeResponseValue;
28574 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_known(void);
28576 export function NodeFeatures_known(): bigint {
28577 if(!isWasmInitialized) {
28578 throw new Error("initializeWasm() must be awaited first!");
28580 const nativeResponseValue = wasm.TS_NodeFeatures_known();
28581 return nativeResponseValue;
28583 // MUST_USE_RES bool NodeFeatures_requires_unknown_bits(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28585 export function NodeFeatures_requires_unknown_bits(this_arg: bigint): boolean {
28586 if(!isWasmInitialized) {
28587 throw new Error("initializeWasm() must be awaited first!");
28589 const nativeResponseValue = wasm.TS_NodeFeatures_requires_unknown_bits(this_arg);
28590 return nativeResponseValue;
28592 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_empty(void);
28594 export function ChannelFeatures_empty(): bigint {
28595 if(!isWasmInitialized) {
28596 throw new Error("initializeWasm() must be awaited first!");
28598 const nativeResponseValue = wasm.TS_ChannelFeatures_empty();
28599 return nativeResponseValue;
28601 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_known(void);
28603 export function ChannelFeatures_known(): bigint {
28604 if(!isWasmInitialized) {
28605 throw new Error("initializeWasm() must be awaited first!");
28607 const nativeResponseValue = wasm.TS_ChannelFeatures_known();
28608 return nativeResponseValue;
28610 // MUST_USE_RES bool ChannelFeatures_requires_unknown_bits(const struct LDKChannelFeatures *NONNULL_PTR this_arg);
28612 export function ChannelFeatures_requires_unknown_bits(this_arg: bigint): boolean {
28613 if(!isWasmInitialized) {
28614 throw new Error("initializeWasm() must be awaited first!");
28616 const nativeResponseValue = wasm.TS_ChannelFeatures_requires_unknown_bits(this_arg);
28617 return nativeResponseValue;
28619 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_empty(void);
28621 export function InvoiceFeatures_empty(): bigint {
28622 if(!isWasmInitialized) {
28623 throw new Error("initializeWasm() must be awaited first!");
28625 const nativeResponseValue = wasm.TS_InvoiceFeatures_empty();
28626 return nativeResponseValue;
28628 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_known(void);
28630 export function InvoiceFeatures_known(): bigint {
28631 if(!isWasmInitialized) {
28632 throw new Error("initializeWasm() must be awaited first!");
28634 const nativeResponseValue = wasm.TS_InvoiceFeatures_known();
28635 return nativeResponseValue;
28637 // MUST_USE_RES bool InvoiceFeatures_requires_unknown_bits(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
28639 export function InvoiceFeatures_requires_unknown_bits(this_arg: bigint): boolean {
28640 if(!isWasmInitialized) {
28641 throw new Error("initializeWasm() must be awaited first!");
28643 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_unknown_bits(this_arg);
28644 return nativeResponseValue;
28646 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_empty(void);
28648 export function ChannelTypeFeatures_empty(): bigint {
28649 if(!isWasmInitialized) {
28650 throw new Error("initializeWasm() must be awaited first!");
28652 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_empty();
28653 return nativeResponseValue;
28655 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_known(void);
28657 export function ChannelTypeFeatures_known(): bigint {
28658 if(!isWasmInitialized) {
28659 throw new Error("initializeWasm() must be awaited first!");
28661 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_known();
28662 return nativeResponseValue;
28664 // MUST_USE_RES bool ChannelTypeFeatures_requires_unknown_bits(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28666 export function ChannelTypeFeatures_requires_unknown_bits(this_arg: bigint): boolean {
28667 if(!isWasmInitialized) {
28668 throw new Error("initializeWasm() must be awaited first!");
28670 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_unknown_bits(this_arg);
28671 return nativeResponseValue;
28673 // struct LDKCVec_u8Z InitFeatures_write(const struct LDKInitFeatures *NONNULL_PTR obj);
28675 export function InitFeatures_write(obj: bigint): number {
28676 if(!isWasmInitialized) {
28677 throw new Error("initializeWasm() must be awaited first!");
28679 const nativeResponseValue = wasm.TS_InitFeatures_write(obj);
28680 return nativeResponseValue;
28682 // struct LDKCResult_InitFeaturesDecodeErrorZ InitFeatures_read(struct LDKu8slice ser);
28684 export function InitFeatures_read(ser: number): bigint {
28685 if(!isWasmInitialized) {
28686 throw new Error("initializeWasm() must be awaited first!");
28688 const nativeResponseValue = wasm.TS_InitFeatures_read(ser);
28689 return nativeResponseValue;
28691 // struct LDKCVec_u8Z ChannelFeatures_write(const struct LDKChannelFeatures *NONNULL_PTR obj);
28693 export function ChannelFeatures_write(obj: bigint): number {
28694 if(!isWasmInitialized) {
28695 throw new Error("initializeWasm() must be awaited first!");
28697 const nativeResponseValue = wasm.TS_ChannelFeatures_write(obj);
28698 return nativeResponseValue;
28700 // struct LDKCResult_ChannelFeaturesDecodeErrorZ ChannelFeatures_read(struct LDKu8slice ser);
28702 export function ChannelFeatures_read(ser: number): bigint {
28703 if(!isWasmInitialized) {
28704 throw new Error("initializeWasm() must be awaited first!");
28706 const nativeResponseValue = wasm.TS_ChannelFeatures_read(ser);
28707 return nativeResponseValue;
28709 // struct LDKCVec_u8Z NodeFeatures_write(const struct LDKNodeFeatures *NONNULL_PTR obj);
28711 export function NodeFeatures_write(obj: bigint): number {
28712 if(!isWasmInitialized) {
28713 throw new Error("initializeWasm() must be awaited first!");
28715 const nativeResponseValue = wasm.TS_NodeFeatures_write(obj);
28716 return nativeResponseValue;
28718 // struct LDKCResult_NodeFeaturesDecodeErrorZ NodeFeatures_read(struct LDKu8slice ser);
28720 export function NodeFeatures_read(ser: number): bigint {
28721 if(!isWasmInitialized) {
28722 throw new Error("initializeWasm() must be awaited first!");
28724 const nativeResponseValue = wasm.TS_NodeFeatures_read(ser);
28725 return nativeResponseValue;
28727 // struct LDKCVec_u8Z InvoiceFeatures_write(const struct LDKInvoiceFeatures *NONNULL_PTR obj);
28729 export function InvoiceFeatures_write(obj: bigint): number {
28730 if(!isWasmInitialized) {
28731 throw new Error("initializeWasm() must be awaited first!");
28733 const nativeResponseValue = wasm.TS_InvoiceFeatures_write(obj);
28734 return nativeResponseValue;
28736 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ InvoiceFeatures_read(struct LDKu8slice ser);
28738 export function InvoiceFeatures_read(ser: number): bigint {
28739 if(!isWasmInitialized) {
28740 throw new Error("initializeWasm() must be awaited first!");
28742 const nativeResponseValue = wasm.TS_InvoiceFeatures_read(ser);
28743 return nativeResponseValue;
28745 // struct LDKCVec_u8Z ChannelTypeFeatures_write(const struct LDKChannelTypeFeatures *NONNULL_PTR obj);
28747 export function ChannelTypeFeatures_write(obj: bigint): number {
28748 if(!isWasmInitialized) {
28749 throw new Error("initializeWasm() must be awaited first!");
28751 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_write(obj);
28752 return nativeResponseValue;
28754 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ ChannelTypeFeatures_read(struct LDKu8slice ser);
28756 export function ChannelTypeFeatures_read(ser: number): bigint {
28757 if(!isWasmInitialized) {
28758 throw new Error("initializeWasm() must be awaited first!");
28760 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_read(ser);
28761 return nativeResponseValue;
28763 // void InitFeatures_set_data_loss_protect_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28765 export function InitFeatures_set_data_loss_protect_optional(this_arg: bigint): void {
28766 if(!isWasmInitialized) {
28767 throw new Error("initializeWasm() must be awaited first!");
28769 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_optional(this_arg);
28770 // debug statements here
28772 // void InitFeatures_set_data_loss_protect_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28774 export function InitFeatures_set_data_loss_protect_required(this_arg: bigint): void {
28775 if(!isWasmInitialized) {
28776 throw new Error("initializeWasm() must be awaited first!");
28778 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_required(this_arg);
28779 // debug statements here
28781 // MUST_USE_RES bool InitFeatures_supports_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28783 export function InitFeatures_supports_data_loss_protect(this_arg: bigint): boolean {
28784 if(!isWasmInitialized) {
28785 throw new Error("initializeWasm() must be awaited first!");
28787 const nativeResponseValue = wasm.TS_InitFeatures_supports_data_loss_protect(this_arg);
28788 return nativeResponseValue;
28790 // void NodeFeatures_set_data_loss_protect_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28792 export function NodeFeatures_set_data_loss_protect_optional(this_arg: bigint): void {
28793 if(!isWasmInitialized) {
28794 throw new Error("initializeWasm() must be awaited first!");
28796 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_optional(this_arg);
28797 // debug statements here
28799 // void NodeFeatures_set_data_loss_protect_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28801 export function NodeFeatures_set_data_loss_protect_required(this_arg: bigint): void {
28802 if(!isWasmInitialized) {
28803 throw new Error("initializeWasm() must be awaited first!");
28805 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_required(this_arg);
28806 // debug statements here
28808 // MUST_USE_RES bool NodeFeatures_supports_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28810 export function NodeFeatures_supports_data_loss_protect(this_arg: bigint): boolean {
28811 if(!isWasmInitialized) {
28812 throw new Error("initializeWasm() must be awaited first!");
28814 const nativeResponseValue = wasm.TS_NodeFeatures_supports_data_loss_protect(this_arg);
28815 return nativeResponseValue;
28817 // MUST_USE_RES bool InitFeatures_requires_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28819 export function InitFeatures_requires_data_loss_protect(this_arg: bigint): boolean {
28820 if(!isWasmInitialized) {
28821 throw new Error("initializeWasm() must be awaited first!");
28823 const nativeResponseValue = wasm.TS_InitFeatures_requires_data_loss_protect(this_arg);
28824 return nativeResponseValue;
28826 // MUST_USE_RES bool NodeFeatures_requires_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28828 export function NodeFeatures_requires_data_loss_protect(this_arg: bigint): boolean {
28829 if(!isWasmInitialized) {
28830 throw new Error("initializeWasm() must be awaited first!");
28832 const nativeResponseValue = wasm.TS_NodeFeatures_requires_data_loss_protect(this_arg);
28833 return nativeResponseValue;
28835 // void InitFeatures_set_initial_routing_sync_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28837 export function InitFeatures_set_initial_routing_sync_optional(this_arg: bigint): void {
28838 if(!isWasmInitialized) {
28839 throw new Error("initializeWasm() must be awaited first!");
28841 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_optional(this_arg);
28842 // debug statements here
28844 // void InitFeatures_set_initial_routing_sync_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28846 export function InitFeatures_set_initial_routing_sync_required(this_arg: bigint): void {
28847 if(!isWasmInitialized) {
28848 throw new Error("initializeWasm() must be awaited first!");
28850 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_required(this_arg);
28851 // debug statements here
28853 // MUST_USE_RES bool InitFeatures_initial_routing_sync(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28855 export function InitFeatures_initial_routing_sync(this_arg: bigint): boolean {
28856 if(!isWasmInitialized) {
28857 throw new Error("initializeWasm() must be awaited first!");
28859 const nativeResponseValue = wasm.TS_InitFeatures_initial_routing_sync(this_arg);
28860 return nativeResponseValue;
28862 // void InitFeatures_set_upfront_shutdown_script_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28864 export function InitFeatures_set_upfront_shutdown_script_optional(this_arg: bigint): void {
28865 if(!isWasmInitialized) {
28866 throw new Error("initializeWasm() must be awaited first!");
28868 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_optional(this_arg);
28869 // debug statements here
28871 // void InitFeatures_set_upfront_shutdown_script_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28873 export function InitFeatures_set_upfront_shutdown_script_required(this_arg: bigint): void {
28874 if(!isWasmInitialized) {
28875 throw new Error("initializeWasm() must be awaited first!");
28877 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_required(this_arg);
28878 // debug statements here
28880 // MUST_USE_RES bool InitFeatures_supports_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28882 export function InitFeatures_supports_upfront_shutdown_script(this_arg: bigint): boolean {
28883 if(!isWasmInitialized) {
28884 throw new Error("initializeWasm() must be awaited first!");
28886 const nativeResponseValue = wasm.TS_InitFeatures_supports_upfront_shutdown_script(this_arg);
28887 return nativeResponseValue;
28889 // void NodeFeatures_set_upfront_shutdown_script_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28891 export function NodeFeatures_set_upfront_shutdown_script_optional(this_arg: bigint): void {
28892 if(!isWasmInitialized) {
28893 throw new Error("initializeWasm() must be awaited first!");
28895 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_optional(this_arg);
28896 // debug statements here
28898 // void NodeFeatures_set_upfront_shutdown_script_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28900 export function NodeFeatures_set_upfront_shutdown_script_required(this_arg: bigint): void {
28901 if(!isWasmInitialized) {
28902 throw new Error("initializeWasm() must be awaited first!");
28904 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_required(this_arg);
28905 // debug statements here
28907 // MUST_USE_RES bool NodeFeatures_supports_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28909 export function NodeFeatures_supports_upfront_shutdown_script(this_arg: bigint): boolean {
28910 if(!isWasmInitialized) {
28911 throw new Error("initializeWasm() must be awaited first!");
28913 const nativeResponseValue = wasm.TS_NodeFeatures_supports_upfront_shutdown_script(this_arg);
28914 return nativeResponseValue;
28916 // MUST_USE_RES bool InitFeatures_requires_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28918 export function InitFeatures_requires_upfront_shutdown_script(this_arg: bigint): boolean {
28919 if(!isWasmInitialized) {
28920 throw new Error("initializeWasm() must be awaited first!");
28922 const nativeResponseValue = wasm.TS_InitFeatures_requires_upfront_shutdown_script(this_arg);
28923 return nativeResponseValue;
28925 // MUST_USE_RES bool NodeFeatures_requires_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28927 export function NodeFeatures_requires_upfront_shutdown_script(this_arg: bigint): boolean {
28928 if(!isWasmInitialized) {
28929 throw new Error("initializeWasm() must be awaited first!");
28931 const nativeResponseValue = wasm.TS_NodeFeatures_requires_upfront_shutdown_script(this_arg);
28932 return nativeResponseValue;
28934 // void InitFeatures_set_gossip_queries_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28936 export function InitFeatures_set_gossip_queries_optional(this_arg: bigint): void {
28937 if(!isWasmInitialized) {
28938 throw new Error("initializeWasm() must be awaited first!");
28940 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_optional(this_arg);
28941 // debug statements here
28943 // void InitFeatures_set_gossip_queries_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28945 export function InitFeatures_set_gossip_queries_required(this_arg: bigint): void {
28946 if(!isWasmInitialized) {
28947 throw new Error("initializeWasm() must be awaited first!");
28949 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_required(this_arg);
28950 // debug statements here
28952 // MUST_USE_RES bool InitFeatures_supports_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28954 export function InitFeatures_supports_gossip_queries(this_arg: bigint): boolean {
28955 if(!isWasmInitialized) {
28956 throw new Error("initializeWasm() must be awaited first!");
28958 const nativeResponseValue = wasm.TS_InitFeatures_supports_gossip_queries(this_arg);
28959 return nativeResponseValue;
28961 // void NodeFeatures_set_gossip_queries_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28963 export function NodeFeatures_set_gossip_queries_optional(this_arg: bigint): void {
28964 if(!isWasmInitialized) {
28965 throw new Error("initializeWasm() must be awaited first!");
28967 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_optional(this_arg);
28968 // debug statements here
28970 // void NodeFeatures_set_gossip_queries_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28972 export function NodeFeatures_set_gossip_queries_required(this_arg: bigint): void {
28973 if(!isWasmInitialized) {
28974 throw new Error("initializeWasm() must be awaited first!");
28976 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_required(this_arg);
28977 // debug statements here
28979 // MUST_USE_RES bool NodeFeatures_supports_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28981 export function NodeFeatures_supports_gossip_queries(this_arg: bigint): boolean {
28982 if(!isWasmInitialized) {
28983 throw new Error("initializeWasm() must be awaited first!");
28985 const nativeResponseValue = wasm.TS_NodeFeatures_supports_gossip_queries(this_arg);
28986 return nativeResponseValue;
28988 // MUST_USE_RES bool InitFeatures_requires_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28990 export function InitFeatures_requires_gossip_queries(this_arg: bigint): boolean {
28991 if(!isWasmInitialized) {
28992 throw new Error("initializeWasm() must be awaited first!");
28994 const nativeResponseValue = wasm.TS_InitFeatures_requires_gossip_queries(this_arg);
28995 return nativeResponseValue;
28997 // MUST_USE_RES bool NodeFeatures_requires_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28999 export function NodeFeatures_requires_gossip_queries(this_arg: bigint): boolean {
29000 if(!isWasmInitialized) {
29001 throw new Error("initializeWasm() must be awaited first!");
29003 const nativeResponseValue = wasm.TS_NodeFeatures_requires_gossip_queries(this_arg);
29004 return nativeResponseValue;
29006 // void InitFeatures_set_variable_length_onion_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
29008 export function InitFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
29009 if(!isWasmInitialized) {
29010 throw new Error("initializeWasm() must be awaited first!");
29012 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_optional(this_arg);
29013 // debug statements here
29015 // void InitFeatures_set_variable_length_onion_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
29017 export function InitFeatures_set_variable_length_onion_required(this_arg: bigint): void {
29018 if(!isWasmInitialized) {
29019 throw new Error("initializeWasm() must be awaited first!");
29021 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_required(this_arg);
29022 // debug statements here
29024 // MUST_USE_RES bool InitFeatures_supports_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29026 export function InitFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
29027 if(!isWasmInitialized) {
29028 throw new Error("initializeWasm() must be awaited first!");
29030 const nativeResponseValue = wasm.TS_InitFeatures_supports_variable_length_onion(this_arg);
29031 return nativeResponseValue;
29033 // void NodeFeatures_set_variable_length_onion_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29035 export function NodeFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
29036 if(!isWasmInitialized) {
29037 throw new Error("initializeWasm() must be awaited first!");
29039 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_optional(this_arg);
29040 // debug statements here
29042 // void NodeFeatures_set_variable_length_onion_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29044 export function NodeFeatures_set_variable_length_onion_required(this_arg: bigint): void {
29045 if(!isWasmInitialized) {
29046 throw new Error("initializeWasm() must be awaited first!");
29048 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_required(this_arg);
29049 // debug statements here
29051 // MUST_USE_RES bool NodeFeatures_supports_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29053 export function NodeFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
29054 if(!isWasmInitialized) {
29055 throw new Error("initializeWasm() must be awaited first!");
29057 const nativeResponseValue = wasm.TS_NodeFeatures_supports_variable_length_onion(this_arg);
29058 return nativeResponseValue;
29060 // void InvoiceFeatures_set_variable_length_onion_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
29062 export function InvoiceFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
29063 if(!isWasmInitialized) {
29064 throw new Error("initializeWasm() must be awaited first!");
29066 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_variable_length_onion_optional(this_arg);
29067 // debug statements here
29069 // void InvoiceFeatures_set_variable_length_onion_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
29071 export function InvoiceFeatures_set_variable_length_onion_required(this_arg: bigint): void {
29072 if(!isWasmInitialized) {
29073 throw new Error("initializeWasm() must be awaited first!");
29075 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_variable_length_onion_required(this_arg);
29076 // debug statements here
29078 // MUST_USE_RES bool InvoiceFeatures_supports_variable_length_onion(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
29080 export function InvoiceFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
29081 if(!isWasmInitialized) {
29082 throw new Error("initializeWasm() must be awaited first!");
29084 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_variable_length_onion(this_arg);
29085 return nativeResponseValue;
29087 // MUST_USE_RES bool InitFeatures_requires_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29089 export function InitFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
29090 if(!isWasmInitialized) {
29091 throw new Error("initializeWasm() must be awaited first!");
29093 const nativeResponseValue = wasm.TS_InitFeatures_requires_variable_length_onion(this_arg);
29094 return nativeResponseValue;
29096 // MUST_USE_RES bool NodeFeatures_requires_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29098 export function NodeFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
29099 if(!isWasmInitialized) {
29100 throw new Error("initializeWasm() must be awaited first!");
29102 const nativeResponseValue = wasm.TS_NodeFeatures_requires_variable_length_onion(this_arg);
29103 return nativeResponseValue;
29105 // MUST_USE_RES bool InvoiceFeatures_requires_variable_length_onion(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
29107 export function InvoiceFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
29108 if(!isWasmInitialized) {
29109 throw new Error("initializeWasm() must be awaited first!");
29111 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_variable_length_onion(this_arg);
29112 return nativeResponseValue;
29114 // void InitFeatures_set_static_remote_key_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
29116 export function InitFeatures_set_static_remote_key_optional(this_arg: bigint): void {
29117 if(!isWasmInitialized) {
29118 throw new Error("initializeWasm() must be awaited first!");
29120 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_optional(this_arg);
29121 // debug statements here
29123 // void InitFeatures_set_static_remote_key_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
29125 export function InitFeatures_set_static_remote_key_required(this_arg: bigint): void {
29126 if(!isWasmInitialized) {
29127 throw new Error("initializeWasm() must be awaited first!");
29129 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_required(this_arg);
29130 // debug statements here
29132 // MUST_USE_RES bool InitFeatures_supports_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29134 export function InitFeatures_supports_static_remote_key(this_arg: bigint): boolean {
29135 if(!isWasmInitialized) {
29136 throw new Error("initializeWasm() must be awaited first!");
29138 const nativeResponseValue = wasm.TS_InitFeatures_supports_static_remote_key(this_arg);
29139 return nativeResponseValue;
29141 // void NodeFeatures_set_static_remote_key_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29143 export function NodeFeatures_set_static_remote_key_optional(this_arg: bigint): void {
29144 if(!isWasmInitialized) {
29145 throw new Error("initializeWasm() must be awaited first!");
29147 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_optional(this_arg);
29148 // debug statements here
29150 // void NodeFeatures_set_static_remote_key_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29152 export function NodeFeatures_set_static_remote_key_required(this_arg: bigint): void {
29153 if(!isWasmInitialized) {
29154 throw new Error("initializeWasm() must be awaited first!");
29156 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_required(this_arg);
29157 // debug statements here
29159 // MUST_USE_RES bool NodeFeatures_supports_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29161 export function NodeFeatures_supports_static_remote_key(this_arg: bigint): boolean {
29162 if(!isWasmInitialized) {
29163 throw new Error("initializeWasm() must be awaited first!");
29165 const nativeResponseValue = wasm.TS_NodeFeatures_supports_static_remote_key(this_arg);
29166 return nativeResponseValue;
29168 // void ChannelTypeFeatures_set_static_remote_key_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
29170 export function ChannelTypeFeatures_set_static_remote_key_optional(this_arg: bigint): void {
29171 if(!isWasmInitialized) {
29172 throw new Error("initializeWasm() must be awaited first!");
29174 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_optional(this_arg);
29175 // debug statements here
29177 // void ChannelTypeFeatures_set_static_remote_key_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
29179 export function ChannelTypeFeatures_set_static_remote_key_required(this_arg: bigint): void {
29180 if(!isWasmInitialized) {
29181 throw new Error("initializeWasm() must be awaited first!");
29183 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_required(this_arg);
29184 // debug statements here
29186 // MUST_USE_RES bool ChannelTypeFeatures_supports_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
29188 export function ChannelTypeFeatures_supports_static_remote_key(this_arg: bigint): boolean {
29189 if(!isWasmInitialized) {
29190 throw new Error("initializeWasm() must be awaited first!");
29192 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_static_remote_key(this_arg);
29193 return nativeResponseValue;
29195 // MUST_USE_RES bool InitFeatures_requires_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29197 export function InitFeatures_requires_static_remote_key(this_arg: bigint): boolean {
29198 if(!isWasmInitialized) {
29199 throw new Error("initializeWasm() must be awaited first!");
29201 const nativeResponseValue = wasm.TS_InitFeatures_requires_static_remote_key(this_arg);
29202 return nativeResponseValue;
29204 // MUST_USE_RES bool NodeFeatures_requires_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29206 export function NodeFeatures_requires_static_remote_key(this_arg: bigint): boolean {
29207 if(!isWasmInitialized) {
29208 throw new Error("initializeWasm() must be awaited first!");
29210 const nativeResponseValue = wasm.TS_NodeFeatures_requires_static_remote_key(this_arg);
29211 return nativeResponseValue;
29213 // MUST_USE_RES bool ChannelTypeFeatures_requires_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
29215 export function ChannelTypeFeatures_requires_static_remote_key(this_arg: bigint): boolean {
29216 if(!isWasmInitialized) {
29217 throw new Error("initializeWasm() must be awaited first!");
29219 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_static_remote_key(this_arg);
29220 return nativeResponseValue;
29222 // void InitFeatures_set_payment_secret_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
29224 export function InitFeatures_set_payment_secret_optional(this_arg: bigint): void {
29225 if(!isWasmInitialized) {
29226 throw new Error("initializeWasm() must be awaited first!");
29228 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_optional(this_arg);
29229 // debug statements here
29231 // void InitFeatures_set_payment_secret_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
29233 export function InitFeatures_set_payment_secret_required(this_arg: bigint): void {
29234 if(!isWasmInitialized) {
29235 throw new Error("initializeWasm() must be awaited first!");
29237 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_required(this_arg);
29238 // debug statements here
29240 // MUST_USE_RES bool InitFeatures_supports_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29242 export function InitFeatures_supports_payment_secret(this_arg: bigint): boolean {
29243 if(!isWasmInitialized) {
29244 throw new Error("initializeWasm() must be awaited first!");
29246 const nativeResponseValue = wasm.TS_InitFeatures_supports_payment_secret(this_arg);
29247 return nativeResponseValue;
29249 // void NodeFeatures_set_payment_secret_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29251 export function NodeFeatures_set_payment_secret_optional(this_arg: bigint): void {
29252 if(!isWasmInitialized) {
29253 throw new Error("initializeWasm() must be awaited first!");
29255 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_optional(this_arg);
29256 // debug statements here
29258 // void NodeFeatures_set_payment_secret_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29260 export function NodeFeatures_set_payment_secret_required(this_arg: bigint): void {
29261 if(!isWasmInitialized) {
29262 throw new Error("initializeWasm() must be awaited first!");
29264 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_required(this_arg);
29265 // debug statements here
29267 // MUST_USE_RES bool NodeFeatures_supports_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29269 export function NodeFeatures_supports_payment_secret(this_arg: bigint): boolean {
29270 if(!isWasmInitialized) {
29271 throw new Error("initializeWasm() must be awaited first!");
29273 const nativeResponseValue = wasm.TS_NodeFeatures_supports_payment_secret(this_arg);
29274 return nativeResponseValue;
29276 // void InvoiceFeatures_set_payment_secret_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
29278 export function InvoiceFeatures_set_payment_secret_optional(this_arg: bigint): void {
29279 if(!isWasmInitialized) {
29280 throw new Error("initializeWasm() must be awaited first!");
29282 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_payment_secret_optional(this_arg);
29283 // debug statements here
29285 // void InvoiceFeatures_set_payment_secret_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
29287 export function InvoiceFeatures_set_payment_secret_required(this_arg: bigint): void {
29288 if(!isWasmInitialized) {
29289 throw new Error("initializeWasm() must be awaited first!");
29291 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_payment_secret_required(this_arg);
29292 // debug statements here
29294 // MUST_USE_RES bool InvoiceFeatures_supports_payment_secret(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
29296 export function InvoiceFeatures_supports_payment_secret(this_arg: bigint): boolean {
29297 if(!isWasmInitialized) {
29298 throw new Error("initializeWasm() must be awaited first!");
29300 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_payment_secret(this_arg);
29301 return nativeResponseValue;
29303 // MUST_USE_RES bool InitFeatures_requires_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29305 export function InitFeatures_requires_payment_secret(this_arg: bigint): boolean {
29306 if(!isWasmInitialized) {
29307 throw new Error("initializeWasm() must be awaited first!");
29309 const nativeResponseValue = wasm.TS_InitFeatures_requires_payment_secret(this_arg);
29310 return nativeResponseValue;
29312 // MUST_USE_RES bool NodeFeatures_requires_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29314 export function NodeFeatures_requires_payment_secret(this_arg: bigint): boolean {
29315 if(!isWasmInitialized) {
29316 throw new Error("initializeWasm() must be awaited first!");
29318 const nativeResponseValue = wasm.TS_NodeFeatures_requires_payment_secret(this_arg);
29319 return nativeResponseValue;
29321 // MUST_USE_RES bool InvoiceFeatures_requires_payment_secret(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
29323 export function InvoiceFeatures_requires_payment_secret(this_arg: bigint): boolean {
29324 if(!isWasmInitialized) {
29325 throw new Error("initializeWasm() must be awaited first!");
29327 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_payment_secret(this_arg);
29328 return nativeResponseValue;
29330 // void InitFeatures_set_basic_mpp_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
29332 export function InitFeatures_set_basic_mpp_optional(this_arg: bigint): void {
29333 if(!isWasmInitialized) {
29334 throw new Error("initializeWasm() must be awaited first!");
29336 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_optional(this_arg);
29337 // debug statements here
29339 // void InitFeatures_set_basic_mpp_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
29341 export function InitFeatures_set_basic_mpp_required(this_arg: bigint): void {
29342 if(!isWasmInitialized) {
29343 throw new Error("initializeWasm() must be awaited first!");
29345 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_required(this_arg);
29346 // debug statements here
29348 // MUST_USE_RES bool InitFeatures_supports_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29350 export function InitFeatures_supports_basic_mpp(this_arg: bigint): boolean {
29351 if(!isWasmInitialized) {
29352 throw new Error("initializeWasm() must be awaited first!");
29354 const nativeResponseValue = wasm.TS_InitFeatures_supports_basic_mpp(this_arg);
29355 return nativeResponseValue;
29357 // void NodeFeatures_set_basic_mpp_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29359 export function NodeFeatures_set_basic_mpp_optional(this_arg: bigint): void {
29360 if(!isWasmInitialized) {
29361 throw new Error("initializeWasm() must be awaited first!");
29363 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_optional(this_arg);
29364 // debug statements here
29366 // void NodeFeatures_set_basic_mpp_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29368 export function NodeFeatures_set_basic_mpp_required(this_arg: bigint): void {
29369 if(!isWasmInitialized) {
29370 throw new Error("initializeWasm() must be awaited first!");
29372 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_required(this_arg);
29373 // debug statements here
29375 // MUST_USE_RES bool NodeFeatures_supports_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29377 export function NodeFeatures_supports_basic_mpp(this_arg: bigint): boolean {
29378 if(!isWasmInitialized) {
29379 throw new Error("initializeWasm() must be awaited first!");
29381 const nativeResponseValue = wasm.TS_NodeFeatures_supports_basic_mpp(this_arg);
29382 return nativeResponseValue;
29384 // void InvoiceFeatures_set_basic_mpp_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
29386 export function InvoiceFeatures_set_basic_mpp_optional(this_arg: bigint): void {
29387 if(!isWasmInitialized) {
29388 throw new Error("initializeWasm() must be awaited first!");
29390 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_basic_mpp_optional(this_arg);
29391 // debug statements here
29393 // void InvoiceFeatures_set_basic_mpp_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
29395 export function InvoiceFeatures_set_basic_mpp_required(this_arg: bigint): void {
29396 if(!isWasmInitialized) {
29397 throw new Error("initializeWasm() must be awaited first!");
29399 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_basic_mpp_required(this_arg);
29400 // debug statements here
29402 // MUST_USE_RES bool InvoiceFeatures_supports_basic_mpp(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
29404 export function InvoiceFeatures_supports_basic_mpp(this_arg: bigint): boolean {
29405 if(!isWasmInitialized) {
29406 throw new Error("initializeWasm() must be awaited first!");
29408 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_basic_mpp(this_arg);
29409 return nativeResponseValue;
29411 // MUST_USE_RES bool InitFeatures_requires_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29413 export function InitFeatures_requires_basic_mpp(this_arg: bigint): boolean {
29414 if(!isWasmInitialized) {
29415 throw new Error("initializeWasm() must be awaited first!");
29417 const nativeResponseValue = wasm.TS_InitFeatures_requires_basic_mpp(this_arg);
29418 return nativeResponseValue;
29420 // MUST_USE_RES bool NodeFeatures_requires_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29422 export function NodeFeatures_requires_basic_mpp(this_arg: bigint): boolean {
29423 if(!isWasmInitialized) {
29424 throw new Error("initializeWasm() must be awaited first!");
29426 const nativeResponseValue = wasm.TS_NodeFeatures_requires_basic_mpp(this_arg);
29427 return nativeResponseValue;
29429 // MUST_USE_RES bool InvoiceFeatures_requires_basic_mpp(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
29431 export function InvoiceFeatures_requires_basic_mpp(this_arg: bigint): boolean {
29432 if(!isWasmInitialized) {
29433 throw new Error("initializeWasm() must be awaited first!");
29435 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_basic_mpp(this_arg);
29436 return nativeResponseValue;
29438 // void InitFeatures_set_wumbo_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
29440 export function InitFeatures_set_wumbo_optional(this_arg: bigint): void {
29441 if(!isWasmInitialized) {
29442 throw new Error("initializeWasm() must be awaited first!");
29444 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_optional(this_arg);
29445 // debug statements here
29447 // void InitFeatures_set_wumbo_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
29449 export function InitFeatures_set_wumbo_required(this_arg: bigint): void {
29450 if(!isWasmInitialized) {
29451 throw new Error("initializeWasm() must be awaited first!");
29453 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_required(this_arg);
29454 // debug statements here
29456 // MUST_USE_RES bool InitFeatures_supports_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29458 export function InitFeatures_supports_wumbo(this_arg: bigint): boolean {
29459 if(!isWasmInitialized) {
29460 throw new Error("initializeWasm() must be awaited first!");
29462 const nativeResponseValue = wasm.TS_InitFeatures_supports_wumbo(this_arg);
29463 return nativeResponseValue;
29465 // void NodeFeatures_set_wumbo_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29467 export function NodeFeatures_set_wumbo_optional(this_arg: bigint): void {
29468 if(!isWasmInitialized) {
29469 throw new Error("initializeWasm() must be awaited first!");
29471 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_optional(this_arg);
29472 // debug statements here
29474 // void NodeFeatures_set_wumbo_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29476 export function NodeFeatures_set_wumbo_required(this_arg: bigint): void {
29477 if(!isWasmInitialized) {
29478 throw new Error("initializeWasm() must be awaited first!");
29480 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_required(this_arg);
29481 // debug statements here
29483 // MUST_USE_RES bool NodeFeatures_supports_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29485 export function NodeFeatures_supports_wumbo(this_arg: bigint): boolean {
29486 if(!isWasmInitialized) {
29487 throw new Error("initializeWasm() must be awaited first!");
29489 const nativeResponseValue = wasm.TS_NodeFeatures_supports_wumbo(this_arg);
29490 return nativeResponseValue;
29492 // MUST_USE_RES bool InitFeatures_requires_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29494 export function InitFeatures_requires_wumbo(this_arg: bigint): boolean {
29495 if(!isWasmInitialized) {
29496 throw new Error("initializeWasm() must be awaited first!");
29498 const nativeResponseValue = wasm.TS_InitFeatures_requires_wumbo(this_arg);
29499 return nativeResponseValue;
29501 // MUST_USE_RES bool NodeFeatures_requires_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29503 export function NodeFeatures_requires_wumbo(this_arg: bigint): boolean {
29504 if(!isWasmInitialized) {
29505 throw new Error("initializeWasm() must be awaited first!");
29507 const nativeResponseValue = wasm.TS_NodeFeatures_requires_wumbo(this_arg);
29508 return nativeResponseValue;
29510 // void InitFeatures_set_shutdown_any_segwit_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
29512 export function InitFeatures_set_shutdown_any_segwit_optional(this_arg: bigint): void {
29513 if(!isWasmInitialized) {
29514 throw new Error("initializeWasm() must be awaited first!");
29516 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_optional(this_arg);
29517 // debug statements here
29519 // void InitFeatures_set_shutdown_any_segwit_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
29521 export function InitFeatures_set_shutdown_any_segwit_required(this_arg: bigint): void {
29522 if(!isWasmInitialized) {
29523 throw new Error("initializeWasm() must be awaited first!");
29525 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_required(this_arg);
29526 // debug statements here
29528 // MUST_USE_RES bool InitFeatures_supports_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29530 export function InitFeatures_supports_shutdown_anysegwit(this_arg: bigint): boolean {
29531 if(!isWasmInitialized) {
29532 throw new Error("initializeWasm() must be awaited first!");
29534 const nativeResponseValue = wasm.TS_InitFeatures_supports_shutdown_anysegwit(this_arg);
29535 return nativeResponseValue;
29537 // void NodeFeatures_set_shutdown_any_segwit_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29539 export function NodeFeatures_set_shutdown_any_segwit_optional(this_arg: bigint): void {
29540 if(!isWasmInitialized) {
29541 throw new Error("initializeWasm() must be awaited first!");
29543 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_optional(this_arg);
29544 // debug statements here
29546 // void NodeFeatures_set_shutdown_any_segwit_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29548 export function NodeFeatures_set_shutdown_any_segwit_required(this_arg: bigint): void {
29549 if(!isWasmInitialized) {
29550 throw new Error("initializeWasm() must be awaited first!");
29552 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_required(this_arg);
29553 // debug statements here
29555 // MUST_USE_RES bool NodeFeatures_supports_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29557 export function NodeFeatures_supports_shutdown_anysegwit(this_arg: bigint): boolean {
29558 if(!isWasmInitialized) {
29559 throw new Error("initializeWasm() must be awaited first!");
29561 const nativeResponseValue = wasm.TS_NodeFeatures_supports_shutdown_anysegwit(this_arg);
29562 return nativeResponseValue;
29564 // MUST_USE_RES bool InitFeatures_requires_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29566 export function InitFeatures_requires_shutdown_anysegwit(this_arg: bigint): boolean {
29567 if(!isWasmInitialized) {
29568 throw new Error("initializeWasm() must be awaited first!");
29570 const nativeResponseValue = wasm.TS_InitFeatures_requires_shutdown_anysegwit(this_arg);
29571 return nativeResponseValue;
29573 // MUST_USE_RES bool NodeFeatures_requires_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29575 export function NodeFeatures_requires_shutdown_anysegwit(this_arg: bigint): boolean {
29576 if(!isWasmInitialized) {
29577 throw new Error("initializeWasm() must be awaited first!");
29579 const nativeResponseValue = wasm.TS_NodeFeatures_requires_shutdown_anysegwit(this_arg);
29580 return nativeResponseValue;
29582 // void InitFeatures_set_onion_messages_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
29584 export function InitFeatures_set_onion_messages_optional(this_arg: bigint): void {
29585 if(!isWasmInitialized) {
29586 throw new Error("initializeWasm() must be awaited first!");
29588 const nativeResponseValue = wasm.TS_InitFeatures_set_onion_messages_optional(this_arg);
29589 // debug statements here
29591 // void InitFeatures_set_onion_messages_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
29593 export function InitFeatures_set_onion_messages_required(this_arg: bigint): void {
29594 if(!isWasmInitialized) {
29595 throw new Error("initializeWasm() must be awaited first!");
29597 const nativeResponseValue = wasm.TS_InitFeatures_set_onion_messages_required(this_arg);
29598 // debug statements here
29600 // MUST_USE_RES bool InitFeatures_supports_onion_messages(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29602 export function InitFeatures_supports_onion_messages(this_arg: bigint): boolean {
29603 if(!isWasmInitialized) {
29604 throw new Error("initializeWasm() must be awaited first!");
29606 const nativeResponseValue = wasm.TS_InitFeatures_supports_onion_messages(this_arg);
29607 return nativeResponseValue;
29609 // void NodeFeatures_set_onion_messages_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29611 export function NodeFeatures_set_onion_messages_optional(this_arg: bigint): void {
29612 if(!isWasmInitialized) {
29613 throw new Error("initializeWasm() must be awaited first!");
29615 const nativeResponseValue = wasm.TS_NodeFeatures_set_onion_messages_optional(this_arg);
29616 // debug statements here
29618 // void NodeFeatures_set_onion_messages_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29620 export function NodeFeatures_set_onion_messages_required(this_arg: bigint): void {
29621 if(!isWasmInitialized) {
29622 throw new Error("initializeWasm() must be awaited first!");
29624 const nativeResponseValue = wasm.TS_NodeFeatures_set_onion_messages_required(this_arg);
29625 // debug statements here
29627 // MUST_USE_RES bool NodeFeatures_supports_onion_messages(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29629 export function NodeFeatures_supports_onion_messages(this_arg: bigint): boolean {
29630 if(!isWasmInitialized) {
29631 throw new Error("initializeWasm() must be awaited first!");
29633 const nativeResponseValue = wasm.TS_NodeFeatures_supports_onion_messages(this_arg);
29634 return nativeResponseValue;
29636 // MUST_USE_RES bool InitFeatures_requires_onion_messages(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29638 export function InitFeatures_requires_onion_messages(this_arg: bigint): boolean {
29639 if(!isWasmInitialized) {
29640 throw new Error("initializeWasm() must be awaited first!");
29642 const nativeResponseValue = wasm.TS_InitFeatures_requires_onion_messages(this_arg);
29643 return nativeResponseValue;
29645 // MUST_USE_RES bool NodeFeatures_requires_onion_messages(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29647 export function NodeFeatures_requires_onion_messages(this_arg: bigint): boolean {
29648 if(!isWasmInitialized) {
29649 throw new Error("initializeWasm() must be awaited first!");
29651 const nativeResponseValue = wasm.TS_NodeFeatures_requires_onion_messages(this_arg);
29652 return nativeResponseValue;
29654 // void InitFeatures_set_channel_type_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
29656 export function InitFeatures_set_channel_type_optional(this_arg: bigint): void {
29657 if(!isWasmInitialized) {
29658 throw new Error("initializeWasm() must be awaited first!");
29660 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_optional(this_arg);
29661 // debug statements here
29663 // void InitFeatures_set_channel_type_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
29665 export function InitFeatures_set_channel_type_required(this_arg: bigint): void {
29666 if(!isWasmInitialized) {
29667 throw new Error("initializeWasm() must be awaited first!");
29669 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_required(this_arg);
29670 // debug statements here
29672 // MUST_USE_RES bool InitFeatures_supports_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29674 export function InitFeatures_supports_channel_type(this_arg: bigint): boolean {
29675 if(!isWasmInitialized) {
29676 throw new Error("initializeWasm() must be awaited first!");
29678 const nativeResponseValue = wasm.TS_InitFeatures_supports_channel_type(this_arg);
29679 return nativeResponseValue;
29681 // void NodeFeatures_set_channel_type_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29683 export function NodeFeatures_set_channel_type_optional(this_arg: bigint): void {
29684 if(!isWasmInitialized) {
29685 throw new Error("initializeWasm() must be awaited first!");
29687 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_optional(this_arg);
29688 // debug statements here
29690 // void NodeFeatures_set_channel_type_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29692 export function NodeFeatures_set_channel_type_required(this_arg: bigint): void {
29693 if(!isWasmInitialized) {
29694 throw new Error("initializeWasm() must be awaited first!");
29696 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_required(this_arg);
29697 // debug statements here
29699 // MUST_USE_RES bool NodeFeatures_supports_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29701 export function NodeFeatures_supports_channel_type(this_arg: bigint): boolean {
29702 if(!isWasmInitialized) {
29703 throw new Error("initializeWasm() must be awaited first!");
29705 const nativeResponseValue = wasm.TS_NodeFeatures_supports_channel_type(this_arg);
29706 return nativeResponseValue;
29708 // MUST_USE_RES bool InitFeatures_requires_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29710 export function InitFeatures_requires_channel_type(this_arg: bigint): boolean {
29711 if(!isWasmInitialized) {
29712 throw new Error("initializeWasm() must be awaited first!");
29714 const nativeResponseValue = wasm.TS_InitFeatures_requires_channel_type(this_arg);
29715 return nativeResponseValue;
29717 // MUST_USE_RES bool NodeFeatures_requires_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29719 export function NodeFeatures_requires_channel_type(this_arg: bigint): boolean {
29720 if(!isWasmInitialized) {
29721 throw new Error("initializeWasm() must be awaited first!");
29723 const nativeResponseValue = wasm.TS_NodeFeatures_requires_channel_type(this_arg);
29724 return nativeResponseValue;
29726 // void InitFeatures_set_scid_privacy_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
29728 export function InitFeatures_set_scid_privacy_optional(this_arg: bigint): void {
29729 if(!isWasmInitialized) {
29730 throw new Error("initializeWasm() must be awaited first!");
29732 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_optional(this_arg);
29733 // debug statements here
29735 // void InitFeatures_set_scid_privacy_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
29737 export function InitFeatures_set_scid_privacy_required(this_arg: bigint): void {
29738 if(!isWasmInitialized) {
29739 throw new Error("initializeWasm() must be awaited first!");
29741 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_required(this_arg);
29742 // debug statements here
29744 // MUST_USE_RES bool InitFeatures_supports_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29746 export function InitFeatures_supports_scid_privacy(this_arg: bigint): boolean {
29747 if(!isWasmInitialized) {
29748 throw new Error("initializeWasm() must be awaited first!");
29750 const nativeResponseValue = wasm.TS_InitFeatures_supports_scid_privacy(this_arg);
29751 return nativeResponseValue;
29753 // void NodeFeatures_set_scid_privacy_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29755 export function NodeFeatures_set_scid_privacy_optional(this_arg: bigint): void {
29756 if(!isWasmInitialized) {
29757 throw new Error("initializeWasm() must be awaited first!");
29759 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_optional(this_arg);
29760 // debug statements here
29762 // void NodeFeatures_set_scid_privacy_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29764 export function NodeFeatures_set_scid_privacy_required(this_arg: bigint): void {
29765 if(!isWasmInitialized) {
29766 throw new Error("initializeWasm() must be awaited first!");
29768 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_required(this_arg);
29769 // debug statements here
29771 // MUST_USE_RES bool NodeFeatures_supports_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29773 export function NodeFeatures_supports_scid_privacy(this_arg: bigint): boolean {
29774 if(!isWasmInitialized) {
29775 throw new Error("initializeWasm() must be awaited first!");
29777 const nativeResponseValue = wasm.TS_NodeFeatures_supports_scid_privacy(this_arg);
29778 return nativeResponseValue;
29780 // void ChannelTypeFeatures_set_scid_privacy_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
29782 export function ChannelTypeFeatures_set_scid_privacy_optional(this_arg: bigint): void {
29783 if(!isWasmInitialized) {
29784 throw new Error("initializeWasm() must be awaited first!");
29786 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_optional(this_arg);
29787 // debug statements here
29789 // void ChannelTypeFeatures_set_scid_privacy_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
29791 export function ChannelTypeFeatures_set_scid_privacy_required(this_arg: bigint): void {
29792 if(!isWasmInitialized) {
29793 throw new Error("initializeWasm() must be awaited first!");
29795 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_required(this_arg);
29796 // debug statements here
29798 // MUST_USE_RES bool ChannelTypeFeatures_supports_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
29800 export function ChannelTypeFeatures_supports_scid_privacy(this_arg: bigint): boolean {
29801 if(!isWasmInitialized) {
29802 throw new Error("initializeWasm() must be awaited first!");
29804 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_scid_privacy(this_arg);
29805 return nativeResponseValue;
29807 // MUST_USE_RES bool InitFeatures_requires_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29809 export function InitFeatures_requires_scid_privacy(this_arg: bigint): boolean {
29810 if(!isWasmInitialized) {
29811 throw new Error("initializeWasm() must be awaited first!");
29813 const nativeResponseValue = wasm.TS_InitFeatures_requires_scid_privacy(this_arg);
29814 return nativeResponseValue;
29816 // MUST_USE_RES bool NodeFeatures_requires_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29818 export function NodeFeatures_requires_scid_privacy(this_arg: bigint): boolean {
29819 if(!isWasmInitialized) {
29820 throw new Error("initializeWasm() must be awaited first!");
29822 const nativeResponseValue = wasm.TS_NodeFeatures_requires_scid_privacy(this_arg);
29823 return nativeResponseValue;
29825 // MUST_USE_RES bool ChannelTypeFeatures_requires_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
29827 export function ChannelTypeFeatures_requires_scid_privacy(this_arg: bigint): boolean {
29828 if(!isWasmInitialized) {
29829 throw new Error("initializeWasm() must be awaited first!");
29831 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_scid_privacy(this_arg);
29832 return nativeResponseValue;
29834 // void InitFeatures_set_zero_conf_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
29836 export function InitFeatures_set_zero_conf_optional(this_arg: bigint): void {
29837 if(!isWasmInitialized) {
29838 throw new Error("initializeWasm() must be awaited first!");
29840 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_optional(this_arg);
29841 // debug statements here
29843 // void InitFeatures_set_zero_conf_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
29845 export function InitFeatures_set_zero_conf_required(this_arg: bigint): void {
29846 if(!isWasmInitialized) {
29847 throw new Error("initializeWasm() must be awaited first!");
29849 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_required(this_arg);
29850 // debug statements here
29852 // MUST_USE_RES bool InitFeatures_supports_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29854 export function InitFeatures_supports_zero_conf(this_arg: bigint): boolean {
29855 if(!isWasmInitialized) {
29856 throw new Error("initializeWasm() must be awaited first!");
29858 const nativeResponseValue = wasm.TS_InitFeatures_supports_zero_conf(this_arg);
29859 return nativeResponseValue;
29861 // void NodeFeatures_set_zero_conf_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29863 export function NodeFeatures_set_zero_conf_optional(this_arg: bigint): void {
29864 if(!isWasmInitialized) {
29865 throw new Error("initializeWasm() must be awaited first!");
29867 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_optional(this_arg);
29868 // debug statements here
29870 // void NodeFeatures_set_zero_conf_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29872 export function NodeFeatures_set_zero_conf_required(this_arg: bigint): void {
29873 if(!isWasmInitialized) {
29874 throw new Error("initializeWasm() must be awaited first!");
29876 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_required(this_arg);
29877 // debug statements here
29879 // MUST_USE_RES bool NodeFeatures_supports_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29881 export function NodeFeatures_supports_zero_conf(this_arg: bigint): boolean {
29882 if(!isWasmInitialized) {
29883 throw new Error("initializeWasm() must be awaited first!");
29885 const nativeResponseValue = wasm.TS_NodeFeatures_supports_zero_conf(this_arg);
29886 return nativeResponseValue;
29888 // void ChannelTypeFeatures_set_zero_conf_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
29890 export function ChannelTypeFeatures_set_zero_conf_optional(this_arg: bigint): void {
29891 if(!isWasmInitialized) {
29892 throw new Error("initializeWasm() must be awaited first!");
29894 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_optional(this_arg);
29895 // debug statements here
29897 // void ChannelTypeFeatures_set_zero_conf_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
29899 export function ChannelTypeFeatures_set_zero_conf_required(this_arg: bigint): void {
29900 if(!isWasmInitialized) {
29901 throw new Error("initializeWasm() must be awaited first!");
29903 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_required(this_arg);
29904 // debug statements here
29906 // MUST_USE_RES bool ChannelTypeFeatures_supports_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
29908 export function ChannelTypeFeatures_supports_zero_conf(this_arg: bigint): boolean {
29909 if(!isWasmInitialized) {
29910 throw new Error("initializeWasm() must be awaited first!");
29912 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_zero_conf(this_arg);
29913 return nativeResponseValue;
29915 // MUST_USE_RES bool InitFeatures_requires_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29917 export function InitFeatures_requires_zero_conf(this_arg: bigint): boolean {
29918 if(!isWasmInitialized) {
29919 throw new Error("initializeWasm() must be awaited first!");
29921 const nativeResponseValue = wasm.TS_InitFeatures_requires_zero_conf(this_arg);
29922 return nativeResponseValue;
29924 // MUST_USE_RES bool NodeFeatures_requires_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29926 export function NodeFeatures_requires_zero_conf(this_arg: bigint): boolean {
29927 if(!isWasmInitialized) {
29928 throw new Error("initializeWasm() must be awaited first!");
29930 const nativeResponseValue = wasm.TS_NodeFeatures_requires_zero_conf(this_arg);
29931 return nativeResponseValue;
29933 // MUST_USE_RES bool ChannelTypeFeatures_requires_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
29935 export function ChannelTypeFeatures_requires_zero_conf(this_arg: bigint): boolean {
29936 if(!isWasmInitialized) {
29937 throw new Error("initializeWasm() must be awaited first!");
29939 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_zero_conf(this_arg);
29940 return nativeResponseValue;
29942 // void NodeFeatures_set_keysend_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29944 export function NodeFeatures_set_keysend_optional(this_arg: bigint): void {
29945 if(!isWasmInitialized) {
29946 throw new Error("initializeWasm() must be awaited first!");
29948 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_optional(this_arg);
29949 // debug statements here
29951 // void NodeFeatures_set_keysend_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29953 export function NodeFeatures_set_keysend_required(this_arg: bigint): void {
29954 if(!isWasmInitialized) {
29955 throw new Error("initializeWasm() must be awaited first!");
29957 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_required(this_arg);
29958 // debug statements here
29960 // MUST_USE_RES bool NodeFeatures_supports_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29962 export function NodeFeatures_supports_keysend(this_arg: bigint): boolean {
29963 if(!isWasmInitialized) {
29964 throw new Error("initializeWasm() must be awaited first!");
29966 const nativeResponseValue = wasm.TS_NodeFeatures_supports_keysend(this_arg);
29967 return nativeResponseValue;
29969 // MUST_USE_RES bool NodeFeatures_requires_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29971 export function NodeFeatures_requires_keysend(this_arg: bigint): boolean {
29972 if(!isWasmInitialized) {
29973 throw new Error("initializeWasm() must be awaited first!");
29975 const nativeResponseValue = wasm.TS_NodeFeatures_requires_keysend(this_arg);
29976 return nativeResponseValue;
29978 // void ShutdownScript_free(struct LDKShutdownScript this_obj);
29980 export function ShutdownScript_free(this_obj: bigint): void {
29981 if(!isWasmInitialized) {
29982 throw new Error("initializeWasm() must be awaited first!");
29984 const nativeResponseValue = wasm.TS_ShutdownScript_free(this_obj);
29985 // debug statements here
29987 // uint64_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg);
29989 export function ShutdownScript_clone_ptr(arg: bigint): bigint {
29990 if(!isWasmInitialized) {
29991 throw new Error("initializeWasm() must be awaited first!");
29993 const nativeResponseValue = wasm.TS_ShutdownScript_clone_ptr(arg);
29994 return nativeResponseValue;
29996 // struct LDKShutdownScript ShutdownScript_clone(const struct LDKShutdownScript *NONNULL_PTR orig);
29998 export function ShutdownScript_clone(orig: bigint): bigint {
29999 if(!isWasmInitialized) {
30000 throw new Error("initializeWasm() must be awaited first!");
30002 const nativeResponseValue = wasm.TS_ShutdownScript_clone(orig);
30003 return nativeResponseValue;
30005 // void InvalidShutdownScript_free(struct LDKInvalidShutdownScript this_obj);
30007 export function InvalidShutdownScript_free(this_obj: bigint): void {
30008 if(!isWasmInitialized) {
30009 throw new Error("initializeWasm() must be awaited first!");
30011 const nativeResponseValue = wasm.TS_InvalidShutdownScript_free(this_obj);
30012 // debug statements here
30014 // struct LDKu8slice InvalidShutdownScript_get_script(const struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr);
30016 export function InvalidShutdownScript_get_script(this_ptr: bigint): number {
30017 if(!isWasmInitialized) {
30018 throw new Error("initializeWasm() must be awaited first!");
30020 const nativeResponseValue = wasm.TS_InvalidShutdownScript_get_script(this_ptr);
30021 return nativeResponseValue;
30023 // void InvalidShutdownScript_set_script(struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
30025 export function InvalidShutdownScript_set_script(this_ptr: bigint, val: number): void {
30026 if(!isWasmInitialized) {
30027 throw new Error("initializeWasm() must be awaited first!");
30029 const nativeResponseValue = wasm.TS_InvalidShutdownScript_set_script(this_ptr, val);
30030 // debug statements here
30032 // MUST_USE_RES struct LDKInvalidShutdownScript InvalidShutdownScript_new(struct LDKCVec_u8Z script_arg);
30034 export function InvalidShutdownScript_new(script_arg: number): bigint {
30035 if(!isWasmInitialized) {
30036 throw new Error("initializeWasm() must be awaited first!");
30038 const nativeResponseValue = wasm.TS_InvalidShutdownScript_new(script_arg);
30039 return nativeResponseValue;
30041 // uint64_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg);
30043 export function InvalidShutdownScript_clone_ptr(arg: bigint): bigint {
30044 if(!isWasmInitialized) {
30045 throw new Error("initializeWasm() must be awaited first!");
30047 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone_ptr(arg);
30048 return nativeResponseValue;
30050 // struct LDKInvalidShutdownScript InvalidShutdownScript_clone(const struct LDKInvalidShutdownScript *NONNULL_PTR orig);
30052 export function InvalidShutdownScript_clone(orig: bigint): bigint {
30053 if(!isWasmInitialized) {
30054 throw new Error("initializeWasm() must be awaited first!");
30056 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone(orig);
30057 return nativeResponseValue;
30059 // struct LDKCVec_u8Z ShutdownScript_write(const struct LDKShutdownScript *NONNULL_PTR obj);
30061 export function ShutdownScript_write(obj: bigint): number {
30062 if(!isWasmInitialized) {
30063 throw new Error("initializeWasm() must be awaited first!");
30065 const nativeResponseValue = wasm.TS_ShutdownScript_write(obj);
30066 return nativeResponseValue;
30068 // struct LDKCResult_ShutdownScriptDecodeErrorZ ShutdownScript_read(struct LDKu8slice ser);
30070 export function ShutdownScript_read(ser: number): bigint {
30071 if(!isWasmInitialized) {
30072 throw new Error("initializeWasm() must be awaited first!");
30074 const nativeResponseValue = wasm.TS_ShutdownScript_read(ser);
30075 return nativeResponseValue;
30077 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wpkh(const uint8_t (*pubkey_hash)[20]);
30079 export function ShutdownScript_new_p2wpkh(pubkey_hash: number): bigint {
30080 if(!isWasmInitialized) {
30081 throw new Error("initializeWasm() must be awaited first!");
30083 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wpkh(pubkey_hash);
30084 return nativeResponseValue;
30086 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wsh(const uint8_t (*script_hash)[32]);
30088 export function ShutdownScript_new_p2wsh(script_hash: number): bigint {
30089 if(!isWasmInitialized) {
30090 throw new Error("initializeWasm() must be awaited first!");
30092 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wsh(script_hash);
30093 return nativeResponseValue;
30095 // MUST_USE_RES struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ ShutdownScript_new_witness_program(struct LDKWitnessVersion version, struct LDKu8slice program);
30097 export function ShutdownScript_new_witness_program(version: number, program: number): bigint {
30098 if(!isWasmInitialized) {
30099 throw new Error("initializeWasm() must be awaited first!");
30101 const nativeResponseValue = wasm.TS_ShutdownScript_new_witness_program(version, program);
30102 return nativeResponseValue;
30104 // MUST_USE_RES struct LDKCVec_u8Z ShutdownScript_into_inner(struct LDKShutdownScript this_arg);
30106 export function ShutdownScript_into_inner(this_arg: bigint): number {
30107 if(!isWasmInitialized) {
30108 throw new Error("initializeWasm() must be awaited first!");
30110 const nativeResponseValue = wasm.TS_ShutdownScript_into_inner(this_arg);
30111 return nativeResponseValue;
30113 // MUST_USE_RES struct LDKPublicKey ShutdownScript_as_legacy_pubkey(const struct LDKShutdownScript *NONNULL_PTR this_arg);
30115 export function ShutdownScript_as_legacy_pubkey(this_arg: bigint): number {
30116 if(!isWasmInitialized) {
30117 throw new Error("initializeWasm() must be awaited first!");
30119 const nativeResponseValue = wasm.TS_ShutdownScript_as_legacy_pubkey(this_arg);
30120 return nativeResponseValue;
30122 // MUST_USE_RES bool ShutdownScript_is_compatible(const struct LDKShutdownScript *NONNULL_PTR this_arg, const struct LDKInitFeatures *NONNULL_PTR features);
30124 export function ShutdownScript_is_compatible(this_arg: bigint, features: bigint): boolean {
30125 if(!isWasmInitialized) {
30126 throw new Error("initializeWasm() must be awaited first!");
30128 const nativeResponseValue = wasm.TS_ShutdownScript_is_compatible(this_arg, features);
30129 return nativeResponseValue;
30131 // void CustomMessageReader_free(struct LDKCustomMessageReader this_ptr);
30133 export function CustomMessageReader_free(this_ptr: bigint): void {
30134 if(!isWasmInitialized) {
30135 throw new Error("initializeWasm() must be awaited first!");
30137 const nativeResponseValue = wasm.TS_CustomMessageReader_free(this_ptr);
30138 // debug statements here
30140 // uint64_t Type_clone_ptr(LDKType *NONNULL_PTR arg);
30142 export function Type_clone_ptr(arg: bigint): bigint {
30143 if(!isWasmInitialized) {
30144 throw new Error("initializeWasm() must be awaited first!");
30146 const nativeResponseValue = wasm.TS_Type_clone_ptr(arg);
30147 return nativeResponseValue;
30149 // struct LDKType Type_clone(const struct LDKType *NONNULL_PTR orig);
30151 export function Type_clone(orig: bigint): bigint {
30152 if(!isWasmInitialized) {
30153 throw new Error("initializeWasm() must be awaited first!");
30155 const nativeResponseValue = wasm.TS_Type_clone(orig);
30156 return nativeResponseValue;
30158 // void Type_free(struct LDKType this_ptr);
30160 export function Type_free(this_ptr: bigint): void {
30161 if(!isWasmInitialized) {
30162 throw new Error("initializeWasm() must be awaited first!");
30164 const nativeResponseValue = wasm.TS_Type_free(this_ptr);
30165 // debug statements here
30167 // void NodeId_free(struct LDKNodeId this_obj);
30169 export function NodeId_free(this_obj: bigint): void {
30170 if(!isWasmInitialized) {
30171 throw new Error("initializeWasm() must be awaited first!");
30173 const nativeResponseValue = wasm.TS_NodeId_free(this_obj);
30174 // debug statements here
30176 // uint64_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg);
30178 export function NodeId_clone_ptr(arg: bigint): bigint {
30179 if(!isWasmInitialized) {
30180 throw new Error("initializeWasm() must be awaited first!");
30182 const nativeResponseValue = wasm.TS_NodeId_clone_ptr(arg);
30183 return nativeResponseValue;
30185 // struct LDKNodeId NodeId_clone(const struct LDKNodeId *NONNULL_PTR orig);
30187 export function NodeId_clone(orig: bigint): bigint {
30188 if(!isWasmInitialized) {
30189 throw new Error("initializeWasm() must be awaited first!");
30191 const nativeResponseValue = wasm.TS_NodeId_clone(orig);
30192 return nativeResponseValue;
30194 // MUST_USE_RES struct LDKNodeId NodeId_from_pubkey(struct LDKPublicKey pubkey);
30196 export function NodeId_from_pubkey(pubkey: number): bigint {
30197 if(!isWasmInitialized) {
30198 throw new Error("initializeWasm() must be awaited first!");
30200 const nativeResponseValue = wasm.TS_NodeId_from_pubkey(pubkey);
30201 return nativeResponseValue;
30203 // MUST_USE_RES struct LDKu8slice NodeId_as_slice(const struct LDKNodeId *NONNULL_PTR this_arg);
30205 export function NodeId_as_slice(this_arg: bigint): number {
30206 if(!isWasmInitialized) {
30207 throw new Error("initializeWasm() must be awaited first!");
30209 const nativeResponseValue = wasm.TS_NodeId_as_slice(this_arg);
30210 return nativeResponseValue;
30212 // uint64_t NodeId_hash(const struct LDKNodeId *NONNULL_PTR o);
30214 export function NodeId_hash(o: bigint): bigint {
30215 if(!isWasmInitialized) {
30216 throw new Error("initializeWasm() must be awaited first!");
30218 const nativeResponseValue = wasm.TS_NodeId_hash(o);
30219 return nativeResponseValue;
30221 // struct LDKCVec_u8Z NodeId_write(const struct LDKNodeId *NONNULL_PTR obj);
30223 export function NodeId_write(obj: bigint): number {
30224 if(!isWasmInitialized) {
30225 throw new Error("initializeWasm() must be awaited first!");
30227 const nativeResponseValue = wasm.TS_NodeId_write(obj);
30228 return nativeResponseValue;
30230 // struct LDKCResult_NodeIdDecodeErrorZ NodeId_read(struct LDKu8slice ser);
30232 export function NodeId_read(ser: number): bigint {
30233 if(!isWasmInitialized) {
30234 throw new Error("initializeWasm() must be awaited first!");
30236 const nativeResponseValue = wasm.TS_NodeId_read(ser);
30237 return nativeResponseValue;
30239 // void NetworkGraph_free(struct LDKNetworkGraph this_obj);
30241 export function NetworkGraph_free(this_obj: bigint): void {
30242 if(!isWasmInitialized) {
30243 throw new Error("initializeWasm() must be awaited first!");
30245 const nativeResponseValue = wasm.TS_NetworkGraph_free(this_obj);
30246 // debug statements here
30248 // void ReadOnlyNetworkGraph_free(struct LDKReadOnlyNetworkGraph this_obj);
30250 export function ReadOnlyNetworkGraph_free(this_obj: bigint): void {
30251 if(!isWasmInitialized) {
30252 throw new Error("initializeWasm() must be awaited first!");
30254 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_free(this_obj);
30255 // debug statements here
30257 // void NetworkUpdate_free(struct LDKNetworkUpdate this_ptr);
30259 export function NetworkUpdate_free(this_ptr: bigint): void {
30260 if(!isWasmInitialized) {
30261 throw new Error("initializeWasm() must be awaited first!");
30263 const nativeResponseValue = wasm.TS_NetworkUpdate_free(this_ptr);
30264 // debug statements here
30266 // uint64_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg);
30268 export function NetworkUpdate_clone_ptr(arg: bigint): bigint {
30269 if(!isWasmInitialized) {
30270 throw new Error("initializeWasm() must be awaited first!");
30272 const nativeResponseValue = wasm.TS_NetworkUpdate_clone_ptr(arg);
30273 return nativeResponseValue;
30275 // struct LDKNetworkUpdate NetworkUpdate_clone(const struct LDKNetworkUpdate *NONNULL_PTR orig);
30277 export function NetworkUpdate_clone(orig: bigint): bigint {
30278 if(!isWasmInitialized) {
30279 throw new Error("initializeWasm() must be awaited first!");
30281 const nativeResponseValue = wasm.TS_NetworkUpdate_clone(orig);
30282 return nativeResponseValue;
30284 // struct LDKNetworkUpdate NetworkUpdate_channel_update_message(struct LDKChannelUpdate msg);
30286 export function NetworkUpdate_channel_update_message(msg: bigint): bigint {
30287 if(!isWasmInitialized) {
30288 throw new Error("initializeWasm() must be awaited first!");
30290 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_update_message(msg);
30291 return nativeResponseValue;
30293 // struct LDKNetworkUpdate NetworkUpdate_channel_failure(uint64_t short_channel_id, bool is_permanent);
30295 export function NetworkUpdate_channel_failure(short_channel_id: bigint, is_permanent: boolean): bigint {
30296 if(!isWasmInitialized) {
30297 throw new Error("initializeWasm() must be awaited first!");
30299 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_failure(short_channel_id, is_permanent);
30300 return nativeResponseValue;
30302 // struct LDKNetworkUpdate NetworkUpdate_node_failure(struct LDKPublicKey node_id, bool is_permanent);
30304 export function NetworkUpdate_node_failure(node_id: number, is_permanent: boolean): bigint {
30305 if(!isWasmInitialized) {
30306 throw new Error("initializeWasm() must be awaited first!");
30308 const nativeResponseValue = wasm.TS_NetworkUpdate_node_failure(node_id, is_permanent);
30309 return nativeResponseValue;
30311 // struct LDKCVec_u8Z NetworkUpdate_write(const struct LDKNetworkUpdate *NONNULL_PTR obj);
30313 export function NetworkUpdate_write(obj: bigint): number {
30314 if(!isWasmInitialized) {
30315 throw new Error("initializeWasm() must be awaited first!");
30317 const nativeResponseValue = wasm.TS_NetworkUpdate_write(obj);
30318 return nativeResponseValue;
30320 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ NetworkUpdate_read(struct LDKu8slice ser);
30322 export function NetworkUpdate_read(ser: number): bigint {
30323 if(!isWasmInitialized) {
30324 throw new Error("initializeWasm() must be awaited first!");
30326 const nativeResponseValue = wasm.TS_NetworkUpdate_read(ser);
30327 return nativeResponseValue;
30329 // void P2PGossipSync_free(struct LDKP2PGossipSync this_obj);
30331 export function P2PGossipSync_free(this_obj: bigint): void {
30332 if(!isWasmInitialized) {
30333 throw new Error("initializeWasm() must be awaited first!");
30335 const nativeResponseValue = wasm.TS_P2PGossipSync_free(this_obj);
30336 // debug statements here
30338 // MUST_USE_RES struct LDKP2PGossipSync P2PGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCOption_AccessZ chain_access, struct LDKLogger logger);
30340 export function P2PGossipSync_new(network_graph: bigint, chain_access: bigint, logger: bigint): bigint {
30341 if(!isWasmInitialized) {
30342 throw new Error("initializeWasm() must be awaited first!");
30344 const nativeResponseValue = wasm.TS_P2PGossipSync_new(network_graph, chain_access, logger);
30345 return nativeResponseValue;
30347 // void P2PGossipSync_add_chain_access(struct LDKP2PGossipSync *NONNULL_PTR this_arg, struct LDKCOption_AccessZ chain_access);
30349 export function P2PGossipSync_add_chain_access(this_arg: bigint, chain_access: bigint): void {
30350 if(!isWasmInitialized) {
30351 throw new Error("initializeWasm() must be awaited first!");
30353 const nativeResponseValue = wasm.TS_P2PGossipSync_add_chain_access(this_arg, chain_access);
30354 // debug statements here
30356 // struct LDKEventHandler NetworkGraph_as_EventHandler(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
30358 export function NetworkGraph_as_EventHandler(this_arg: bigint): bigint {
30359 if(!isWasmInitialized) {
30360 throw new Error("initializeWasm() must be awaited first!");
30362 const nativeResponseValue = wasm.TS_NetworkGraph_as_EventHandler(this_arg);
30363 return nativeResponseValue;
30365 // struct LDKRoutingMessageHandler P2PGossipSync_as_RoutingMessageHandler(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
30367 export function P2PGossipSync_as_RoutingMessageHandler(this_arg: bigint): bigint {
30368 if(!isWasmInitialized) {
30369 throw new Error("initializeWasm() must be awaited first!");
30371 const nativeResponseValue = wasm.TS_P2PGossipSync_as_RoutingMessageHandler(this_arg);
30372 return nativeResponseValue;
30374 // struct LDKMessageSendEventsProvider P2PGossipSync_as_MessageSendEventsProvider(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
30376 export function P2PGossipSync_as_MessageSendEventsProvider(this_arg: bigint): bigint {
30377 if(!isWasmInitialized) {
30378 throw new Error("initializeWasm() must be awaited first!");
30380 const nativeResponseValue = wasm.TS_P2PGossipSync_as_MessageSendEventsProvider(this_arg);
30381 return nativeResponseValue;
30383 // void ChannelUpdateInfo_free(struct LDKChannelUpdateInfo this_obj);
30385 export function ChannelUpdateInfo_free(this_obj: bigint): void {
30386 if(!isWasmInitialized) {
30387 throw new Error("initializeWasm() must be awaited first!");
30389 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_free(this_obj);
30390 // debug statements here
30392 // uint32_t ChannelUpdateInfo_get_last_update(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
30394 export function ChannelUpdateInfo_get_last_update(this_ptr: bigint): number {
30395 if(!isWasmInitialized) {
30396 throw new Error("initializeWasm() must be awaited first!");
30398 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update(this_ptr);
30399 return nativeResponseValue;
30401 // void ChannelUpdateInfo_set_last_update(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint32_t val);
30403 export function ChannelUpdateInfo_set_last_update(this_ptr: bigint, val: number): void {
30404 if(!isWasmInitialized) {
30405 throw new Error("initializeWasm() must be awaited first!");
30407 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update(this_ptr, val);
30408 // debug statements here
30410 // bool ChannelUpdateInfo_get_enabled(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
30412 export function ChannelUpdateInfo_get_enabled(this_ptr: bigint): boolean {
30413 if(!isWasmInitialized) {
30414 throw new Error("initializeWasm() must be awaited first!");
30416 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_enabled(this_ptr);
30417 return nativeResponseValue;
30419 // void ChannelUpdateInfo_set_enabled(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, bool val);
30421 export function ChannelUpdateInfo_set_enabled(this_ptr: bigint, val: boolean): void {
30422 if(!isWasmInitialized) {
30423 throw new Error("initializeWasm() must be awaited first!");
30425 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_enabled(this_ptr, val);
30426 // debug statements here
30428 // uint16_t ChannelUpdateInfo_get_cltv_expiry_delta(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
30430 export function ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
30431 if(!isWasmInitialized) {
30432 throw new Error("initializeWasm() must be awaited first!");
30434 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr);
30435 return nativeResponseValue;
30437 // void ChannelUpdateInfo_set_cltv_expiry_delta(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint16_t val);
30439 export function ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
30440 if(!isWasmInitialized) {
30441 throw new Error("initializeWasm() must be awaited first!");
30443 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr, val);
30444 // debug statements here
30446 // uint64_t ChannelUpdateInfo_get_htlc_minimum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
30448 export function ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr: bigint): bigint {
30449 if(!isWasmInitialized) {
30450 throw new Error("initializeWasm() must be awaited first!");
30452 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr);
30453 return nativeResponseValue;
30455 // void ChannelUpdateInfo_set_htlc_minimum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
30457 export function ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
30458 if(!isWasmInitialized) {
30459 throw new Error("initializeWasm() must be awaited first!");
30461 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr, val);
30462 // debug statements here
30464 // uint64_t ChannelUpdateInfo_get_htlc_maximum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
30466 export function ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr: bigint): bigint {
30467 if(!isWasmInitialized) {
30468 throw new Error("initializeWasm() must be awaited first!");
30470 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr);
30471 return nativeResponseValue;
30473 // void ChannelUpdateInfo_set_htlc_maximum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
30475 export function ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
30476 if(!isWasmInitialized) {
30477 throw new Error("initializeWasm() must be awaited first!");
30479 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr, val);
30480 // debug statements here
30482 // struct LDKRoutingFees ChannelUpdateInfo_get_fees(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
30484 export function ChannelUpdateInfo_get_fees(this_ptr: bigint): bigint {
30485 if(!isWasmInitialized) {
30486 throw new Error("initializeWasm() must be awaited first!");
30488 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_fees(this_ptr);
30489 return nativeResponseValue;
30491 // void ChannelUpdateInfo_set_fees(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
30493 export function ChannelUpdateInfo_set_fees(this_ptr: bigint, val: bigint): void {
30494 if(!isWasmInitialized) {
30495 throw new Error("initializeWasm() must be awaited first!");
30497 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_fees(this_ptr, val);
30498 // debug statements here
30500 // struct LDKChannelUpdate ChannelUpdateInfo_get_last_update_message(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
30502 export function ChannelUpdateInfo_get_last_update_message(this_ptr: bigint): bigint {
30503 if(!isWasmInitialized) {
30504 throw new Error("initializeWasm() must be awaited first!");
30506 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update_message(this_ptr);
30507 return nativeResponseValue;
30509 // void ChannelUpdateInfo_set_last_update_message(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdate val);
30511 export function ChannelUpdateInfo_set_last_update_message(this_ptr: bigint, val: bigint): void {
30512 if(!isWasmInitialized) {
30513 throw new Error("initializeWasm() must be awaited first!");
30515 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update_message(this_ptr, val);
30516 // debug statements here
30518 // 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, uint64_t htlc_maximum_msat_arg, struct LDKRoutingFees fees_arg, struct LDKChannelUpdate last_update_message_arg);
30520 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: bigint, fees_arg: bigint, last_update_message_arg: bigint): bigint {
30521 if(!isWasmInitialized) {
30522 throw new Error("initializeWasm() must be awaited first!");
30524 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);
30525 return nativeResponseValue;
30527 // uint64_t ChannelUpdateInfo_clone_ptr(LDKChannelUpdateInfo *NONNULL_PTR arg);
30529 export function ChannelUpdateInfo_clone_ptr(arg: bigint): bigint {
30530 if(!isWasmInitialized) {
30531 throw new Error("initializeWasm() must be awaited first!");
30533 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone_ptr(arg);
30534 return nativeResponseValue;
30536 // struct LDKChannelUpdateInfo ChannelUpdateInfo_clone(const struct LDKChannelUpdateInfo *NONNULL_PTR orig);
30538 export function ChannelUpdateInfo_clone(orig: bigint): bigint {
30539 if(!isWasmInitialized) {
30540 throw new Error("initializeWasm() must be awaited first!");
30542 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone(orig);
30543 return nativeResponseValue;
30545 // struct LDKCVec_u8Z ChannelUpdateInfo_write(const struct LDKChannelUpdateInfo *NONNULL_PTR obj);
30547 export function ChannelUpdateInfo_write(obj: bigint): number {
30548 if(!isWasmInitialized) {
30549 throw new Error("initializeWasm() must be awaited first!");
30551 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_write(obj);
30552 return nativeResponseValue;
30554 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ ChannelUpdateInfo_read(struct LDKu8slice ser);
30556 export function ChannelUpdateInfo_read(ser: number): bigint {
30557 if(!isWasmInitialized) {
30558 throw new Error("initializeWasm() must be awaited first!");
30560 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_read(ser);
30561 return nativeResponseValue;
30563 // void ChannelInfo_free(struct LDKChannelInfo this_obj);
30565 export function ChannelInfo_free(this_obj: bigint): void {
30566 if(!isWasmInitialized) {
30567 throw new Error("initializeWasm() must be awaited first!");
30569 const nativeResponseValue = wasm.TS_ChannelInfo_free(this_obj);
30570 // debug statements here
30572 // struct LDKChannelFeatures ChannelInfo_get_features(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
30574 export function ChannelInfo_get_features(this_ptr: bigint): bigint {
30575 if(!isWasmInitialized) {
30576 throw new Error("initializeWasm() must be awaited first!");
30578 const nativeResponseValue = wasm.TS_ChannelInfo_get_features(this_ptr);
30579 return nativeResponseValue;
30581 // void ChannelInfo_set_features(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
30583 export function ChannelInfo_set_features(this_ptr: bigint, val: bigint): void {
30584 if(!isWasmInitialized) {
30585 throw new Error("initializeWasm() must be awaited first!");
30587 const nativeResponseValue = wasm.TS_ChannelInfo_set_features(this_ptr, val);
30588 // debug statements here
30590 // struct LDKNodeId ChannelInfo_get_node_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
30592 export function ChannelInfo_get_node_one(this_ptr: bigint): bigint {
30593 if(!isWasmInitialized) {
30594 throw new Error("initializeWasm() must be awaited first!");
30596 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_one(this_ptr);
30597 return nativeResponseValue;
30599 // void ChannelInfo_set_node_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
30601 export function ChannelInfo_set_node_one(this_ptr: bigint, val: bigint): void {
30602 if(!isWasmInitialized) {
30603 throw new Error("initializeWasm() must be awaited first!");
30605 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_one(this_ptr, val);
30606 // debug statements here
30608 // struct LDKChannelUpdateInfo ChannelInfo_get_one_to_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
30610 export function ChannelInfo_get_one_to_two(this_ptr: bigint): bigint {
30611 if(!isWasmInitialized) {
30612 throw new Error("initializeWasm() must be awaited first!");
30614 const nativeResponseValue = wasm.TS_ChannelInfo_get_one_to_two(this_ptr);
30615 return nativeResponseValue;
30617 // void ChannelInfo_set_one_to_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
30619 export function ChannelInfo_set_one_to_two(this_ptr: bigint, val: bigint): void {
30620 if(!isWasmInitialized) {
30621 throw new Error("initializeWasm() must be awaited first!");
30623 const nativeResponseValue = wasm.TS_ChannelInfo_set_one_to_two(this_ptr, val);
30624 // debug statements here
30626 // struct LDKNodeId ChannelInfo_get_node_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
30628 export function ChannelInfo_get_node_two(this_ptr: bigint): bigint {
30629 if(!isWasmInitialized) {
30630 throw new Error("initializeWasm() must be awaited first!");
30632 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_two(this_ptr);
30633 return nativeResponseValue;
30635 // void ChannelInfo_set_node_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
30637 export function ChannelInfo_set_node_two(this_ptr: bigint, val: bigint): void {
30638 if(!isWasmInitialized) {
30639 throw new Error("initializeWasm() must be awaited first!");
30641 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_two(this_ptr, val);
30642 // debug statements here
30644 // struct LDKChannelUpdateInfo ChannelInfo_get_two_to_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
30646 export function ChannelInfo_get_two_to_one(this_ptr: bigint): bigint {
30647 if(!isWasmInitialized) {
30648 throw new Error("initializeWasm() must be awaited first!");
30650 const nativeResponseValue = wasm.TS_ChannelInfo_get_two_to_one(this_ptr);
30651 return nativeResponseValue;
30653 // void ChannelInfo_set_two_to_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
30655 export function ChannelInfo_set_two_to_one(this_ptr: bigint, val: bigint): void {
30656 if(!isWasmInitialized) {
30657 throw new Error("initializeWasm() must be awaited first!");
30659 const nativeResponseValue = wasm.TS_ChannelInfo_set_two_to_one(this_ptr, val);
30660 // debug statements here
30662 // struct LDKCOption_u64Z ChannelInfo_get_capacity_sats(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
30664 export function ChannelInfo_get_capacity_sats(this_ptr: bigint): bigint {
30665 if(!isWasmInitialized) {
30666 throw new Error("initializeWasm() must be awaited first!");
30668 const nativeResponseValue = wasm.TS_ChannelInfo_get_capacity_sats(this_ptr);
30669 return nativeResponseValue;
30671 // void ChannelInfo_set_capacity_sats(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
30673 export function ChannelInfo_set_capacity_sats(this_ptr: bigint, val: bigint): void {
30674 if(!isWasmInitialized) {
30675 throw new Error("initializeWasm() must be awaited first!");
30677 const nativeResponseValue = wasm.TS_ChannelInfo_set_capacity_sats(this_ptr, val);
30678 // debug statements here
30680 // struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
30682 export function ChannelInfo_get_announcement_message(this_ptr: bigint): bigint {
30683 if(!isWasmInitialized) {
30684 throw new Error("initializeWasm() must be awaited first!");
30686 const nativeResponseValue = wasm.TS_ChannelInfo_get_announcement_message(this_ptr);
30687 return nativeResponseValue;
30689 // void ChannelInfo_set_announcement_message(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelAnnouncement val);
30691 export function ChannelInfo_set_announcement_message(this_ptr: bigint, val: bigint): void {
30692 if(!isWasmInitialized) {
30693 throw new Error("initializeWasm() must be awaited first!");
30695 const nativeResponseValue = wasm.TS_ChannelInfo_set_announcement_message(this_ptr, val);
30696 // debug statements here
30698 // uint64_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg);
30700 export function ChannelInfo_clone_ptr(arg: bigint): bigint {
30701 if(!isWasmInitialized) {
30702 throw new Error("initializeWasm() must be awaited first!");
30704 const nativeResponseValue = wasm.TS_ChannelInfo_clone_ptr(arg);
30705 return nativeResponseValue;
30707 // struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
30709 export function ChannelInfo_clone(orig: bigint): bigint {
30710 if(!isWasmInitialized) {
30711 throw new Error("initializeWasm() must be awaited first!");
30713 const nativeResponseValue = wasm.TS_ChannelInfo_clone(orig);
30714 return nativeResponseValue;
30716 // MUST_USE_RES struct LDKChannelUpdateInfo ChannelInfo_get_directional_info(const struct LDKChannelInfo *NONNULL_PTR this_arg, uint8_t channel_flags);
30718 export function ChannelInfo_get_directional_info(this_arg: bigint, channel_flags: number): bigint {
30719 if(!isWasmInitialized) {
30720 throw new Error("initializeWasm() must be awaited first!");
30722 const nativeResponseValue = wasm.TS_ChannelInfo_get_directional_info(this_arg, channel_flags);
30723 return nativeResponseValue;
30725 // struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
30727 export function ChannelInfo_write(obj: bigint): number {
30728 if(!isWasmInitialized) {
30729 throw new Error("initializeWasm() must be awaited first!");
30731 const nativeResponseValue = wasm.TS_ChannelInfo_write(obj);
30732 return nativeResponseValue;
30734 // struct LDKCResult_ChannelInfoDecodeErrorZ ChannelInfo_read(struct LDKu8slice ser);
30736 export function ChannelInfo_read(ser: number): bigint {
30737 if(!isWasmInitialized) {
30738 throw new Error("initializeWasm() must be awaited first!");
30740 const nativeResponseValue = wasm.TS_ChannelInfo_read(ser);
30741 return nativeResponseValue;
30743 // void DirectedChannelInfo_free(struct LDKDirectedChannelInfo this_obj);
30745 export function DirectedChannelInfo_free(this_obj: bigint): void {
30746 if(!isWasmInitialized) {
30747 throw new Error("initializeWasm() must be awaited first!");
30749 const nativeResponseValue = wasm.TS_DirectedChannelInfo_free(this_obj);
30750 // debug statements here
30752 // uint64_t DirectedChannelInfo_clone_ptr(LDKDirectedChannelInfo *NONNULL_PTR arg);
30754 export function DirectedChannelInfo_clone_ptr(arg: bigint): bigint {
30755 if(!isWasmInitialized) {
30756 throw new Error("initializeWasm() must be awaited first!");
30758 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone_ptr(arg);
30759 return nativeResponseValue;
30761 // struct LDKDirectedChannelInfo DirectedChannelInfo_clone(const struct LDKDirectedChannelInfo *NONNULL_PTR orig);
30763 export function DirectedChannelInfo_clone(orig: bigint): bigint {
30764 if(!isWasmInitialized) {
30765 throw new Error("initializeWasm() must be awaited first!");
30767 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone(orig);
30768 return nativeResponseValue;
30770 // MUST_USE_RES struct LDKChannelInfo DirectedChannelInfo_channel(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
30772 export function DirectedChannelInfo_channel(this_arg: bigint): bigint {
30773 if(!isWasmInitialized) {
30774 throw new Error("initializeWasm() must be awaited first!");
30776 const nativeResponseValue = wasm.TS_DirectedChannelInfo_channel(this_arg);
30777 return nativeResponseValue;
30779 // MUST_USE_RES struct LDKChannelUpdateInfo DirectedChannelInfo_direction(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
30781 export function DirectedChannelInfo_direction(this_arg: bigint): bigint {
30782 if(!isWasmInitialized) {
30783 throw new Error("initializeWasm() must be awaited first!");
30785 const nativeResponseValue = wasm.TS_DirectedChannelInfo_direction(this_arg);
30786 return nativeResponseValue;
30788 // MUST_USE_RES uint64_t DirectedChannelInfo_htlc_maximum_msat(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
30790 export function DirectedChannelInfo_htlc_maximum_msat(this_arg: bigint): bigint {
30791 if(!isWasmInitialized) {
30792 throw new Error("initializeWasm() must be awaited first!");
30794 const nativeResponseValue = wasm.TS_DirectedChannelInfo_htlc_maximum_msat(this_arg);
30795 return nativeResponseValue;
30797 // MUST_USE_RES struct LDKEffectiveCapacity DirectedChannelInfo_effective_capacity(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
30799 export function DirectedChannelInfo_effective_capacity(this_arg: bigint): bigint {
30800 if(!isWasmInitialized) {
30801 throw new Error("initializeWasm() must be awaited first!");
30803 const nativeResponseValue = wasm.TS_DirectedChannelInfo_effective_capacity(this_arg);
30804 return nativeResponseValue;
30806 // void EffectiveCapacity_free(struct LDKEffectiveCapacity this_ptr);
30808 export function EffectiveCapacity_free(this_ptr: bigint): void {
30809 if(!isWasmInitialized) {
30810 throw new Error("initializeWasm() must be awaited first!");
30812 const nativeResponseValue = wasm.TS_EffectiveCapacity_free(this_ptr);
30813 // debug statements here
30815 // uint64_t EffectiveCapacity_clone_ptr(LDKEffectiveCapacity *NONNULL_PTR arg);
30817 export function EffectiveCapacity_clone_ptr(arg: bigint): bigint {
30818 if(!isWasmInitialized) {
30819 throw new Error("initializeWasm() must be awaited first!");
30821 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone_ptr(arg);
30822 return nativeResponseValue;
30824 // struct LDKEffectiveCapacity EffectiveCapacity_clone(const struct LDKEffectiveCapacity *NONNULL_PTR orig);
30826 export function EffectiveCapacity_clone(orig: bigint): bigint {
30827 if(!isWasmInitialized) {
30828 throw new Error("initializeWasm() must be awaited first!");
30830 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone(orig);
30831 return nativeResponseValue;
30833 // struct LDKEffectiveCapacity EffectiveCapacity_exact_liquidity(uint64_t liquidity_msat);
30835 export function EffectiveCapacity_exact_liquidity(liquidity_msat: bigint): bigint {
30836 if(!isWasmInitialized) {
30837 throw new Error("initializeWasm() must be awaited first!");
30839 const nativeResponseValue = wasm.TS_EffectiveCapacity_exact_liquidity(liquidity_msat);
30840 return nativeResponseValue;
30842 // struct LDKEffectiveCapacity EffectiveCapacity_maximum_htlc(uint64_t amount_msat);
30844 export function EffectiveCapacity_maximum_htlc(amount_msat: bigint): bigint {
30845 if(!isWasmInitialized) {
30846 throw new Error("initializeWasm() must be awaited first!");
30848 const nativeResponseValue = wasm.TS_EffectiveCapacity_maximum_htlc(amount_msat);
30849 return nativeResponseValue;
30851 // struct LDKEffectiveCapacity EffectiveCapacity_total(uint64_t capacity_msat, struct LDKCOption_u64Z htlc_maximum_msat);
30853 export function EffectiveCapacity_total(capacity_msat: bigint, htlc_maximum_msat: bigint): bigint {
30854 if(!isWasmInitialized) {
30855 throw new Error("initializeWasm() must be awaited first!");
30857 const nativeResponseValue = wasm.TS_EffectiveCapacity_total(capacity_msat, htlc_maximum_msat);
30858 return nativeResponseValue;
30860 // struct LDKEffectiveCapacity EffectiveCapacity_infinite(void);
30862 export function EffectiveCapacity_infinite(): bigint {
30863 if(!isWasmInitialized) {
30864 throw new Error("initializeWasm() must be awaited first!");
30866 const nativeResponseValue = wasm.TS_EffectiveCapacity_infinite();
30867 return nativeResponseValue;
30869 // struct LDKEffectiveCapacity EffectiveCapacity_unknown(void);
30871 export function EffectiveCapacity_unknown(): bigint {
30872 if(!isWasmInitialized) {
30873 throw new Error("initializeWasm() must be awaited first!");
30875 const nativeResponseValue = wasm.TS_EffectiveCapacity_unknown();
30876 return nativeResponseValue;
30878 // MUST_USE_RES uint64_t EffectiveCapacity_as_msat(const struct LDKEffectiveCapacity *NONNULL_PTR this_arg);
30880 export function EffectiveCapacity_as_msat(this_arg: bigint): bigint {
30881 if(!isWasmInitialized) {
30882 throw new Error("initializeWasm() must be awaited first!");
30884 const nativeResponseValue = wasm.TS_EffectiveCapacity_as_msat(this_arg);
30885 return nativeResponseValue;
30887 // void RoutingFees_free(struct LDKRoutingFees this_obj);
30889 export function RoutingFees_free(this_obj: bigint): void {
30890 if(!isWasmInitialized) {
30891 throw new Error("initializeWasm() must be awaited first!");
30893 const nativeResponseValue = wasm.TS_RoutingFees_free(this_obj);
30894 // debug statements here
30896 // uint32_t RoutingFees_get_base_msat(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
30898 export function RoutingFees_get_base_msat(this_ptr: bigint): number {
30899 if(!isWasmInitialized) {
30900 throw new Error("initializeWasm() must be awaited first!");
30902 const nativeResponseValue = wasm.TS_RoutingFees_get_base_msat(this_ptr);
30903 return nativeResponseValue;
30905 // void RoutingFees_set_base_msat(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
30907 export function RoutingFees_set_base_msat(this_ptr: bigint, val: number): void {
30908 if(!isWasmInitialized) {
30909 throw new Error("initializeWasm() must be awaited first!");
30911 const nativeResponseValue = wasm.TS_RoutingFees_set_base_msat(this_ptr, val);
30912 // debug statements here
30914 // uint32_t RoutingFees_get_proportional_millionths(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
30916 export function RoutingFees_get_proportional_millionths(this_ptr: bigint): number {
30917 if(!isWasmInitialized) {
30918 throw new Error("initializeWasm() must be awaited first!");
30920 const nativeResponseValue = wasm.TS_RoutingFees_get_proportional_millionths(this_ptr);
30921 return nativeResponseValue;
30923 // void RoutingFees_set_proportional_millionths(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
30925 export function RoutingFees_set_proportional_millionths(this_ptr: bigint, val: number): void {
30926 if(!isWasmInitialized) {
30927 throw new Error("initializeWasm() must be awaited first!");
30929 const nativeResponseValue = wasm.TS_RoutingFees_set_proportional_millionths(this_ptr, val);
30930 // debug statements here
30932 // MUST_USE_RES struct LDKRoutingFees RoutingFees_new(uint32_t base_msat_arg, uint32_t proportional_millionths_arg);
30934 export function RoutingFees_new(base_msat_arg: number, proportional_millionths_arg: number): bigint {
30935 if(!isWasmInitialized) {
30936 throw new Error("initializeWasm() must be awaited first!");
30938 const nativeResponseValue = wasm.TS_RoutingFees_new(base_msat_arg, proportional_millionths_arg);
30939 return nativeResponseValue;
30941 // bool RoutingFees_eq(const struct LDKRoutingFees *NONNULL_PTR a, const struct LDKRoutingFees *NONNULL_PTR b);
30943 export function RoutingFees_eq(a: bigint, b: bigint): boolean {
30944 if(!isWasmInitialized) {
30945 throw new Error("initializeWasm() must be awaited first!");
30947 const nativeResponseValue = wasm.TS_RoutingFees_eq(a, b);
30948 return nativeResponseValue;
30950 // uint64_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg);
30952 export function RoutingFees_clone_ptr(arg: bigint): bigint {
30953 if(!isWasmInitialized) {
30954 throw new Error("initializeWasm() must be awaited first!");
30956 const nativeResponseValue = wasm.TS_RoutingFees_clone_ptr(arg);
30957 return nativeResponseValue;
30959 // struct LDKRoutingFees RoutingFees_clone(const struct LDKRoutingFees *NONNULL_PTR orig);
30961 export function RoutingFees_clone(orig: bigint): bigint {
30962 if(!isWasmInitialized) {
30963 throw new Error("initializeWasm() must be awaited first!");
30965 const nativeResponseValue = wasm.TS_RoutingFees_clone(orig);
30966 return nativeResponseValue;
30968 // uint64_t RoutingFees_hash(const struct LDKRoutingFees *NONNULL_PTR o);
30970 export function RoutingFees_hash(o: bigint): bigint {
30971 if(!isWasmInitialized) {
30972 throw new Error("initializeWasm() must be awaited first!");
30974 const nativeResponseValue = wasm.TS_RoutingFees_hash(o);
30975 return nativeResponseValue;
30977 // struct LDKCVec_u8Z RoutingFees_write(const struct LDKRoutingFees *NONNULL_PTR obj);
30979 export function RoutingFees_write(obj: bigint): number {
30980 if(!isWasmInitialized) {
30981 throw new Error("initializeWasm() must be awaited first!");
30983 const nativeResponseValue = wasm.TS_RoutingFees_write(obj);
30984 return nativeResponseValue;
30986 // struct LDKCResult_RoutingFeesDecodeErrorZ RoutingFees_read(struct LDKu8slice ser);
30988 export function RoutingFees_read(ser: number): bigint {
30989 if(!isWasmInitialized) {
30990 throw new Error("initializeWasm() must be awaited first!");
30992 const nativeResponseValue = wasm.TS_RoutingFees_read(ser);
30993 return nativeResponseValue;
30995 // void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_obj);
30997 export function NodeAnnouncementInfo_free(this_obj: bigint): void {
30998 if(!isWasmInitialized) {
30999 throw new Error("initializeWasm() must be awaited first!");
31001 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_free(this_obj);
31002 // debug statements here
31004 // struct LDKNodeFeatures NodeAnnouncementInfo_get_features(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
31006 export function NodeAnnouncementInfo_get_features(this_ptr: bigint): bigint {
31007 if(!isWasmInitialized) {
31008 throw new Error("initializeWasm() must be awaited first!");
31010 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_features(this_ptr);
31011 return nativeResponseValue;
31013 // void NodeAnnouncementInfo_set_features(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
31015 export function NodeAnnouncementInfo_set_features(this_ptr: bigint, val: bigint): void {
31016 if(!isWasmInitialized) {
31017 throw new Error("initializeWasm() must be awaited first!");
31019 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_features(this_ptr, val);
31020 // debug statements here
31022 // uint32_t NodeAnnouncementInfo_get_last_update(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
31024 export function NodeAnnouncementInfo_get_last_update(this_ptr: bigint): number {
31025 if(!isWasmInitialized) {
31026 throw new Error("initializeWasm() must be awaited first!");
31028 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_last_update(this_ptr);
31029 return nativeResponseValue;
31031 // void NodeAnnouncementInfo_set_last_update(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, uint32_t val);
31033 export function NodeAnnouncementInfo_set_last_update(this_ptr: bigint, val: number): void {
31034 if(!isWasmInitialized) {
31035 throw new Error("initializeWasm() must be awaited first!");
31037 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_last_update(this_ptr, val);
31038 // debug statements here
31040 // const uint8_t (*NodeAnnouncementInfo_get_rgb(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[3];
31042 export function NodeAnnouncementInfo_get_rgb(this_ptr: bigint): number {
31043 if(!isWasmInitialized) {
31044 throw new Error("initializeWasm() must be awaited first!");
31046 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_rgb(this_ptr);
31047 return nativeResponseValue;
31049 // void NodeAnnouncementInfo_set_rgb(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
31051 export function NodeAnnouncementInfo_set_rgb(this_ptr: bigint, val: number): void {
31052 if(!isWasmInitialized) {
31053 throw new Error("initializeWasm() must be awaited first!");
31055 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_rgb(this_ptr, val);
31056 // debug statements here
31058 // struct LDKNodeAlias NodeAnnouncementInfo_get_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
31060 export function NodeAnnouncementInfo_get_alias(this_ptr: bigint): bigint {
31061 if(!isWasmInitialized) {
31062 throw new Error("initializeWasm() must be awaited first!");
31064 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_alias(this_ptr);
31065 return nativeResponseValue;
31067 // void NodeAnnouncementInfo_set_alias(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAlias val);
31069 export function NodeAnnouncementInfo_set_alias(this_ptr: bigint, val: bigint): void {
31070 if(!isWasmInitialized) {
31071 throw new Error("initializeWasm() must be awaited first!");
31073 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_alias(this_ptr, val);
31074 // debug statements here
31076 // struct LDKCVec_NetAddressZ NodeAnnouncementInfo_get_addresses(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
31078 export function NodeAnnouncementInfo_get_addresses(this_ptr: bigint): number {
31079 if(!isWasmInitialized) {
31080 throw new Error("initializeWasm() must be awaited first!");
31082 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_addresses(this_ptr);
31083 return nativeResponseValue;
31085 // void NodeAnnouncementInfo_set_addresses(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
31087 export function NodeAnnouncementInfo_set_addresses(this_ptr: bigint, val: number): void {
31088 if(!isWasmInitialized) {
31089 throw new Error("initializeWasm() must be awaited first!");
31091 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_addresses(this_ptr, val);
31092 // debug statements here
31094 // struct LDKNodeAnnouncement NodeAnnouncementInfo_get_announcement_message(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
31096 export function NodeAnnouncementInfo_get_announcement_message(this_ptr: bigint): bigint {
31097 if(!isWasmInitialized) {
31098 throw new Error("initializeWasm() must be awaited first!");
31100 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_announcement_message(this_ptr);
31101 return nativeResponseValue;
31103 // void NodeAnnouncementInfo_set_announcement_message(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncement val);
31105 export function NodeAnnouncementInfo_set_announcement_message(this_ptr: bigint, val: bigint): void {
31106 if(!isWasmInitialized) {
31107 throw new Error("initializeWasm() must be awaited first!");
31109 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_announcement_message(this_ptr, val);
31110 // debug statements here
31112 // MUST_USE_RES struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_new(struct LDKNodeFeatures features_arg, uint32_t last_update_arg, struct LDKThreeBytes rgb_arg, struct LDKNodeAlias alias_arg, struct LDKCVec_NetAddressZ addresses_arg, struct LDKNodeAnnouncement announcement_message_arg);
31114 export function NodeAnnouncementInfo_new(features_arg: bigint, last_update_arg: number, rgb_arg: number, alias_arg: bigint, addresses_arg: number, announcement_message_arg: bigint): bigint {
31115 if(!isWasmInitialized) {
31116 throw new Error("initializeWasm() must be awaited first!");
31118 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_new(features_arg, last_update_arg, rgb_arg, alias_arg, addresses_arg, announcement_message_arg);
31119 return nativeResponseValue;
31121 // uint64_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg);
31123 export function NodeAnnouncementInfo_clone_ptr(arg: bigint): bigint {
31124 if(!isWasmInitialized) {
31125 throw new Error("initializeWasm() must be awaited first!");
31127 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone_ptr(arg);
31128 return nativeResponseValue;
31130 // struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
31132 export function NodeAnnouncementInfo_clone(orig: bigint): bigint {
31133 if(!isWasmInitialized) {
31134 throw new Error("initializeWasm() must be awaited first!");
31136 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone(orig);
31137 return nativeResponseValue;
31139 // struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementInfo *NONNULL_PTR obj);
31141 export function NodeAnnouncementInfo_write(obj: bigint): number {
31142 if(!isWasmInitialized) {
31143 throw new Error("initializeWasm() must be awaited first!");
31145 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_write(obj);
31146 return nativeResponseValue;
31148 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ NodeAnnouncementInfo_read(struct LDKu8slice ser);
31150 export function NodeAnnouncementInfo_read(ser: number): bigint {
31151 if(!isWasmInitialized) {
31152 throw new Error("initializeWasm() must be awaited first!");
31154 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_read(ser);
31155 return nativeResponseValue;
31157 // void NodeAlias_free(struct LDKNodeAlias this_obj);
31159 export function NodeAlias_free(this_obj: bigint): void {
31160 if(!isWasmInitialized) {
31161 throw new Error("initializeWasm() must be awaited first!");
31163 const nativeResponseValue = wasm.TS_NodeAlias_free(this_obj);
31164 // debug statements here
31166 // const uint8_t (*NodeAlias_get_a(const struct LDKNodeAlias *NONNULL_PTR this_ptr))[32];
31168 export function NodeAlias_get_a(this_ptr: bigint): number {
31169 if(!isWasmInitialized) {
31170 throw new Error("initializeWasm() must be awaited first!");
31172 const nativeResponseValue = wasm.TS_NodeAlias_get_a(this_ptr);
31173 return nativeResponseValue;
31175 // void NodeAlias_set_a(struct LDKNodeAlias *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31177 export function NodeAlias_set_a(this_ptr: bigint, val: number): void {
31178 if(!isWasmInitialized) {
31179 throw new Error("initializeWasm() must be awaited first!");
31181 const nativeResponseValue = wasm.TS_NodeAlias_set_a(this_ptr, val);
31182 // debug statements here
31184 // MUST_USE_RES struct LDKNodeAlias NodeAlias_new(struct LDKThirtyTwoBytes a_arg);
31186 export function NodeAlias_new(a_arg: number): bigint {
31187 if(!isWasmInitialized) {
31188 throw new Error("initializeWasm() must be awaited first!");
31190 const nativeResponseValue = wasm.TS_NodeAlias_new(a_arg);
31191 return nativeResponseValue;
31193 // uint64_t NodeAlias_clone_ptr(LDKNodeAlias *NONNULL_PTR arg);
31195 export function NodeAlias_clone_ptr(arg: bigint): bigint {
31196 if(!isWasmInitialized) {
31197 throw new Error("initializeWasm() must be awaited first!");
31199 const nativeResponseValue = wasm.TS_NodeAlias_clone_ptr(arg);
31200 return nativeResponseValue;
31202 // struct LDKNodeAlias NodeAlias_clone(const struct LDKNodeAlias *NONNULL_PTR orig);
31204 export function NodeAlias_clone(orig: bigint): bigint {
31205 if(!isWasmInitialized) {
31206 throw new Error("initializeWasm() must be awaited first!");
31208 const nativeResponseValue = wasm.TS_NodeAlias_clone(orig);
31209 return nativeResponseValue;
31211 // struct LDKCVec_u8Z NodeAlias_write(const struct LDKNodeAlias *NONNULL_PTR obj);
31213 export function NodeAlias_write(obj: bigint): number {
31214 if(!isWasmInitialized) {
31215 throw new Error("initializeWasm() must be awaited first!");
31217 const nativeResponseValue = wasm.TS_NodeAlias_write(obj);
31218 return nativeResponseValue;
31220 // struct LDKCResult_NodeAliasDecodeErrorZ NodeAlias_read(struct LDKu8slice ser);
31222 export function NodeAlias_read(ser: number): bigint {
31223 if(!isWasmInitialized) {
31224 throw new Error("initializeWasm() must be awaited first!");
31226 const nativeResponseValue = wasm.TS_NodeAlias_read(ser);
31227 return nativeResponseValue;
31229 // void NodeInfo_free(struct LDKNodeInfo this_obj);
31231 export function NodeInfo_free(this_obj: bigint): void {
31232 if(!isWasmInitialized) {
31233 throw new Error("initializeWasm() must be awaited first!");
31235 const nativeResponseValue = wasm.TS_NodeInfo_free(this_obj);
31236 // debug statements here
31238 // struct LDKCVec_u64Z NodeInfo_get_channels(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
31240 export function NodeInfo_get_channels(this_ptr: bigint): number {
31241 if(!isWasmInitialized) {
31242 throw new Error("initializeWasm() must be awaited first!");
31244 const nativeResponseValue = wasm.TS_NodeInfo_get_channels(this_ptr);
31245 return nativeResponseValue;
31247 // void NodeInfo_set_channels(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
31249 export function NodeInfo_set_channels(this_ptr: bigint, val: number): void {
31250 if(!isWasmInitialized) {
31251 throw new Error("initializeWasm() must be awaited first!");
31253 const nativeResponseValue = wasm.TS_NodeInfo_set_channels(this_ptr, val);
31254 // debug statements here
31256 // struct LDKRoutingFees NodeInfo_get_lowest_inbound_channel_fees(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
31258 export function NodeInfo_get_lowest_inbound_channel_fees(this_ptr: bigint): bigint {
31259 if(!isWasmInitialized) {
31260 throw new Error("initializeWasm() must be awaited first!");
31262 const nativeResponseValue = wasm.TS_NodeInfo_get_lowest_inbound_channel_fees(this_ptr);
31263 return nativeResponseValue;
31265 // void NodeInfo_set_lowest_inbound_channel_fees(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
31267 export function NodeInfo_set_lowest_inbound_channel_fees(this_ptr: bigint, val: bigint): void {
31268 if(!isWasmInitialized) {
31269 throw new Error("initializeWasm() must be awaited first!");
31271 const nativeResponseValue = wasm.TS_NodeInfo_set_lowest_inbound_channel_fees(this_ptr, val);
31272 // debug statements here
31274 // struct LDKNodeAnnouncementInfo NodeInfo_get_announcement_info(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
31276 export function NodeInfo_get_announcement_info(this_ptr: bigint): bigint {
31277 if(!isWasmInitialized) {
31278 throw new Error("initializeWasm() must be awaited first!");
31280 const nativeResponseValue = wasm.TS_NodeInfo_get_announcement_info(this_ptr);
31281 return nativeResponseValue;
31283 // void NodeInfo_set_announcement_info(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncementInfo val);
31285 export function NodeInfo_set_announcement_info(this_ptr: bigint, val: bigint): void {
31286 if(!isWasmInitialized) {
31287 throw new Error("initializeWasm() must be awaited first!");
31289 const nativeResponseValue = wasm.TS_NodeInfo_set_announcement_info(this_ptr, val);
31290 // debug statements here
31292 // MUST_USE_RES struct LDKNodeInfo NodeInfo_new(struct LDKCVec_u64Z channels_arg, struct LDKRoutingFees lowest_inbound_channel_fees_arg, struct LDKNodeAnnouncementInfo announcement_info_arg);
31294 export function NodeInfo_new(channels_arg: number, lowest_inbound_channel_fees_arg: bigint, announcement_info_arg: bigint): bigint {
31295 if(!isWasmInitialized) {
31296 throw new Error("initializeWasm() must be awaited first!");
31298 const nativeResponseValue = wasm.TS_NodeInfo_new(channels_arg, lowest_inbound_channel_fees_arg, announcement_info_arg);
31299 return nativeResponseValue;
31301 // uint64_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg);
31303 export function NodeInfo_clone_ptr(arg: bigint): bigint {
31304 if(!isWasmInitialized) {
31305 throw new Error("initializeWasm() must be awaited first!");
31307 const nativeResponseValue = wasm.TS_NodeInfo_clone_ptr(arg);
31308 return nativeResponseValue;
31310 // struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
31312 export function NodeInfo_clone(orig: bigint): bigint {
31313 if(!isWasmInitialized) {
31314 throw new Error("initializeWasm() must be awaited first!");
31316 const nativeResponseValue = wasm.TS_NodeInfo_clone(orig);
31317 return nativeResponseValue;
31319 // struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
31321 export function NodeInfo_write(obj: bigint): number {
31322 if(!isWasmInitialized) {
31323 throw new Error("initializeWasm() must be awaited first!");
31325 const nativeResponseValue = wasm.TS_NodeInfo_write(obj);
31326 return nativeResponseValue;
31328 // struct LDKCResult_NodeInfoDecodeErrorZ NodeInfo_read(struct LDKu8slice ser);
31330 export function NodeInfo_read(ser: number): bigint {
31331 if(!isWasmInitialized) {
31332 throw new Error("initializeWasm() must be awaited first!");
31334 const nativeResponseValue = wasm.TS_NodeInfo_read(ser);
31335 return nativeResponseValue;
31337 // struct LDKCVec_u8Z NetworkGraph_write(const struct LDKNetworkGraph *NONNULL_PTR obj);
31339 export function NetworkGraph_write(obj: bigint): number {
31340 if(!isWasmInitialized) {
31341 throw new Error("initializeWasm() must be awaited first!");
31343 const nativeResponseValue = wasm.TS_NetworkGraph_write(obj);
31344 return nativeResponseValue;
31346 // struct LDKCResult_NetworkGraphDecodeErrorZ NetworkGraph_read(struct LDKu8slice ser, struct LDKLogger arg);
31348 export function NetworkGraph_read(ser: number, arg: bigint): bigint {
31349 if(!isWasmInitialized) {
31350 throw new Error("initializeWasm() must be awaited first!");
31352 const nativeResponseValue = wasm.TS_NetworkGraph_read(ser, arg);
31353 return nativeResponseValue;
31355 // MUST_USE_RES struct LDKNetworkGraph NetworkGraph_new(struct LDKThirtyTwoBytes genesis_hash, struct LDKLogger logger);
31357 export function NetworkGraph_new(genesis_hash: number, logger: bigint): bigint {
31358 if(!isWasmInitialized) {
31359 throw new Error("initializeWasm() must be awaited first!");
31361 const nativeResponseValue = wasm.TS_NetworkGraph_new(genesis_hash, logger);
31362 return nativeResponseValue;
31364 // MUST_USE_RES struct LDKReadOnlyNetworkGraph NetworkGraph_read_only(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
31366 export function NetworkGraph_read_only(this_arg: bigint): bigint {
31367 if(!isWasmInitialized) {
31368 throw new Error("initializeWasm() must be awaited first!");
31370 const nativeResponseValue = wasm.TS_NetworkGraph_read_only(this_arg);
31371 return nativeResponseValue;
31373 // MUST_USE_RES struct LDKCOption_u32Z NetworkGraph_get_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
31375 export function NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg: bigint): bigint {
31376 if(!isWasmInitialized) {
31377 throw new Error("initializeWasm() must be awaited first!");
31379 const nativeResponseValue = wasm.TS_NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg);
31380 return nativeResponseValue;
31382 // void NetworkGraph_set_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint32_t last_rapid_gossip_sync_timestamp);
31384 export function NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg: bigint, last_rapid_gossip_sync_timestamp: number): void {
31385 if(!isWasmInitialized) {
31386 throw new Error("initializeWasm() must be awaited first!");
31388 const nativeResponseValue = wasm.TS_NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg, last_rapid_gossip_sync_timestamp);
31389 // debug statements here
31391 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
31393 export function NetworkGraph_update_node_from_announcement(this_arg: bigint, msg: bigint): bigint {
31394 if(!isWasmInitialized) {
31395 throw new Error("initializeWasm() must be awaited first!");
31397 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_announcement(this_arg, msg);
31398 return nativeResponseValue;
31400 // 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);
31402 export function NetworkGraph_update_node_from_unsigned_announcement(this_arg: bigint, msg: bigint): bigint {
31403 if(!isWasmInitialized) {
31404 throw new Error("initializeWasm() must be awaited first!");
31406 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_unsigned_announcement(this_arg, msg);
31407 return nativeResponseValue;
31409 // 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);
31411 export function NetworkGraph_update_channel_from_announcement(this_arg: bigint, msg: bigint, chain_access: bigint): bigint {
31412 if(!isWasmInitialized) {
31413 throw new Error("initializeWasm() must be awaited first!");
31415 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement(this_arg, msg, chain_access);
31416 return nativeResponseValue;
31418 // 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);
31420 export function NetworkGraph_update_channel_from_unsigned_announcement(this_arg: bigint, msg: bigint, chain_access: bigint): bigint {
31421 if(!isWasmInitialized) {
31422 throw new Error("initializeWasm() must be awaited first!");
31424 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_unsigned_announcement(this_arg, msg, chain_access);
31425 return nativeResponseValue;
31427 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_add_channel_from_partial_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id, uint64_t timestamp, struct LDKChannelFeatures features, struct LDKPublicKey node_id_1, struct LDKPublicKey node_id_2);
31429 export function NetworkGraph_add_channel_from_partial_announcement(this_arg: bigint, short_channel_id: bigint, timestamp: bigint, features: bigint, node_id_1: number, node_id_2: number): bigint {
31430 if(!isWasmInitialized) {
31431 throw new Error("initializeWasm() must be awaited first!");
31433 const nativeResponseValue = wasm.TS_NetworkGraph_add_channel_from_partial_announcement(this_arg, short_channel_id, timestamp, features, node_id_1, node_id_2);
31434 return nativeResponseValue;
31436 // void NetworkGraph_channel_failed(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id, bool is_permanent);
31438 export function NetworkGraph_channel_failed(this_arg: bigint, short_channel_id: bigint, is_permanent: boolean): void {
31439 if(!isWasmInitialized) {
31440 throw new Error("initializeWasm() must be awaited first!");
31442 const nativeResponseValue = wasm.TS_NetworkGraph_channel_failed(this_arg, short_channel_id, is_permanent);
31443 // debug statements here
31445 // void NetworkGraph_node_failed(const struct LDKNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey _node_id, bool is_permanent);
31447 export function NetworkGraph_node_failed(this_arg: bigint, _node_id: number, is_permanent: boolean): void {
31448 if(!isWasmInitialized) {
31449 throw new Error("initializeWasm() must be awaited first!");
31451 const nativeResponseValue = wasm.TS_NetworkGraph_node_failed(this_arg, _node_id, is_permanent);
31452 // debug statements here
31454 // void NetworkGraph_remove_stale_channels_with_time(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t current_time_unix);
31456 export function NetworkGraph_remove_stale_channels_with_time(this_arg: bigint, current_time_unix: bigint): void {
31457 if(!isWasmInitialized) {
31458 throw new Error("initializeWasm() must be awaited first!");
31460 const nativeResponseValue = wasm.TS_NetworkGraph_remove_stale_channels_with_time(this_arg, current_time_unix);
31461 // debug statements here
31463 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
31465 export function NetworkGraph_update_channel(this_arg: bigint, msg: bigint): bigint {
31466 if(!isWasmInitialized) {
31467 throw new Error("initializeWasm() must be awaited first!");
31469 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel(this_arg, msg);
31470 return nativeResponseValue;
31472 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_unsigned(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelUpdate *NONNULL_PTR msg);
31474 export function NetworkGraph_update_channel_unsigned(this_arg: bigint, msg: bigint): bigint {
31475 if(!isWasmInitialized) {
31476 throw new Error("initializeWasm() must be awaited first!");
31478 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_unsigned(this_arg, msg);
31479 return nativeResponseValue;
31481 // MUST_USE_RES struct LDKChannelInfo ReadOnlyNetworkGraph_channel(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id);
31483 export function ReadOnlyNetworkGraph_channel(this_arg: bigint, short_channel_id: bigint): bigint {
31484 if(!isWasmInitialized) {
31485 throw new Error("initializeWasm() must be awaited first!");
31487 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_channel(this_arg, short_channel_id);
31488 return nativeResponseValue;
31490 // MUST_USE_RES struct LDKCVec_u64Z ReadOnlyNetworkGraph_list_channels(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg);
31492 export function ReadOnlyNetworkGraph_list_channels(this_arg: bigint): number {
31493 if(!isWasmInitialized) {
31494 throw new Error("initializeWasm() must be awaited first!");
31496 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_list_channels(this_arg);
31497 return nativeResponseValue;
31499 // MUST_USE_RES struct LDKNodeInfo ReadOnlyNetworkGraph_node(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
31501 export function ReadOnlyNetworkGraph_node(this_arg: bigint, node_id: bigint): bigint {
31502 if(!isWasmInitialized) {
31503 throw new Error("initializeWasm() must be awaited first!");
31505 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_node(this_arg, node_id);
31506 return nativeResponseValue;
31508 // MUST_USE_RES struct LDKCVec_NodeIdZ ReadOnlyNetworkGraph_list_nodes(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg);
31510 export function ReadOnlyNetworkGraph_list_nodes(this_arg: bigint): number {
31511 if(!isWasmInitialized) {
31512 throw new Error("initializeWasm() must be awaited first!");
31514 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_list_nodes(this_arg);
31515 return nativeResponseValue;
31517 // MUST_USE_RES struct LDKCOption_CVec_NetAddressZZ ReadOnlyNetworkGraph_get_addresses(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey pubkey);
31519 export function ReadOnlyNetworkGraph_get_addresses(this_arg: bigint, pubkey: number): bigint {
31520 if(!isWasmInitialized) {
31521 throw new Error("initializeWasm() must be awaited first!");
31523 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_get_addresses(this_arg, pubkey);
31524 return nativeResponseValue;
31526 // void RouteHop_free(struct LDKRouteHop this_obj);
31528 export function RouteHop_free(this_obj: bigint): void {
31529 if(!isWasmInitialized) {
31530 throw new Error("initializeWasm() must be awaited first!");
31532 const nativeResponseValue = wasm.TS_RouteHop_free(this_obj);
31533 // debug statements here
31535 // struct LDKPublicKey RouteHop_get_pubkey(const struct LDKRouteHop *NONNULL_PTR this_ptr);
31537 export function RouteHop_get_pubkey(this_ptr: bigint): number {
31538 if(!isWasmInitialized) {
31539 throw new Error("initializeWasm() must be awaited first!");
31541 const nativeResponseValue = wasm.TS_RouteHop_get_pubkey(this_ptr);
31542 return nativeResponseValue;
31544 // void RouteHop_set_pubkey(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31546 export function RouteHop_set_pubkey(this_ptr: bigint, val: number): void {
31547 if(!isWasmInitialized) {
31548 throw new Error("initializeWasm() must be awaited first!");
31550 const nativeResponseValue = wasm.TS_RouteHop_set_pubkey(this_ptr, val);
31551 // debug statements here
31553 // struct LDKNodeFeatures RouteHop_get_node_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
31555 export function RouteHop_get_node_features(this_ptr: bigint): bigint {
31556 if(!isWasmInitialized) {
31557 throw new Error("initializeWasm() must be awaited first!");
31559 const nativeResponseValue = wasm.TS_RouteHop_get_node_features(this_ptr);
31560 return nativeResponseValue;
31562 // void RouteHop_set_node_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
31564 export function RouteHop_set_node_features(this_ptr: bigint, val: bigint): void {
31565 if(!isWasmInitialized) {
31566 throw new Error("initializeWasm() must be awaited first!");
31568 const nativeResponseValue = wasm.TS_RouteHop_set_node_features(this_ptr, val);
31569 // debug statements here
31571 // uint64_t RouteHop_get_short_channel_id(const struct LDKRouteHop *NONNULL_PTR this_ptr);
31573 export function RouteHop_get_short_channel_id(this_ptr: bigint): bigint {
31574 if(!isWasmInitialized) {
31575 throw new Error("initializeWasm() must be awaited first!");
31577 const nativeResponseValue = wasm.TS_RouteHop_get_short_channel_id(this_ptr);
31578 return nativeResponseValue;
31580 // void RouteHop_set_short_channel_id(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
31582 export function RouteHop_set_short_channel_id(this_ptr: bigint, val: bigint): void {
31583 if(!isWasmInitialized) {
31584 throw new Error("initializeWasm() must be awaited first!");
31586 const nativeResponseValue = wasm.TS_RouteHop_set_short_channel_id(this_ptr, val);
31587 // debug statements here
31589 // struct LDKChannelFeatures RouteHop_get_channel_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
31591 export function RouteHop_get_channel_features(this_ptr: bigint): bigint {
31592 if(!isWasmInitialized) {
31593 throw new Error("initializeWasm() must be awaited first!");
31595 const nativeResponseValue = wasm.TS_RouteHop_get_channel_features(this_ptr);
31596 return nativeResponseValue;
31598 // void RouteHop_set_channel_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
31600 export function RouteHop_set_channel_features(this_ptr: bigint, val: bigint): void {
31601 if(!isWasmInitialized) {
31602 throw new Error("initializeWasm() must be awaited first!");
31604 const nativeResponseValue = wasm.TS_RouteHop_set_channel_features(this_ptr, val);
31605 // debug statements here
31607 // uint64_t RouteHop_get_fee_msat(const struct LDKRouteHop *NONNULL_PTR this_ptr);
31609 export function RouteHop_get_fee_msat(this_ptr: bigint): bigint {
31610 if(!isWasmInitialized) {
31611 throw new Error("initializeWasm() must be awaited first!");
31613 const nativeResponseValue = wasm.TS_RouteHop_get_fee_msat(this_ptr);
31614 return nativeResponseValue;
31616 // void RouteHop_set_fee_msat(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
31618 export function RouteHop_set_fee_msat(this_ptr: bigint, val: bigint): void {
31619 if(!isWasmInitialized) {
31620 throw new Error("initializeWasm() must be awaited first!");
31622 const nativeResponseValue = wasm.TS_RouteHop_set_fee_msat(this_ptr, val);
31623 // debug statements here
31625 // uint32_t RouteHop_get_cltv_expiry_delta(const struct LDKRouteHop *NONNULL_PTR this_ptr);
31627 export function RouteHop_get_cltv_expiry_delta(this_ptr: bigint): number {
31628 if(!isWasmInitialized) {
31629 throw new Error("initializeWasm() must be awaited first!");
31631 const nativeResponseValue = wasm.TS_RouteHop_get_cltv_expiry_delta(this_ptr);
31632 return nativeResponseValue;
31634 // void RouteHop_set_cltv_expiry_delta(struct LDKRouteHop *NONNULL_PTR this_ptr, uint32_t val);
31636 export function RouteHop_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
31637 if(!isWasmInitialized) {
31638 throw new Error("initializeWasm() must be awaited first!");
31640 const nativeResponseValue = wasm.TS_RouteHop_set_cltv_expiry_delta(this_ptr, val);
31641 // debug statements here
31643 // 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);
31645 export function RouteHop_new(pubkey_arg: number, node_features_arg: bigint, short_channel_id_arg: bigint, channel_features_arg: bigint, fee_msat_arg: bigint, cltv_expiry_delta_arg: number): bigint {
31646 if(!isWasmInitialized) {
31647 throw new Error("initializeWasm() must be awaited first!");
31649 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);
31650 return nativeResponseValue;
31652 // uint64_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg);
31654 export function RouteHop_clone_ptr(arg: bigint): bigint {
31655 if(!isWasmInitialized) {
31656 throw new Error("initializeWasm() must be awaited first!");
31658 const nativeResponseValue = wasm.TS_RouteHop_clone_ptr(arg);
31659 return nativeResponseValue;
31661 // struct LDKRouteHop RouteHop_clone(const struct LDKRouteHop *NONNULL_PTR orig);
31663 export function RouteHop_clone(orig: bigint): bigint {
31664 if(!isWasmInitialized) {
31665 throw new Error("initializeWasm() must be awaited first!");
31667 const nativeResponseValue = wasm.TS_RouteHop_clone(orig);
31668 return nativeResponseValue;
31670 // uint64_t RouteHop_hash(const struct LDKRouteHop *NONNULL_PTR o);
31672 export function RouteHop_hash(o: bigint): bigint {
31673 if(!isWasmInitialized) {
31674 throw new Error("initializeWasm() must be awaited first!");
31676 const nativeResponseValue = wasm.TS_RouteHop_hash(o);
31677 return nativeResponseValue;
31679 // bool RouteHop_eq(const struct LDKRouteHop *NONNULL_PTR a, const struct LDKRouteHop *NONNULL_PTR b);
31681 export function RouteHop_eq(a: bigint, b: bigint): boolean {
31682 if(!isWasmInitialized) {
31683 throw new Error("initializeWasm() must be awaited first!");
31685 const nativeResponseValue = wasm.TS_RouteHop_eq(a, b);
31686 return nativeResponseValue;
31688 // struct LDKCVec_u8Z RouteHop_write(const struct LDKRouteHop *NONNULL_PTR obj);
31690 export function RouteHop_write(obj: bigint): number {
31691 if(!isWasmInitialized) {
31692 throw new Error("initializeWasm() must be awaited first!");
31694 const nativeResponseValue = wasm.TS_RouteHop_write(obj);
31695 return nativeResponseValue;
31697 // struct LDKCResult_RouteHopDecodeErrorZ RouteHop_read(struct LDKu8slice ser);
31699 export function RouteHop_read(ser: number): bigint {
31700 if(!isWasmInitialized) {
31701 throw new Error("initializeWasm() must be awaited first!");
31703 const nativeResponseValue = wasm.TS_RouteHop_read(ser);
31704 return nativeResponseValue;
31706 // void Route_free(struct LDKRoute this_obj);
31708 export function Route_free(this_obj: bigint): void {
31709 if(!isWasmInitialized) {
31710 throw new Error("initializeWasm() must be awaited first!");
31712 const nativeResponseValue = wasm.TS_Route_free(this_obj);
31713 // debug statements here
31715 // struct LDKCVec_CVec_RouteHopZZ Route_get_paths(const struct LDKRoute *NONNULL_PTR this_ptr);
31717 export function Route_get_paths(this_ptr: bigint): number {
31718 if(!isWasmInitialized) {
31719 throw new Error("initializeWasm() must be awaited first!");
31721 const nativeResponseValue = wasm.TS_Route_get_paths(this_ptr);
31722 return nativeResponseValue;
31724 // void Route_set_paths(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKCVec_CVec_RouteHopZZ val);
31726 export function Route_set_paths(this_ptr: bigint, val: number): void {
31727 if(!isWasmInitialized) {
31728 throw new Error("initializeWasm() must be awaited first!");
31730 const nativeResponseValue = wasm.TS_Route_set_paths(this_ptr, val);
31731 // debug statements here
31733 // struct LDKPaymentParameters Route_get_payment_params(const struct LDKRoute *NONNULL_PTR this_ptr);
31735 export function Route_get_payment_params(this_ptr: bigint): bigint {
31736 if(!isWasmInitialized) {
31737 throw new Error("initializeWasm() must be awaited first!");
31739 const nativeResponseValue = wasm.TS_Route_get_payment_params(this_ptr);
31740 return nativeResponseValue;
31742 // void Route_set_payment_params(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
31744 export function Route_set_payment_params(this_ptr: bigint, val: bigint): void {
31745 if(!isWasmInitialized) {
31746 throw new Error("initializeWasm() must be awaited first!");
31748 const nativeResponseValue = wasm.TS_Route_set_payment_params(this_ptr, val);
31749 // debug statements here
31751 // MUST_USE_RES struct LDKRoute Route_new(struct LDKCVec_CVec_RouteHopZZ paths_arg, struct LDKPaymentParameters payment_params_arg);
31753 export function Route_new(paths_arg: number, payment_params_arg: bigint): bigint {
31754 if(!isWasmInitialized) {
31755 throw new Error("initializeWasm() must be awaited first!");
31757 const nativeResponseValue = wasm.TS_Route_new(paths_arg, payment_params_arg);
31758 return nativeResponseValue;
31760 // uint64_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg);
31762 export function Route_clone_ptr(arg: bigint): bigint {
31763 if(!isWasmInitialized) {
31764 throw new Error("initializeWasm() must be awaited first!");
31766 const nativeResponseValue = wasm.TS_Route_clone_ptr(arg);
31767 return nativeResponseValue;
31769 // struct LDKRoute Route_clone(const struct LDKRoute *NONNULL_PTR orig);
31771 export function Route_clone(orig: bigint): bigint {
31772 if(!isWasmInitialized) {
31773 throw new Error("initializeWasm() must be awaited first!");
31775 const nativeResponseValue = wasm.TS_Route_clone(orig);
31776 return nativeResponseValue;
31778 // uint64_t Route_hash(const struct LDKRoute *NONNULL_PTR o);
31780 export function Route_hash(o: bigint): bigint {
31781 if(!isWasmInitialized) {
31782 throw new Error("initializeWasm() must be awaited first!");
31784 const nativeResponseValue = wasm.TS_Route_hash(o);
31785 return nativeResponseValue;
31787 // bool Route_eq(const struct LDKRoute *NONNULL_PTR a, const struct LDKRoute *NONNULL_PTR b);
31789 export function Route_eq(a: bigint, b: bigint): boolean {
31790 if(!isWasmInitialized) {
31791 throw new Error("initializeWasm() must be awaited first!");
31793 const nativeResponseValue = wasm.TS_Route_eq(a, b);
31794 return nativeResponseValue;
31796 // MUST_USE_RES uint64_t Route_get_total_fees(const struct LDKRoute *NONNULL_PTR this_arg);
31798 export function Route_get_total_fees(this_arg: bigint): bigint {
31799 if(!isWasmInitialized) {
31800 throw new Error("initializeWasm() must be awaited first!");
31802 const nativeResponseValue = wasm.TS_Route_get_total_fees(this_arg);
31803 return nativeResponseValue;
31805 // MUST_USE_RES uint64_t Route_get_total_amount(const struct LDKRoute *NONNULL_PTR this_arg);
31807 export function Route_get_total_amount(this_arg: bigint): bigint {
31808 if(!isWasmInitialized) {
31809 throw new Error("initializeWasm() must be awaited first!");
31811 const nativeResponseValue = wasm.TS_Route_get_total_amount(this_arg);
31812 return nativeResponseValue;
31814 // struct LDKCVec_u8Z Route_write(const struct LDKRoute *NONNULL_PTR obj);
31816 export function Route_write(obj: bigint): number {
31817 if(!isWasmInitialized) {
31818 throw new Error("initializeWasm() must be awaited first!");
31820 const nativeResponseValue = wasm.TS_Route_write(obj);
31821 return nativeResponseValue;
31823 // struct LDKCResult_RouteDecodeErrorZ Route_read(struct LDKu8slice ser);
31825 export function Route_read(ser: number): bigint {
31826 if(!isWasmInitialized) {
31827 throw new Error("initializeWasm() must be awaited first!");
31829 const nativeResponseValue = wasm.TS_Route_read(ser);
31830 return nativeResponseValue;
31832 // void RouteParameters_free(struct LDKRouteParameters this_obj);
31834 export function RouteParameters_free(this_obj: bigint): void {
31835 if(!isWasmInitialized) {
31836 throw new Error("initializeWasm() must be awaited first!");
31838 const nativeResponseValue = wasm.TS_RouteParameters_free(this_obj);
31839 // debug statements here
31841 // struct LDKPaymentParameters RouteParameters_get_payment_params(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
31843 export function RouteParameters_get_payment_params(this_ptr: bigint): bigint {
31844 if(!isWasmInitialized) {
31845 throw new Error("initializeWasm() must be awaited first!");
31847 const nativeResponseValue = wasm.TS_RouteParameters_get_payment_params(this_ptr);
31848 return nativeResponseValue;
31850 // void RouteParameters_set_payment_params(struct LDKRouteParameters *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
31852 export function RouteParameters_set_payment_params(this_ptr: bigint, val: bigint): void {
31853 if(!isWasmInitialized) {
31854 throw new Error("initializeWasm() must be awaited first!");
31856 const nativeResponseValue = wasm.TS_RouteParameters_set_payment_params(this_ptr, val);
31857 // debug statements here
31859 // uint64_t RouteParameters_get_final_value_msat(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
31861 export function RouteParameters_get_final_value_msat(this_ptr: bigint): bigint {
31862 if(!isWasmInitialized) {
31863 throw new Error("initializeWasm() must be awaited first!");
31865 const nativeResponseValue = wasm.TS_RouteParameters_get_final_value_msat(this_ptr);
31866 return nativeResponseValue;
31868 // void RouteParameters_set_final_value_msat(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint64_t val);
31870 export function RouteParameters_set_final_value_msat(this_ptr: bigint, val: bigint): void {
31871 if(!isWasmInitialized) {
31872 throw new Error("initializeWasm() must be awaited first!");
31874 const nativeResponseValue = wasm.TS_RouteParameters_set_final_value_msat(this_ptr, val);
31875 // debug statements here
31877 // uint32_t RouteParameters_get_final_cltv_expiry_delta(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
31879 export function RouteParameters_get_final_cltv_expiry_delta(this_ptr: bigint): number {
31880 if(!isWasmInitialized) {
31881 throw new Error("initializeWasm() must be awaited first!");
31883 const nativeResponseValue = wasm.TS_RouteParameters_get_final_cltv_expiry_delta(this_ptr);
31884 return nativeResponseValue;
31886 // void RouteParameters_set_final_cltv_expiry_delta(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint32_t val);
31888 export function RouteParameters_set_final_cltv_expiry_delta(this_ptr: bigint, val: number): void {
31889 if(!isWasmInitialized) {
31890 throw new Error("initializeWasm() must be awaited first!");
31892 const nativeResponseValue = wasm.TS_RouteParameters_set_final_cltv_expiry_delta(this_ptr, val);
31893 // debug statements here
31895 // 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);
31897 export function RouteParameters_new(payment_params_arg: bigint, final_value_msat_arg: bigint, final_cltv_expiry_delta_arg: number): bigint {
31898 if(!isWasmInitialized) {
31899 throw new Error("initializeWasm() must be awaited first!");
31901 const nativeResponseValue = wasm.TS_RouteParameters_new(payment_params_arg, final_value_msat_arg, final_cltv_expiry_delta_arg);
31902 return nativeResponseValue;
31904 // uint64_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg);
31906 export function RouteParameters_clone_ptr(arg: bigint): bigint {
31907 if(!isWasmInitialized) {
31908 throw new Error("initializeWasm() must be awaited first!");
31910 const nativeResponseValue = wasm.TS_RouteParameters_clone_ptr(arg);
31911 return nativeResponseValue;
31913 // struct LDKRouteParameters RouteParameters_clone(const struct LDKRouteParameters *NONNULL_PTR orig);
31915 export function RouteParameters_clone(orig: bigint): bigint {
31916 if(!isWasmInitialized) {
31917 throw new Error("initializeWasm() must be awaited first!");
31919 const nativeResponseValue = wasm.TS_RouteParameters_clone(orig);
31920 return nativeResponseValue;
31922 // struct LDKCVec_u8Z RouteParameters_write(const struct LDKRouteParameters *NONNULL_PTR obj);
31924 export function RouteParameters_write(obj: bigint): number {
31925 if(!isWasmInitialized) {
31926 throw new Error("initializeWasm() must be awaited first!");
31928 const nativeResponseValue = wasm.TS_RouteParameters_write(obj);
31929 return nativeResponseValue;
31931 // struct LDKCResult_RouteParametersDecodeErrorZ RouteParameters_read(struct LDKu8slice ser);
31933 export function RouteParameters_read(ser: number): bigint {
31934 if(!isWasmInitialized) {
31935 throw new Error("initializeWasm() must be awaited first!");
31937 const nativeResponseValue = wasm.TS_RouteParameters_read(ser);
31938 return nativeResponseValue;
31940 // void PaymentParameters_free(struct LDKPaymentParameters this_obj);
31942 export function PaymentParameters_free(this_obj: bigint): void {
31943 if(!isWasmInitialized) {
31944 throw new Error("initializeWasm() must be awaited first!");
31946 const nativeResponseValue = wasm.TS_PaymentParameters_free(this_obj);
31947 // debug statements here
31949 // struct LDKPublicKey PaymentParameters_get_payee_pubkey(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
31951 export function PaymentParameters_get_payee_pubkey(this_ptr: bigint): number {
31952 if(!isWasmInitialized) {
31953 throw new Error("initializeWasm() must be awaited first!");
31955 const nativeResponseValue = wasm.TS_PaymentParameters_get_payee_pubkey(this_ptr);
31956 return nativeResponseValue;
31958 // void PaymentParameters_set_payee_pubkey(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31960 export function PaymentParameters_set_payee_pubkey(this_ptr: bigint, val: number): void {
31961 if(!isWasmInitialized) {
31962 throw new Error("initializeWasm() must be awaited first!");
31964 const nativeResponseValue = wasm.TS_PaymentParameters_set_payee_pubkey(this_ptr, val);
31965 // debug statements here
31967 // struct LDKInvoiceFeatures PaymentParameters_get_features(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
31969 export function PaymentParameters_get_features(this_ptr: bigint): bigint {
31970 if(!isWasmInitialized) {
31971 throw new Error("initializeWasm() must be awaited first!");
31973 const nativeResponseValue = wasm.TS_PaymentParameters_get_features(this_ptr);
31974 return nativeResponseValue;
31976 // void PaymentParameters_set_features(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKInvoiceFeatures val);
31978 export function PaymentParameters_set_features(this_ptr: bigint, val: bigint): void {
31979 if(!isWasmInitialized) {
31980 throw new Error("initializeWasm() must be awaited first!");
31982 const nativeResponseValue = wasm.TS_PaymentParameters_set_features(this_ptr, val);
31983 // debug statements here
31985 // struct LDKCVec_RouteHintZ PaymentParameters_get_route_hints(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
31987 export function PaymentParameters_get_route_hints(this_ptr: bigint): number {
31988 if(!isWasmInitialized) {
31989 throw new Error("initializeWasm() must be awaited first!");
31991 const nativeResponseValue = wasm.TS_PaymentParameters_get_route_hints(this_ptr);
31992 return nativeResponseValue;
31994 // void PaymentParameters_set_route_hints(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintZ val);
31996 export function PaymentParameters_set_route_hints(this_ptr: bigint, val: number): void {
31997 if(!isWasmInitialized) {
31998 throw new Error("initializeWasm() must be awaited first!");
32000 const nativeResponseValue = wasm.TS_PaymentParameters_set_route_hints(this_ptr, val);
32001 // debug statements here
32003 // struct LDKCOption_u64Z PaymentParameters_get_expiry_time(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
32005 export function PaymentParameters_get_expiry_time(this_ptr: bigint): bigint {
32006 if(!isWasmInitialized) {
32007 throw new Error("initializeWasm() must be awaited first!");
32009 const nativeResponseValue = wasm.TS_PaymentParameters_get_expiry_time(this_ptr);
32010 return nativeResponseValue;
32012 // void PaymentParameters_set_expiry_time(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
32014 export function PaymentParameters_set_expiry_time(this_ptr: bigint, val: bigint): void {
32015 if(!isWasmInitialized) {
32016 throw new Error("initializeWasm() must be awaited first!");
32018 const nativeResponseValue = wasm.TS_PaymentParameters_set_expiry_time(this_ptr, val);
32019 // debug statements here
32021 // uint32_t PaymentParameters_get_max_total_cltv_expiry_delta(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
32023 export function PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr: bigint): number {
32024 if(!isWasmInitialized) {
32025 throw new Error("initializeWasm() must be awaited first!");
32027 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr);
32028 return nativeResponseValue;
32030 // void PaymentParameters_set_max_total_cltv_expiry_delta(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint32_t val);
32032 export function PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr: bigint, val: number): void {
32033 if(!isWasmInitialized) {
32034 throw new Error("initializeWasm() must be awaited first!");
32036 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr, val);
32037 // debug statements here
32039 // uint8_t PaymentParameters_get_max_path_count(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
32041 export function PaymentParameters_get_max_path_count(this_ptr: bigint): number {
32042 if(!isWasmInitialized) {
32043 throw new Error("initializeWasm() must be awaited first!");
32045 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_path_count(this_ptr);
32046 return nativeResponseValue;
32048 // void PaymentParameters_set_max_path_count(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
32050 export function PaymentParameters_set_max_path_count(this_ptr: bigint, val: number): void {
32051 if(!isWasmInitialized) {
32052 throw new Error("initializeWasm() must be awaited first!");
32054 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_path_count(this_ptr, val);
32055 // debug statements here
32057 // uint8_t PaymentParameters_get_max_channel_saturation_power_of_half(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
32059 export function PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr: bigint): number {
32060 if(!isWasmInitialized) {
32061 throw new Error("initializeWasm() must be awaited first!");
32063 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr);
32064 return nativeResponseValue;
32066 // void PaymentParameters_set_max_channel_saturation_power_of_half(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
32068 export function PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr: bigint, val: number): void {
32069 if(!isWasmInitialized) {
32070 throw new Error("initializeWasm() must be awaited first!");
32072 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr, val);
32073 // debug statements here
32075 // struct LDKCVec_u64Z PaymentParameters_get_previously_failed_channels(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
32077 export function PaymentParameters_get_previously_failed_channels(this_ptr: bigint): number {
32078 if(!isWasmInitialized) {
32079 throw new Error("initializeWasm() must be awaited first!");
32081 const nativeResponseValue = wasm.TS_PaymentParameters_get_previously_failed_channels(this_ptr);
32082 return nativeResponseValue;
32084 // void PaymentParameters_set_previously_failed_channels(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
32086 export function PaymentParameters_set_previously_failed_channels(this_ptr: bigint, val: number): void {
32087 if(!isWasmInitialized) {
32088 throw new Error("initializeWasm() must be awaited first!");
32090 const nativeResponseValue = wasm.TS_PaymentParameters_set_previously_failed_channels(this_ptr, val);
32091 // debug statements here
32093 // 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, uint8_t max_path_count_arg, uint8_t max_channel_saturation_power_of_half_arg, struct LDKCVec_u64Z previously_failed_channels_arg);
32095 export function PaymentParameters_new(payee_pubkey_arg: number, features_arg: bigint, route_hints_arg: number, expiry_time_arg: bigint, max_total_cltv_expiry_delta_arg: number, max_path_count_arg: number, max_channel_saturation_power_of_half_arg: number, previously_failed_channels_arg: number): bigint {
32096 if(!isWasmInitialized) {
32097 throw new Error("initializeWasm() must be awaited first!");
32099 const nativeResponseValue = wasm.TS_PaymentParameters_new(payee_pubkey_arg, features_arg, route_hints_arg, expiry_time_arg, max_total_cltv_expiry_delta_arg, max_path_count_arg, max_channel_saturation_power_of_half_arg, previously_failed_channels_arg);
32100 return nativeResponseValue;
32102 // uint64_t PaymentParameters_clone_ptr(LDKPaymentParameters *NONNULL_PTR arg);
32104 export function PaymentParameters_clone_ptr(arg: bigint): bigint {
32105 if(!isWasmInitialized) {
32106 throw new Error("initializeWasm() must be awaited first!");
32108 const nativeResponseValue = wasm.TS_PaymentParameters_clone_ptr(arg);
32109 return nativeResponseValue;
32111 // struct LDKPaymentParameters PaymentParameters_clone(const struct LDKPaymentParameters *NONNULL_PTR orig);
32113 export function PaymentParameters_clone(orig: bigint): bigint {
32114 if(!isWasmInitialized) {
32115 throw new Error("initializeWasm() must be awaited first!");
32117 const nativeResponseValue = wasm.TS_PaymentParameters_clone(orig);
32118 return nativeResponseValue;
32120 // uint64_t PaymentParameters_hash(const struct LDKPaymentParameters *NONNULL_PTR o);
32122 export function PaymentParameters_hash(o: bigint): bigint {
32123 if(!isWasmInitialized) {
32124 throw new Error("initializeWasm() must be awaited first!");
32126 const nativeResponseValue = wasm.TS_PaymentParameters_hash(o);
32127 return nativeResponseValue;
32129 // bool PaymentParameters_eq(const struct LDKPaymentParameters *NONNULL_PTR a, const struct LDKPaymentParameters *NONNULL_PTR b);
32131 export function PaymentParameters_eq(a: bigint, b: bigint): boolean {
32132 if(!isWasmInitialized) {
32133 throw new Error("initializeWasm() must be awaited first!");
32135 const nativeResponseValue = wasm.TS_PaymentParameters_eq(a, b);
32136 return nativeResponseValue;
32138 // struct LDKCVec_u8Z PaymentParameters_write(const struct LDKPaymentParameters *NONNULL_PTR obj);
32140 export function PaymentParameters_write(obj: bigint): number {
32141 if(!isWasmInitialized) {
32142 throw new Error("initializeWasm() must be awaited first!");
32144 const nativeResponseValue = wasm.TS_PaymentParameters_write(obj);
32145 return nativeResponseValue;
32147 // struct LDKCResult_PaymentParametersDecodeErrorZ PaymentParameters_read(struct LDKu8slice ser);
32149 export function PaymentParameters_read(ser: number): bigint {
32150 if(!isWasmInitialized) {
32151 throw new Error("initializeWasm() must be awaited first!");
32153 const nativeResponseValue = wasm.TS_PaymentParameters_read(ser);
32154 return nativeResponseValue;
32156 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_from_node_id(struct LDKPublicKey payee_pubkey);
32158 export function PaymentParameters_from_node_id(payee_pubkey: number): bigint {
32159 if(!isWasmInitialized) {
32160 throw new Error("initializeWasm() must be awaited first!");
32162 const nativeResponseValue = wasm.TS_PaymentParameters_from_node_id(payee_pubkey);
32163 return nativeResponseValue;
32165 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_for_keysend(struct LDKPublicKey payee_pubkey);
32167 export function PaymentParameters_for_keysend(payee_pubkey: number): bigint {
32168 if(!isWasmInitialized) {
32169 throw new Error("initializeWasm() must be awaited first!");
32171 const nativeResponseValue = wasm.TS_PaymentParameters_for_keysend(payee_pubkey);
32172 return nativeResponseValue;
32174 // void RouteHint_free(struct LDKRouteHint this_obj);
32176 export function RouteHint_free(this_obj: bigint): void {
32177 if(!isWasmInitialized) {
32178 throw new Error("initializeWasm() must be awaited first!");
32180 const nativeResponseValue = wasm.TS_RouteHint_free(this_obj);
32181 // debug statements here
32183 // struct LDKCVec_RouteHintHopZ RouteHint_get_a(const struct LDKRouteHint *NONNULL_PTR this_ptr);
32185 export function RouteHint_get_a(this_ptr: bigint): number {
32186 if(!isWasmInitialized) {
32187 throw new Error("initializeWasm() must be awaited first!");
32189 const nativeResponseValue = wasm.TS_RouteHint_get_a(this_ptr);
32190 return nativeResponseValue;
32192 // void RouteHint_set_a(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintHopZ val);
32194 export function RouteHint_set_a(this_ptr: bigint, val: number): void {
32195 if(!isWasmInitialized) {
32196 throw new Error("initializeWasm() must be awaited first!");
32198 const nativeResponseValue = wasm.TS_RouteHint_set_a(this_ptr, val);
32199 // debug statements here
32201 // MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKCVec_RouteHintHopZ a_arg);
32203 export function RouteHint_new(a_arg: number): bigint {
32204 if(!isWasmInitialized) {
32205 throw new Error("initializeWasm() must be awaited first!");
32207 const nativeResponseValue = wasm.TS_RouteHint_new(a_arg);
32208 return nativeResponseValue;
32210 // uint64_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg);
32212 export function RouteHint_clone_ptr(arg: bigint): bigint {
32213 if(!isWasmInitialized) {
32214 throw new Error("initializeWasm() must be awaited first!");
32216 const nativeResponseValue = wasm.TS_RouteHint_clone_ptr(arg);
32217 return nativeResponseValue;
32219 // struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
32221 export function RouteHint_clone(orig: bigint): bigint {
32222 if(!isWasmInitialized) {
32223 throw new Error("initializeWasm() must be awaited first!");
32225 const nativeResponseValue = wasm.TS_RouteHint_clone(orig);
32226 return nativeResponseValue;
32228 // uint64_t RouteHint_hash(const struct LDKRouteHint *NONNULL_PTR o);
32230 export function RouteHint_hash(o: bigint): bigint {
32231 if(!isWasmInitialized) {
32232 throw new Error("initializeWasm() must be awaited first!");
32234 const nativeResponseValue = wasm.TS_RouteHint_hash(o);
32235 return nativeResponseValue;
32237 // bool RouteHint_eq(const struct LDKRouteHint *NONNULL_PTR a, const struct LDKRouteHint *NONNULL_PTR b);
32239 export function RouteHint_eq(a: bigint, b: bigint): boolean {
32240 if(!isWasmInitialized) {
32241 throw new Error("initializeWasm() must be awaited first!");
32243 const nativeResponseValue = wasm.TS_RouteHint_eq(a, b);
32244 return nativeResponseValue;
32246 // struct LDKCVec_u8Z RouteHint_write(const struct LDKRouteHint *NONNULL_PTR obj);
32248 export function RouteHint_write(obj: bigint): number {
32249 if(!isWasmInitialized) {
32250 throw new Error("initializeWasm() must be awaited first!");
32252 const nativeResponseValue = wasm.TS_RouteHint_write(obj);
32253 return nativeResponseValue;
32255 // struct LDKCResult_RouteHintDecodeErrorZ RouteHint_read(struct LDKu8slice ser);
32257 export function RouteHint_read(ser: number): bigint {
32258 if(!isWasmInitialized) {
32259 throw new Error("initializeWasm() must be awaited first!");
32261 const nativeResponseValue = wasm.TS_RouteHint_read(ser);
32262 return nativeResponseValue;
32264 // void RouteHintHop_free(struct LDKRouteHintHop this_obj);
32266 export function RouteHintHop_free(this_obj: bigint): void {
32267 if(!isWasmInitialized) {
32268 throw new Error("initializeWasm() must be awaited first!");
32270 const nativeResponseValue = wasm.TS_RouteHintHop_free(this_obj);
32271 // debug statements here
32273 // struct LDKPublicKey RouteHintHop_get_src_node_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
32275 export function RouteHintHop_get_src_node_id(this_ptr: bigint): number {
32276 if(!isWasmInitialized) {
32277 throw new Error("initializeWasm() must be awaited first!");
32279 const nativeResponseValue = wasm.TS_RouteHintHop_get_src_node_id(this_ptr);
32280 return nativeResponseValue;
32282 // void RouteHintHop_set_src_node_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
32284 export function RouteHintHop_set_src_node_id(this_ptr: bigint, val: number): void {
32285 if(!isWasmInitialized) {
32286 throw new Error("initializeWasm() must be awaited first!");
32288 const nativeResponseValue = wasm.TS_RouteHintHop_set_src_node_id(this_ptr, val);
32289 // debug statements here
32291 // uint64_t RouteHintHop_get_short_channel_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
32293 export function RouteHintHop_get_short_channel_id(this_ptr: bigint): bigint {
32294 if(!isWasmInitialized) {
32295 throw new Error("initializeWasm() must be awaited first!");
32297 const nativeResponseValue = wasm.TS_RouteHintHop_get_short_channel_id(this_ptr);
32298 return nativeResponseValue;
32300 // void RouteHintHop_set_short_channel_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint64_t val);
32302 export function RouteHintHop_set_short_channel_id(this_ptr: bigint, val: bigint): void {
32303 if(!isWasmInitialized) {
32304 throw new Error("initializeWasm() must be awaited first!");
32306 const nativeResponseValue = wasm.TS_RouteHintHop_set_short_channel_id(this_ptr, val);
32307 // debug statements here
32309 // struct LDKRoutingFees RouteHintHop_get_fees(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
32311 export function RouteHintHop_get_fees(this_ptr: bigint): bigint {
32312 if(!isWasmInitialized) {
32313 throw new Error("initializeWasm() must be awaited first!");
32315 const nativeResponseValue = wasm.TS_RouteHintHop_get_fees(this_ptr);
32316 return nativeResponseValue;
32318 // void RouteHintHop_set_fees(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
32320 export function RouteHintHop_set_fees(this_ptr: bigint, val: bigint): void {
32321 if(!isWasmInitialized) {
32322 throw new Error("initializeWasm() must be awaited first!");
32324 const nativeResponseValue = wasm.TS_RouteHintHop_set_fees(this_ptr, val);
32325 // debug statements here
32327 // uint16_t RouteHintHop_get_cltv_expiry_delta(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
32329 export function RouteHintHop_get_cltv_expiry_delta(this_ptr: bigint): number {
32330 if(!isWasmInitialized) {
32331 throw new Error("initializeWasm() must be awaited first!");
32333 const nativeResponseValue = wasm.TS_RouteHintHop_get_cltv_expiry_delta(this_ptr);
32334 return nativeResponseValue;
32336 // void RouteHintHop_set_cltv_expiry_delta(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint16_t val);
32338 export function RouteHintHop_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
32339 if(!isWasmInitialized) {
32340 throw new Error("initializeWasm() must be awaited first!");
32342 const nativeResponseValue = wasm.TS_RouteHintHop_set_cltv_expiry_delta(this_ptr, val);
32343 // debug statements here
32345 // struct LDKCOption_u64Z RouteHintHop_get_htlc_minimum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
32347 export function RouteHintHop_get_htlc_minimum_msat(this_ptr: bigint): bigint {
32348 if(!isWasmInitialized) {
32349 throw new Error("initializeWasm() must be awaited first!");
32351 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_minimum_msat(this_ptr);
32352 return nativeResponseValue;
32354 // void RouteHintHop_set_htlc_minimum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
32356 export function RouteHintHop_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
32357 if(!isWasmInitialized) {
32358 throw new Error("initializeWasm() must be awaited first!");
32360 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_minimum_msat(this_ptr, val);
32361 // debug statements here
32363 // struct LDKCOption_u64Z RouteHintHop_get_htlc_maximum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
32365 export function RouteHintHop_get_htlc_maximum_msat(this_ptr: bigint): bigint {
32366 if(!isWasmInitialized) {
32367 throw new Error("initializeWasm() must be awaited first!");
32369 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_maximum_msat(this_ptr);
32370 return nativeResponseValue;
32372 // void RouteHintHop_set_htlc_maximum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
32374 export function RouteHintHop_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
32375 if(!isWasmInitialized) {
32376 throw new Error("initializeWasm() must be awaited first!");
32378 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_maximum_msat(this_ptr, val);
32379 // debug statements here
32381 // 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);
32383 export function RouteHintHop_new(src_node_id_arg: number, short_channel_id_arg: bigint, fees_arg: bigint, cltv_expiry_delta_arg: number, htlc_minimum_msat_arg: bigint, htlc_maximum_msat_arg: bigint): bigint {
32384 if(!isWasmInitialized) {
32385 throw new Error("initializeWasm() must be awaited first!");
32387 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);
32388 return nativeResponseValue;
32390 // uint64_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg);
32392 export function RouteHintHop_clone_ptr(arg: bigint): bigint {
32393 if(!isWasmInitialized) {
32394 throw new Error("initializeWasm() must be awaited first!");
32396 const nativeResponseValue = wasm.TS_RouteHintHop_clone_ptr(arg);
32397 return nativeResponseValue;
32399 // struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
32401 export function RouteHintHop_clone(orig: bigint): bigint {
32402 if(!isWasmInitialized) {
32403 throw new Error("initializeWasm() must be awaited first!");
32405 const nativeResponseValue = wasm.TS_RouteHintHop_clone(orig);
32406 return nativeResponseValue;
32408 // uint64_t RouteHintHop_hash(const struct LDKRouteHintHop *NONNULL_PTR o);
32410 export function RouteHintHop_hash(o: bigint): bigint {
32411 if(!isWasmInitialized) {
32412 throw new Error("initializeWasm() must be awaited first!");
32414 const nativeResponseValue = wasm.TS_RouteHintHop_hash(o);
32415 return nativeResponseValue;
32417 // bool RouteHintHop_eq(const struct LDKRouteHintHop *NONNULL_PTR a, const struct LDKRouteHintHop *NONNULL_PTR b);
32419 export function RouteHintHop_eq(a: bigint, b: bigint): boolean {
32420 if(!isWasmInitialized) {
32421 throw new Error("initializeWasm() must be awaited first!");
32423 const nativeResponseValue = wasm.TS_RouteHintHop_eq(a, b);
32424 return nativeResponseValue;
32426 // struct LDKCVec_u8Z RouteHintHop_write(const struct LDKRouteHintHop *NONNULL_PTR obj);
32428 export function RouteHintHop_write(obj: bigint): number {
32429 if(!isWasmInitialized) {
32430 throw new Error("initializeWasm() must be awaited first!");
32432 const nativeResponseValue = wasm.TS_RouteHintHop_write(obj);
32433 return nativeResponseValue;
32435 // struct LDKCResult_RouteHintHopDecodeErrorZ RouteHintHop_read(struct LDKu8slice ser);
32437 export function RouteHintHop_read(ser: number): bigint {
32438 if(!isWasmInitialized) {
32439 throw new Error("initializeWasm() must be awaited first!");
32441 const nativeResponseValue = wasm.TS_RouteHintHop_read(ser);
32442 return nativeResponseValue;
32444 // struct LDKCResult_RouteLightningErrorZ find_route(struct LDKPublicKey our_node_pubkey, const struct LDKRouteParameters *NONNULL_PTR route_params, const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKLogger logger, const struct LDKScore *NONNULL_PTR scorer, const uint8_t (*random_seed_bytes)[32]);
32446 export function find_route(our_node_pubkey: number, route_params: bigint, network_graph: bigint, first_hops: number, logger: bigint, scorer: bigint, random_seed_bytes: number): bigint {
32447 if(!isWasmInitialized) {
32448 throw new Error("initializeWasm() must be awaited first!");
32450 const nativeResponseValue = wasm.TS_find_route(our_node_pubkey, route_params, network_graph, first_hops, logger, scorer, random_seed_bytes);
32451 return nativeResponseValue;
32453 // struct LDKCResult_RouteLightningErrorZ build_route_from_hops(struct LDKPublicKey our_node_pubkey, struct LDKCVec_PublicKeyZ hops, const struct LDKRouteParameters *NONNULL_PTR route_params, const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger, const uint8_t (*random_seed_bytes)[32]);
32455 export function build_route_from_hops(our_node_pubkey: number, hops: number, route_params: bigint, network_graph: bigint, logger: bigint, random_seed_bytes: number): bigint {
32456 if(!isWasmInitialized) {
32457 throw new Error("initializeWasm() must be awaited first!");
32459 const nativeResponseValue = wasm.TS_build_route_from_hops(our_node_pubkey, hops, route_params, network_graph, logger, random_seed_bytes);
32460 return nativeResponseValue;
32462 // void Score_free(struct LDKScore this_ptr);
32464 export function Score_free(this_ptr: bigint): void {
32465 if(!isWasmInitialized) {
32466 throw new Error("initializeWasm() must be awaited first!");
32468 const nativeResponseValue = wasm.TS_Score_free(this_ptr);
32469 // debug statements here
32471 // void LockableScore_free(struct LDKLockableScore this_ptr);
32473 export function LockableScore_free(this_ptr: bigint): void {
32474 if(!isWasmInitialized) {
32475 throw new Error("initializeWasm() must be awaited first!");
32477 const nativeResponseValue = wasm.TS_LockableScore_free(this_ptr);
32478 // debug statements here
32480 // void WriteableScore_free(struct LDKWriteableScore this_ptr);
32482 export function WriteableScore_free(this_ptr: bigint): void {
32483 if(!isWasmInitialized) {
32484 throw new Error("initializeWasm() must be awaited first!");
32486 const nativeResponseValue = wasm.TS_WriteableScore_free(this_ptr);
32487 // debug statements here
32489 // void MultiThreadedLockableScore_free(struct LDKMultiThreadedLockableScore this_obj);
32491 export function MultiThreadedLockableScore_free(this_obj: bigint): void {
32492 if(!isWasmInitialized) {
32493 throw new Error("initializeWasm() must be awaited first!");
32495 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_free(this_obj);
32496 // debug statements here
32498 // void MultiThreadedScoreLock_free(struct LDKMultiThreadedScoreLock this_obj);
32500 export function MultiThreadedScoreLock_free(this_obj: bigint): void {
32501 if(!isWasmInitialized) {
32502 throw new Error("initializeWasm() must be awaited first!");
32504 const nativeResponseValue = wasm.TS_MultiThreadedScoreLock_free(this_obj);
32505 // debug statements here
32507 // struct LDKScore MultiThreadedScoreLock_as_Score(const struct LDKMultiThreadedScoreLock *NONNULL_PTR this_arg);
32509 export function MultiThreadedScoreLock_as_Score(this_arg: bigint): bigint {
32510 if(!isWasmInitialized) {
32511 throw new Error("initializeWasm() must be awaited first!");
32513 const nativeResponseValue = wasm.TS_MultiThreadedScoreLock_as_Score(this_arg);
32514 return nativeResponseValue;
32516 // struct LDKCVec_u8Z MultiThreadedScoreLock_write(const struct LDKMultiThreadedScoreLock *NONNULL_PTR obj);
32518 export function MultiThreadedScoreLock_write(obj: bigint): number {
32519 if(!isWasmInitialized) {
32520 throw new Error("initializeWasm() must be awaited first!");
32522 const nativeResponseValue = wasm.TS_MultiThreadedScoreLock_write(obj);
32523 return nativeResponseValue;
32525 // struct LDKLockableScore MultiThreadedLockableScore_as_LockableScore(const struct LDKMultiThreadedLockableScore *NONNULL_PTR this_arg);
32527 export function MultiThreadedLockableScore_as_LockableScore(this_arg: bigint): bigint {
32528 if(!isWasmInitialized) {
32529 throw new Error("initializeWasm() must be awaited first!");
32531 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_as_LockableScore(this_arg);
32532 return nativeResponseValue;
32534 // struct LDKCVec_u8Z MultiThreadedLockableScore_write(const struct LDKMultiThreadedLockableScore *NONNULL_PTR obj);
32536 export function MultiThreadedLockableScore_write(obj: bigint): number {
32537 if(!isWasmInitialized) {
32538 throw new Error("initializeWasm() must be awaited first!");
32540 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_write(obj);
32541 return nativeResponseValue;
32543 // struct LDKWriteableScore MultiThreadedLockableScore_as_WriteableScore(const struct LDKMultiThreadedLockableScore *NONNULL_PTR this_arg);
32545 export function MultiThreadedLockableScore_as_WriteableScore(this_arg: bigint): bigint {
32546 if(!isWasmInitialized) {
32547 throw new Error("initializeWasm() must be awaited first!");
32549 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_as_WriteableScore(this_arg);
32550 return nativeResponseValue;
32552 // MUST_USE_RES struct LDKMultiThreadedLockableScore MultiThreadedLockableScore_new(struct LDKScore score);
32554 export function MultiThreadedLockableScore_new(score: bigint): bigint {
32555 if(!isWasmInitialized) {
32556 throw new Error("initializeWasm() must be awaited first!");
32558 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_new(score);
32559 return nativeResponseValue;
32561 // void ChannelUsage_free(struct LDKChannelUsage this_obj);
32563 export function ChannelUsage_free(this_obj: bigint): void {
32564 if(!isWasmInitialized) {
32565 throw new Error("initializeWasm() must be awaited first!");
32567 const nativeResponseValue = wasm.TS_ChannelUsage_free(this_obj);
32568 // debug statements here
32570 // uint64_t ChannelUsage_get_amount_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
32572 export function ChannelUsage_get_amount_msat(this_ptr: bigint): bigint {
32573 if(!isWasmInitialized) {
32574 throw new Error("initializeWasm() must be awaited first!");
32576 const nativeResponseValue = wasm.TS_ChannelUsage_get_amount_msat(this_ptr);
32577 return nativeResponseValue;
32579 // void ChannelUsage_set_amount_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
32581 export function ChannelUsage_set_amount_msat(this_ptr: bigint, val: bigint): void {
32582 if(!isWasmInitialized) {
32583 throw new Error("initializeWasm() must be awaited first!");
32585 const nativeResponseValue = wasm.TS_ChannelUsage_set_amount_msat(this_ptr, val);
32586 // debug statements here
32588 // uint64_t ChannelUsage_get_inflight_htlc_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
32590 export function ChannelUsage_get_inflight_htlc_msat(this_ptr: bigint): bigint {
32591 if(!isWasmInitialized) {
32592 throw new Error("initializeWasm() must be awaited first!");
32594 const nativeResponseValue = wasm.TS_ChannelUsage_get_inflight_htlc_msat(this_ptr);
32595 return nativeResponseValue;
32597 // void ChannelUsage_set_inflight_htlc_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
32599 export function ChannelUsage_set_inflight_htlc_msat(this_ptr: bigint, val: bigint): void {
32600 if(!isWasmInitialized) {
32601 throw new Error("initializeWasm() must be awaited first!");
32603 const nativeResponseValue = wasm.TS_ChannelUsage_set_inflight_htlc_msat(this_ptr, val);
32604 // debug statements here
32606 // struct LDKEffectiveCapacity ChannelUsage_get_effective_capacity(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
32608 export function ChannelUsage_get_effective_capacity(this_ptr: bigint): bigint {
32609 if(!isWasmInitialized) {
32610 throw new Error("initializeWasm() must be awaited first!");
32612 const nativeResponseValue = wasm.TS_ChannelUsage_get_effective_capacity(this_ptr);
32613 return nativeResponseValue;
32615 // void ChannelUsage_set_effective_capacity(struct LDKChannelUsage *NONNULL_PTR this_ptr, struct LDKEffectiveCapacity val);
32617 export function ChannelUsage_set_effective_capacity(this_ptr: bigint, val: bigint): void {
32618 if(!isWasmInitialized) {
32619 throw new Error("initializeWasm() must be awaited first!");
32621 const nativeResponseValue = wasm.TS_ChannelUsage_set_effective_capacity(this_ptr, val);
32622 // debug statements here
32624 // MUST_USE_RES struct LDKChannelUsage ChannelUsage_new(uint64_t amount_msat_arg, uint64_t inflight_htlc_msat_arg, struct LDKEffectiveCapacity effective_capacity_arg);
32626 export function ChannelUsage_new(amount_msat_arg: bigint, inflight_htlc_msat_arg: bigint, effective_capacity_arg: bigint): bigint {
32627 if(!isWasmInitialized) {
32628 throw new Error("initializeWasm() must be awaited first!");
32630 const nativeResponseValue = wasm.TS_ChannelUsage_new(amount_msat_arg, inflight_htlc_msat_arg, effective_capacity_arg);
32631 return nativeResponseValue;
32633 // uint64_t ChannelUsage_clone_ptr(LDKChannelUsage *NONNULL_PTR arg);
32635 export function ChannelUsage_clone_ptr(arg: bigint): bigint {
32636 if(!isWasmInitialized) {
32637 throw new Error("initializeWasm() must be awaited first!");
32639 const nativeResponseValue = wasm.TS_ChannelUsage_clone_ptr(arg);
32640 return nativeResponseValue;
32642 // struct LDKChannelUsage ChannelUsage_clone(const struct LDKChannelUsage *NONNULL_PTR orig);
32644 export function ChannelUsage_clone(orig: bigint): bigint {
32645 if(!isWasmInitialized) {
32646 throw new Error("initializeWasm() must be awaited first!");
32648 const nativeResponseValue = wasm.TS_ChannelUsage_clone(orig);
32649 return nativeResponseValue;
32651 // void FixedPenaltyScorer_free(struct LDKFixedPenaltyScorer this_obj);
32653 export function FixedPenaltyScorer_free(this_obj: bigint): void {
32654 if(!isWasmInitialized) {
32655 throw new Error("initializeWasm() must be awaited first!");
32657 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_free(this_obj);
32658 // debug statements here
32660 // uint64_t FixedPenaltyScorer_clone_ptr(LDKFixedPenaltyScorer *NONNULL_PTR arg);
32662 export function FixedPenaltyScorer_clone_ptr(arg: bigint): bigint {
32663 if(!isWasmInitialized) {
32664 throw new Error("initializeWasm() must be awaited first!");
32666 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone_ptr(arg);
32667 return nativeResponseValue;
32669 // struct LDKFixedPenaltyScorer FixedPenaltyScorer_clone(const struct LDKFixedPenaltyScorer *NONNULL_PTR orig);
32671 export function FixedPenaltyScorer_clone(orig: bigint): bigint {
32672 if(!isWasmInitialized) {
32673 throw new Error("initializeWasm() must be awaited first!");
32675 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone(orig);
32676 return nativeResponseValue;
32678 // MUST_USE_RES struct LDKFixedPenaltyScorer FixedPenaltyScorer_with_penalty(uint64_t penalty_msat);
32680 export function FixedPenaltyScorer_with_penalty(penalty_msat: bigint): bigint {
32681 if(!isWasmInitialized) {
32682 throw new Error("initializeWasm() must be awaited first!");
32684 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_with_penalty(penalty_msat);
32685 return nativeResponseValue;
32687 // struct LDKScore FixedPenaltyScorer_as_Score(const struct LDKFixedPenaltyScorer *NONNULL_PTR this_arg);
32689 export function FixedPenaltyScorer_as_Score(this_arg: bigint): bigint {
32690 if(!isWasmInitialized) {
32691 throw new Error("initializeWasm() must be awaited first!");
32693 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_as_Score(this_arg);
32694 return nativeResponseValue;
32696 // struct LDKCVec_u8Z FixedPenaltyScorer_write(const struct LDKFixedPenaltyScorer *NONNULL_PTR obj);
32698 export function FixedPenaltyScorer_write(obj: bigint): number {
32699 if(!isWasmInitialized) {
32700 throw new Error("initializeWasm() must be awaited first!");
32702 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_write(obj);
32703 return nativeResponseValue;
32705 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ FixedPenaltyScorer_read(struct LDKu8slice ser, uint64_t arg);
32707 export function FixedPenaltyScorer_read(ser: number, arg: bigint): bigint {
32708 if(!isWasmInitialized) {
32709 throw new Error("initializeWasm() must be awaited first!");
32711 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_read(ser, arg);
32712 return nativeResponseValue;
32714 // void ProbabilisticScorer_free(struct LDKProbabilisticScorer this_obj);
32716 export function ProbabilisticScorer_free(this_obj: bigint): void {
32717 if(!isWasmInitialized) {
32718 throw new Error("initializeWasm() must be awaited first!");
32720 const nativeResponseValue = wasm.TS_ProbabilisticScorer_free(this_obj);
32721 // debug statements here
32723 // void ProbabilisticScoringParameters_free(struct LDKProbabilisticScoringParameters this_obj);
32725 export function ProbabilisticScoringParameters_free(this_obj: bigint): void {
32726 if(!isWasmInitialized) {
32727 throw new Error("initializeWasm() must be awaited first!");
32729 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_free(this_obj);
32730 // debug statements here
32732 // uint64_t ProbabilisticScoringParameters_get_base_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
32734 export function ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr: bigint): bigint {
32735 if(!isWasmInitialized) {
32736 throw new Error("initializeWasm() must be awaited first!");
32738 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr);
32739 return nativeResponseValue;
32741 // void ProbabilisticScoringParameters_set_base_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
32743 export function ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr: bigint, val: bigint): void {
32744 if(!isWasmInitialized) {
32745 throw new Error("initializeWasm() must be awaited first!");
32747 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr, val);
32748 // debug statements here
32750 // uint64_t ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
32752 export function ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
32753 if(!isWasmInitialized) {
32754 throw new Error("initializeWasm() must be awaited first!");
32756 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(this_ptr);
32757 return nativeResponseValue;
32759 // void ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
32761 export function ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
32762 if(!isWasmInitialized) {
32763 throw new Error("initializeWasm() must be awaited first!");
32765 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(this_ptr, val);
32766 // debug statements here
32768 // uint64_t ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
32770 export function ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr: bigint): bigint {
32771 if(!isWasmInitialized) {
32772 throw new Error("initializeWasm() must be awaited first!");
32774 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr);
32775 return nativeResponseValue;
32777 // void ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
32779 export function ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr: bigint, val: bigint): void {
32780 if(!isWasmInitialized) {
32781 throw new Error("initializeWasm() must be awaited first!");
32783 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr, val);
32784 // debug statements here
32786 // uint64_t ProbabilisticScoringParameters_get_liquidity_offset_half_life(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
32788 export function ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr: bigint): bigint {
32789 if(!isWasmInitialized) {
32790 throw new Error("initializeWasm() must be awaited first!");
32792 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr);
32793 return nativeResponseValue;
32795 // void ProbabilisticScoringParameters_set_liquidity_offset_half_life(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
32797 export function ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr: bigint, val: bigint): void {
32798 if(!isWasmInitialized) {
32799 throw new Error("initializeWasm() must be awaited first!");
32801 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr, val);
32802 // debug statements here
32804 // uint64_t ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
32806 export function ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
32807 if(!isWasmInitialized) {
32808 throw new Error("initializeWasm() must be awaited first!");
32810 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr);
32811 return nativeResponseValue;
32813 // void ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
32815 export function ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
32816 if(!isWasmInitialized) {
32817 throw new Error("initializeWasm() must be awaited first!");
32819 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr, val);
32820 // debug statements here
32822 // uint64_t ProbabilisticScoringParameters_get_anti_probing_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
32824 export function ProbabilisticScoringParameters_get_anti_probing_penalty_msat(this_ptr: bigint): bigint {
32825 if(!isWasmInitialized) {
32826 throw new Error("initializeWasm() must be awaited first!");
32828 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_anti_probing_penalty_msat(this_ptr);
32829 return nativeResponseValue;
32831 // void ProbabilisticScoringParameters_set_anti_probing_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
32833 export function ProbabilisticScoringParameters_set_anti_probing_penalty_msat(this_ptr: bigint, val: bigint): void {
32834 if(!isWasmInitialized) {
32835 throw new Error("initializeWasm() must be awaited first!");
32837 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_anti_probing_penalty_msat(this_ptr, val);
32838 // debug statements here
32840 // uint64_t ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
32842 export function ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(this_ptr: bigint): bigint {
32843 if(!isWasmInitialized) {
32844 throw new Error("initializeWasm() must be awaited first!");
32846 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(this_ptr);
32847 return nativeResponseValue;
32849 // void ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
32851 export function ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(this_ptr: bigint, val: bigint): void {
32852 if(!isWasmInitialized) {
32853 throw new Error("initializeWasm() must be awaited first!");
32855 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(this_ptr, val);
32856 // debug statements here
32858 // uint64_t ProbabilisticScoringParameters_clone_ptr(LDKProbabilisticScoringParameters *NONNULL_PTR arg);
32860 export function ProbabilisticScoringParameters_clone_ptr(arg: bigint): bigint {
32861 if(!isWasmInitialized) {
32862 throw new Error("initializeWasm() must be awaited first!");
32864 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone_ptr(arg);
32865 return nativeResponseValue;
32867 // struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_clone(const struct LDKProbabilisticScoringParameters *NONNULL_PTR orig);
32869 export function ProbabilisticScoringParameters_clone(orig: bigint): bigint {
32870 if(!isWasmInitialized) {
32871 throw new Error("initializeWasm() must be awaited first!");
32873 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone(orig);
32874 return nativeResponseValue;
32876 // MUST_USE_RES struct LDKProbabilisticScorer ProbabilisticScorer_new(struct LDKProbabilisticScoringParameters params, const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger);
32878 export function ProbabilisticScorer_new(params: bigint, network_graph: bigint, logger: bigint): bigint {
32879 if(!isWasmInitialized) {
32880 throw new Error("initializeWasm() must be awaited first!");
32882 const nativeResponseValue = wasm.TS_ProbabilisticScorer_new(params, network_graph, logger);
32883 return nativeResponseValue;
32885 // void ProbabilisticScorer_debug_log_liquidity_stats(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
32887 export function ProbabilisticScorer_debug_log_liquidity_stats(this_arg: bigint): void {
32888 if(!isWasmInitialized) {
32889 throw new Error("initializeWasm() must be awaited first!");
32891 const nativeResponseValue = wasm.TS_ProbabilisticScorer_debug_log_liquidity_stats(this_arg);
32892 // debug statements here
32894 // MUST_USE_RES struct LDKCOption_C2Tuple_u64u64ZZ ProbabilisticScorer_estimated_channel_liquidity_range(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg, uint64_t scid, const struct LDKNodeId *NONNULL_PTR target);
32896 export function ProbabilisticScorer_estimated_channel_liquidity_range(this_arg: bigint, scid: bigint, target: bigint): bigint {
32897 if(!isWasmInitialized) {
32898 throw new Error("initializeWasm() must be awaited first!");
32900 const nativeResponseValue = wasm.TS_ProbabilisticScorer_estimated_channel_liquidity_range(this_arg, scid, target);
32901 return nativeResponseValue;
32903 // void ProbabilisticScorer_add_banned(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
32905 export function ProbabilisticScorer_add_banned(this_arg: bigint, node_id: bigint): void {
32906 if(!isWasmInitialized) {
32907 throw new Error("initializeWasm() must be awaited first!");
32909 const nativeResponseValue = wasm.TS_ProbabilisticScorer_add_banned(this_arg, node_id);
32910 // debug statements here
32912 // void ProbabilisticScorer_remove_banned(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
32914 export function ProbabilisticScorer_remove_banned(this_arg: bigint, node_id: bigint): void {
32915 if(!isWasmInitialized) {
32916 throw new Error("initializeWasm() must be awaited first!");
32918 const nativeResponseValue = wasm.TS_ProbabilisticScorer_remove_banned(this_arg, node_id);
32919 // debug statements here
32921 // void ProbabilisticScorer_set_manual_penalty(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id, uint64_t penalty);
32923 export function ProbabilisticScorer_set_manual_penalty(this_arg: bigint, node_id: bigint, penalty: bigint): void {
32924 if(!isWasmInitialized) {
32925 throw new Error("initializeWasm() must be awaited first!");
32927 const nativeResponseValue = wasm.TS_ProbabilisticScorer_set_manual_penalty(this_arg, node_id, penalty);
32928 // debug statements here
32930 // void ProbabilisticScorer_remove_manual_penalty(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
32932 export function ProbabilisticScorer_remove_manual_penalty(this_arg: bigint, node_id: bigint): void {
32933 if(!isWasmInitialized) {
32934 throw new Error("initializeWasm() must be awaited first!");
32936 const nativeResponseValue = wasm.TS_ProbabilisticScorer_remove_manual_penalty(this_arg, node_id);
32937 // debug statements here
32939 // void ProbabilisticScorer_clear_manual_penalties(struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
32941 export function ProbabilisticScorer_clear_manual_penalties(this_arg: bigint): void {
32942 if(!isWasmInitialized) {
32943 throw new Error("initializeWasm() must be awaited first!");
32945 const nativeResponseValue = wasm.TS_ProbabilisticScorer_clear_manual_penalties(this_arg);
32946 // debug statements here
32948 // void ProbabilisticScoringParameters_add_banned_from_list(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_arg, struct LDKCVec_NodeIdZ node_ids);
32950 export function ProbabilisticScoringParameters_add_banned_from_list(this_arg: bigint, node_ids: number): void {
32951 if(!isWasmInitialized) {
32952 throw new Error("initializeWasm() must be awaited first!");
32954 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_add_banned_from_list(this_arg, node_ids);
32955 // debug statements here
32957 // MUST_USE_RES struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_default(void);
32959 export function ProbabilisticScoringParameters_default(): bigint {
32960 if(!isWasmInitialized) {
32961 throw new Error("initializeWasm() must be awaited first!");
32963 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_default();
32964 return nativeResponseValue;
32966 // struct LDKScore ProbabilisticScorer_as_Score(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
32968 export function ProbabilisticScorer_as_Score(this_arg: bigint): bigint {
32969 if(!isWasmInitialized) {
32970 throw new Error("initializeWasm() must be awaited first!");
32972 const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_Score(this_arg);
32973 return nativeResponseValue;
32975 // struct LDKCVec_u8Z ProbabilisticScorer_write(const struct LDKProbabilisticScorer *NONNULL_PTR obj);
32977 export function ProbabilisticScorer_write(obj: bigint): number {
32978 if(!isWasmInitialized) {
32979 throw new Error("initializeWasm() must be awaited first!");
32981 const nativeResponseValue = wasm.TS_ProbabilisticScorer_write(obj);
32982 return nativeResponseValue;
32984 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ ProbabilisticScorer_read(struct LDKu8slice ser, struct LDKProbabilisticScoringParameters arg_a, const struct LDKNetworkGraph *NONNULL_PTR arg_b, struct LDKLogger arg_c);
32986 export function ProbabilisticScorer_read(ser: number, arg_a: bigint, arg_b: bigint, arg_c: bigint): bigint {
32987 if(!isWasmInitialized) {
32988 throw new Error("initializeWasm() must be awaited first!");
32990 const nativeResponseValue = wasm.TS_ProbabilisticScorer_read(ser, arg_a, arg_b, arg_c);
32991 return nativeResponseValue;
32993 // void BlindedRoute_free(struct LDKBlindedRoute this_obj);
32995 export function BlindedRoute_free(this_obj: bigint): void {
32996 if(!isWasmInitialized) {
32997 throw new Error("initializeWasm() must be awaited first!");
32999 const nativeResponseValue = wasm.TS_BlindedRoute_free(this_obj);
33000 // debug statements here
33002 // void BlindedHop_free(struct LDKBlindedHop this_obj);
33004 export function BlindedHop_free(this_obj: bigint): void {
33005 if(!isWasmInitialized) {
33006 throw new Error("initializeWasm() must be awaited first!");
33008 const nativeResponseValue = wasm.TS_BlindedHop_free(this_obj);
33009 // debug statements here
33011 // MUST_USE_RES struct LDKCResult_BlindedRouteNoneZ BlindedRoute_new(struct LDKCVec_PublicKeyZ node_pks, const struct LDKKeysInterface *NONNULL_PTR keys_manager);
33013 export function BlindedRoute_new(node_pks: number, keys_manager: bigint): bigint {
33014 if(!isWasmInitialized) {
33015 throw new Error("initializeWasm() must be awaited first!");
33017 const nativeResponseValue = wasm.TS_BlindedRoute_new(node_pks, keys_manager);
33018 return nativeResponseValue;
33020 // struct LDKCVec_u8Z BlindedRoute_write(const struct LDKBlindedRoute *NONNULL_PTR obj);
33022 export function BlindedRoute_write(obj: bigint): number {
33023 if(!isWasmInitialized) {
33024 throw new Error("initializeWasm() must be awaited first!");
33026 const nativeResponseValue = wasm.TS_BlindedRoute_write(obj);
33027 return nativeResponseValue;
33029 // struct LDKCResult_BlindedRouteDecodeErrorZ BlindedRoute_read(struct LDKu8slice ser);
33031 export function BlindedRoute_read(ser: number): bigint {
33032 if(!isWasmInitialized) {
33033 throw new Error("initializeWasm() must be awaited first!");
33035 const nativeResponseValue = wasm.TS_BlindedRoute_read(ser);
33036 return nativeResponseValue;
33038 // struct LDKCVec_u8Z BlindedHop_write(const struct LDKBlindedHop *NONNULL_PTR obj);
33040 export function BlindedHop_write(obj: bigint): number {
33041 if(!isWasmInitialized) {
33042 throw new Error("initializeWasm() must be awaited first!");
33044 const nativeResponseValue = wasm.TS_BlindedHop_write(obj);
33045 return nativeResponseValue;
33047 // struct LDKCResult_BlindedHopDecodeErrorZ BlindedHop_read(struct LDKu8slice ser);
33049 export function BlindedHop_read(ser: number): bigint {
33050 if(!isWasmInitialized) {
33051 throw new Error("initializeWasm() must be awaited first!");
33053 const nativeResponseValue = wasm.TS_BlindedHop_read(ser);
33054 return nativeResponseValue;
33056 // void OnionMessenger_free(struct LDKOnionMessenger this_obj);
33058 export function OnionMessenger_free(this_obj: bigint): void {
33059 if(!isWasmInitialized) {
33060 throw new Error("initializeWasm() must be awaited first!");
33062 const nativeResponseValue = wasm.TS_OnionMessenger_free(this_obj);
33063 // debug statements here
33065 // void Destination_free(struct LDKDestination this_ptr);
33067 export function Destination_free(this_ptr: bigint): void {
33068 if(!isWasmInitialized) {
33069 throw new Error("initializeWasm() must be awaited first!");
33071 const nativeResponseValue = wasm.TS_Destination_free(this_ptr);
33072 // debug statements here
33074 // struct LDKDestination Destination_node(struct LDKPublicKey a);
33076 export function Destination_node(a: number): bigint {
33077 if(!isWasmInitialized) {
33078 throw new Error("initializeWasm() must be awaited first!");
33080 const nativeResponseValue = wasm.TS_Destination_node(a);
33081 return nativeResponseValue;
33083 // struct LDKDestination Destination_blinded_route(struct LDKBlindedRoute a);
33085 export function Destination_blinded_route(a: bigint): bigint {
33086 if(!isWasmInitialized) {
33087 throw new Error("initializeWasm() must be awaited first!");
33089 const nativeResponseValue = wasm.TS_Destination_blinded_route(a);
33090 return nativeResponseValue;
33092 // void SendError_free(struct LDKSendError this_ptr);
33094 export function SendError_free(this_ptr: bigint): void {
33095 if(!isWasmInitialized) {
33096 throw new Error("initializeWasm() must be awaited first!");
33098 const nativeResponseValue = wasm.TS_SendError_free(this_ptr);
33099 // debug statements here
33101 // uint64_t SendError_clone_ptr(LDKSendError *NONNULL_PTR arg);
33103 export function SendError_clone_ptr(arg: bigint): bigint {
33104 if(!isWasmInitialized) {
33105 throw new Error("initializeWasm() must be awaited first!");
33107 const nativeResponseValue = wasm.TS_SendError_clone_ptr(arg);
33108 return nativeResponseValue;
33110 // struct LDKSendError SendError_clone(const struct LDKSendError *NONNULL_PTR orig);
33112 export function SendError_clone(orig: bigint): bigint {
33113 if(!isWasmInitialized) {
33114 throw new Error("initializeWasm() must be awaited first!");
33116 const nativeResponseValue = wasm.TS_SendError_clone(orig);
33117 return nativeResponseValue;
33119 // struct LDKSendError SendError_secp256k1(enum LDKSecp256k1Error a);
33121 export function SendError_secp256k1(a: Secp256k1Error): bigint {
33122 if(!isWasmInitialized) {
33123 throw new Error("initializeWasm() must be awaited first!");
33125 const nativeResponseValue = wasm.TS_SendError_secp256k1(a);
33126 return nativeResponseValue;
33128 // struct LDKSendError SendError_too_big_packet(void);
33130 export function SendError_too_big_packet(): bigint {
33131 if(!isWasmInitialized) {
33132 throw new Error("initializeWasm() must be awaited first!");
33134 const nativeResponseValue = wasm.TS_SendError_too_big_packet();
33135 return nativeResponseValue;
33137 // struct LDKSendError SendError_too_few_blinded_hops(void);
33139 export function SendError_too_few_blinded_hops(): bigint {
33140 if(!isWasmInitialized) {
33141 throw new Error("initializeWasm() must be awaited first!");
33143 const nativeResponseValue = wasm.TS_SendError_too_few_blinded_hops();
33144 return nativeResponseValue;
33146 // struct LDKSendError SendError_invalid_first_hop(void);
33148 export function SendError_invalid_first_hop(): bigint {
33149 if(!isWasmInitialized) {
33150 throw new Error("initializeWasm() must be awaited first!");
33152 const nativeResponseValue = wasm.TS_SendError_invalid_first_hop();
33153 return nativeResponseValue;
33155 // struct LDKSendError SendError_buffer_full(void);
33157 export function SendError_buffer_full(): bigint {
33158 if(!isWasmInitialized) {
33159 throw new Error("initializeWasm() must be awaited first!");
33161 const nativeResponseValue = wasm.TS_SendError_buffer_full();
33162 return nativeResponseValue;
33164 // MUST_USE_RES struct LDKOnionMessenger OnionMessenger_new(struct LDKKeysInterface keys_manager, struct LDKLogger logger);
33166 export function OnionMessenger_new(keys_manager: bigint, logger: bigint): bigint {
33167 if(!isWasmInitialized) {
33168 throw new Error("initializeWasm() must be awaited first!");
33170 const nativeResponseValue = wasm.TS_OnionMessenger_new(keys_manager, logger);
33171 return nativeResponseValue;
33173 // MUST_USE_RES struct LDKCResult_NoneSendErrorZ OnionMessenger_send_onion_message(const struct LDKOnionMessenger *NONNULL_PTR this_arg, struct LDKCVec_PublicKeyZ intermediate_nodes, struct LDKDestination destination, struct LDKBlindedRoute reply_path);
33175 export function OnionMessenger_send_onion_message(this_arg: bigint, intermediate_nodes: number, destination: bigint, reply_path: bigint): bigint {
33176 if(!isWasmInitialized) {
33177 throw new Error("initializeWasm() must be awaited first!");
33179 const nativeResponseValue = wasm.TS_OnionMessenger_send_onion_message(this_arg, intermediate_nodes, destination, reply_path);
33180 return nativeResponseValue;
33182 // struct LDKOnionMessageHandler OnionMessenger_as_OnionMessageHandler(const struct LDKOnionMessenger *NONNULL_PTR this_arg);
33184 export function OnionMessenger_as_OnionMessageHandler(this_arg: bigint): bigint {
33185 if(!isWasmInitialized) {
33186 throw new Error("initializeWasm() must be awaited first!");
33188 const nativeResponseValue = wasm.TS_OnionMessenger_as_OnionMessageHandler(this_arg);
33189 return nativeResponseValue;
33191 // struct LDKOnionMessageProvider OnionMessenger_as_OnionMessageProvider(const struct LDKOnionMessenger *NONNULL_PTR this_arg);
33193 export function OnionMessenger_as_OnionMessageProvider(this_arg: bigint): bigint {
33194 if(!isWasmInitialized) {
33195 throw new Error("initializeWasm() must be awaited first!");
33197 const nativeResponseValue = wasm.TS_OnionMessenger_as_OnionMessageProvider(this_arg);
33198 return nativeResponseValue;
33200 // void RapidGossipSync_free(struct LDKRapidGossipSync this_obj);
33202 export function RapidGossipSync_free(this_obj: bigint): void {
33203 if(!isWasmInitialized) {
33204 throw new Error("initializeWasm() must be awaited first!");
33206 const nativeResponseValue = wasm.TS_RapidGossipSync_free(this_obj);
33207 // debug statements here
33209 // MUST_USE_RES struct LDKRapidGossipSync RapidGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph);
33211 export function RapidGossipSync_new(network_graph: bigint): bigint {
33212 if(!isWasmInitialized) {
33213 throw new Error("initializeWasm() must be awaited first!");
33215 const nativeResponseValue = wasm.TS_RapidGossipSync_new(network_graph);
33216 return nativeResponseValue;
33218 // MUST_USE_RES struct LDKCResult_u32GraphSyncErrorZ RapidGossipSync_update_network_graph(const struct LDKRapidGossipSync *NONNULL_PTR this_arg, struct LDKu8slice update_data);
33220 export function RapidGossipSync_update_network_graph(this_arg: bigint, update_data: number): bigint {
33221 if(!isWasmInitialized) {
33222 throw new Error("initializeWasm() must be awaited first!");
33224 const nativeResponseValue = wasm.TS_RapidGossipSync_update_network_graph(this_arg, update_data);
33225 return nativeResponseValue;
33227 // MUST_USE_RES bool RapidGossipSync_is_initial_sync_complete(const struct LDKRapidGossipSync *NONNULL_PTR this_arg);
33229 export function RapidGossipSync_is_initial_sync_complete(this_arg: bigint): boolean {
33230 if(!isWasmInitialized) {
33231 throw new Error("initializeWasm() must be awaited first!");
33233 const nativeResponseValue = wasm.TS_RapidGossipSync_is_initial_sync_complete(this_arg);
33234 return nativeResponseValue;
33236 // void GraphSyncError_free(struct LDKGraphSyncError this_ptr);
33238 export function GraphSyncError_free(this_ptr: bigint): void {
33239 if(!isWasmInitialized) {
33240 throw new Error("initializeWasm() must be awaited first!");
33242 const nativeResponseValue = wasm.TS_GraphSyncError_free(this_ptr);
33243 // debug statements here
33245 // uint64_t GraphSyncError_clone_ptr(LDKGraphSyncError *NONNULL_PTR arg);
33247 export function GraphSyncError_clone_ptr(arg: bigint): bigint {
33248 if(!isWasmInitialized) {
33249 throw new Error("initializeWasm() must be awaited first!");
33251 const nativeResponseValue = wasm.TS_GraphSyncError_clone_ptr(arg);
33252 return nativeResponseValue;
33254 // struct LDKGraphSyncError GraphSyncError_clone(const struct LDKGraphSyncError *NONNULL_PTR orig);
33256 export function GraphSyncError_clone(orig: bigint): bigint {
33257 if(!isWasmInitialized) {
33258 throw new Error("initializeWasm() must be awaited first!");
33260 const nativeResponseValue = wasm.TS_GraphSyncError_clone(orig);
33261 return nativeResponseValue;
33263 // struct LDKGraphSyncError GraphSyncError_decode_error(struct LDKDecodeError a);
33265 export function GraphSyncError_decode_error(a: bigint): bigint {
33266 if(!isWasmInitialized) {
33267 throw new Error("initializeWasm() must be awaited first!");
33269 const nativeResponseValue = wasm.TS_GraphSyncError_decode_error(a);
33270 return nativeResponseValue;
33272 // struct LDKGraphSyncError GraphSyncError_lightning_error(struct LDKLightningError a);
33274 export function GraphSyncError_lightning_error(a: bigint): bigint {
33275 if(!isWasmInitialized) {
33276 throw new Error("initializeWasm() must be awaited first!");
33278 const nativeResponseValue = wasm.TS_GraphSyncError_lightning_error(a);
33279 return nativeResponseValue;
33281 // void ParseError_free(struct LDKParseError this_ptr);
33283 export function ParseError_free(this_ptr: bigint): void {
33284 if(!isWasmInitialized) {
33285 throw new Error("initializeWasm() must be awaited first!");
33287 const nativeResponseValue = wasm.TS_ParseError_free(this_ptr);
33288 // debug statements here
33290 // uint64_t ParseError_clone_ptr(LDKParseError *NONNULL_PTR arg);
33292 export function ParseError_clone_ptr(arg: bigint): bigint {
33293 if(!isWasmInitialized) {
33294 throw new Error("initializeWasm() must be awaited first!");
33296 const nativeResponseValue = wasm.TS_ParseError_clone_ptr(arg);
33297 return nativeResponseValue;
33299 // struct LDKParseError ParseError_clone(const struct LDKParseError *NONNULL_PTR orig);
33301 export function ParseError_clone(orig: bigint): bigint {
33302 if(!isWasmInitialized) {
33303 throw new Error("initializeWasm() must be awaited first!");
33305 const nativeResponseValue = wasm.TS_ParseError_clone(orig);
33306 return nativeResponseValue;
33308 // struct LDKParseError ParseError_bech32_error(struct LDKBech32Error a);
33310 export function ParseError_bech32_error(a: bigint): bigint {
33311 if(!isWasmInitialized) {
33312 throw new Error("initializeWasm() must be awaited first!");
33314 const nativeResponseValue = wasm.TS_ParseError_bech32_error(a);
33315 return nativeResponseValue;
33317 // struct LDKParseError ParseError_parse_amount_error(struct LDKError a);
33319 export function ParseError_parse_amount_error(a: number): bigint {
33320 if(!isWasmInitialized) {
33321 throw new Error("initializeWasm() must be awaited first!");
33323 const nativeResponseValue = wasm.TS_ParseError_parse_amount_error(a);
33324 return nativeResponseValue;
33326 // struct LDKParseError ParseError_malformed_signature(enum LDKSecp256k1Error a);
33328 export function ParseError_malformed_signature(a: Secp256k1Error): bigint {
33329 if(!isWasmInitialized) {
33330 throw new Error("initializeWasm() must be awaited first!");
33332 const nativeResponseValue = wasm.TS_ParseError_malformed_signature(a);
33333 return nativeResponseValue;
33335 // struct LDKParseError ParseError_bad_prefix(void);
33337 export function ParseError_bad_prefix(): bigint {
33338 if(!isWasmInitialized) {
33339 throw new Error("initializeWasm() must be awaited first!");
33341 const nativeResponseValue = wasm.TS_ParseError_bad_prefix();
33342 return nativeResponseValue;
33344 // struct LDKParseError ParseError_unknown_currency(void);
33346 export function ParseError_unknown_currency(): bigint {
33347 if(!isWasmInitialized) {
33348 throw new Error("initializeWasm() must be awaited first!");
33350 const nativeResponseValue = wasm.TS_ParseError_unknown_currency();
33351 return nativeResponseValue;
33353 // struct LDKParseError ParseError_unknown_si_prefix(void);
33355 export function ParseError_unknown_si_prefix(): bigint {
33356 if(!isWasmInitialized) {
33357 throw new Error("initializeWasm() must be awaited first!");
33359 const nativeResponseValue = wasm.TS_ParseError_unknown_si_prefix();
33360 return nativeResponseValue;
33362 // struct LDKParseError ParseError_malformed_hrp(void);
33364 export function ParseError_malformed_hrp(): bigint {
33365 if(!isWasmInitialized) {
33366 throw new Error("initializeWasm() must be awaited first!");
33368 const nativeResponseValue = wasm.TS_ParseError_malformed_hrp();
33369 return nativeResponseValue;
33371 // struct LDKParseError ParseError_too_short_data_part(void);
33373 export function ParseError_too_short_data_part(): bigint {
33374 if(!isWasmInitialized) {
33375 throw new Error("initializeWasm() must be awaited first!");
33377 const nativeResponseValue = wasm.TS_ParseError_too_short_data_part();
33378 return nativeResponseValue;
33380 // struct LDKParseError ParseError_unexpected_end_of_tagged_fields(void);
33382 export function ParseError_unexpected_end_of_tagged_fields(): bigint {
33383 if(!isWasmInitialized) {
33384 throw new Error("initializeWasm() must be awaited first!");
33386 const nativeResponseValue = wasm.TS_ParseError_unexpected_end_of_tagged_fields();
33387 return nativeResponseValue;
33389 // struct LDKParseError ParseError_description_decode_error(struct LDKError a);
33391 export function ParseError_description_decode_error(a: number): bigint {
33392 if(!isWasmInitialized) {
33393 throw new Error("initializeWasm() must be awaited first!");
33395 const nativeResponseValue = wasm.TS_ParseError_description_decode_error(a);
33396 return nativeResponseValue;
33398 // struct LDKParseError ParseError_padding_error(void);
33400 export function ParseError_padding_error(): bigint {
33401 if(!isWasmInitialized) {
33402 throw new Error("initializeWasm() must be awaited first!");
33404 const nativeResponseValue = wasm.TS_ParseError_padding_error();
33405 return nativeResponseValue;
33407 // struct LDKParseError ParseError_integer_overflow_error(void);
33409 export function ParseError_integer_overflow_error(): bigint {
33410 if(!isWasmInitialized) {
33411 throw new Error("initializeWasm() must be awaited first!");
33413 const nativeResponseValue = wasm.TS_ParseError_integer_overflow_error();
33414 return nativeResponseValue;
33416 // struct LDKParseError ParseError_invalid_seg_wit_program_length(void);
33418 export function ParseError_invalid_seg_wit_program_length(): bigint {
33419 if(!isWasmInitialized) {
33420 throw new Error("initializeWasm() must be awaited first!");
33422 const nativeResponseValue = wasm.TS_ParseError_invalid_seg_wit_program_length();
33423 return nativeResponseValue;
33425 // struct LDKParseError ParseError_invalid_pub_key_hash_length(void);
33427 export function ParseError_invalid_pub_key_hash_length(): bigint {
33428 if(!isWasmInitialized) {
33429 throw new Error("initializeWasm() must be awaited first!");
33431 const nativeResponseValue = wasm.TS_ParseError_invalid_pub_key_hash_length();
33432 return nativeResponseValue;
33434 // struct LDKParseError ParseError_invalid_script_hash_length(void);
33436 export function ParseError_invalid_script_hash_length(): bigint {
33437 if(!isWasmInitialized) {
33438 throw new Error("initializeWasm() must be awaited first!");
33440 const nativeResponseValue = wasm.TS_ParseError_invalid_script_hash_length();
33441 return nativeResponseValue;
33443 // struct LDKParseError ParseError_invalid_recovery_id(void);
33445 export function ParseError_invalid_recovery_id(): bigint {
33446 if(!isWasmInitialized) {
33447 throw new Error("initializeWasm() must be awaited first!");
33449 const nativeResponseValue = wasm.TS_ParseError_invalid_recovery_id();
33450 return nativeResponseValue;
33452 // struct LDKParseError ParseError_invalid_slice_length(struct LDKStr a);
33454 export function ParseError_invalid_slice_length(a: number): bigint {
33455 if(!isWasmInitialized) {
33456 throw new Error("initializeWasm() must be awaited first!");
33458 const nativeResponseValue = wasm.TS_ParseError_invalid_slice_length(a);
33459 return nativeResponseValue;
33461 // struct LDKParseError ParseError_skip(void);
33463 export function ParseError_skip(): bigint {
33464 if(!isWasmInitialized) {
33465 throw new Error("initializeWasm() must be awaited first!");
33467 const nativeResponseValue = wasm.TS_ParseError_skip();
33468 return nativeResponseValue;
33470 // void ParseOrSemanticError_free(struct LDKParseOrSemanticError this_ptr);
33472 export function ParseOrSemanticError_free(this_ptr: bigint): void {
33473 if(!isWasmInitialized) {
33474 throw new Error("initializeWasm() must be awaited first!");
33476 const nativeResponseValue = wasm.TS_ParseOrSemanticError_free(this_ptr);
33477 // debug statements here
33479 // uint64_t ParseOrSemanticError_clone_ptr(LDKParseOrSemanticError *NONNULL_PTR arg);
33481 export function ParseOrSemanticError_clone_ptr(arg: bigint): bigint {
33482 if(!isWasmInitialized) {
33483 throw new Error("initializeWasm() must be awaited first!");
33485 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone_ptr(arg);
33486 return nativeResponseValue;
33488 // struct LDKParseOrSemanticError ParseOrSemanticError_clone(const struct LDKParseOrSemanticError *NONNULL_PTR orig);
33490 export function ParseOrSemanticError_clone(orig: bigint): bigint {
33491 if(!isWasmInitialized) {
33492 throw new Error("initializeWasm() must be awaited first!");
33494 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone(orig);
33495 return nativeResponseValue;
33497 // struct LDKParseOrSemanticError ParseOrSemanticError_parse_error(struct LDKParseError a);
33499 export function ParseOrSemanticError_parse_error(a: bigint): bigint {
33500 if(!isWasmInitialized) {
33501 throw new Error("initializeWasm() must be awaited first!");
33503 const nativeResponseValue = wasm.TS_ParseOrSemanticError_parse_error(a);
33504 return nativeResponseValue;
33506 // struct LDKParseOrSemanticError ParseOrSemanticError_semantic_error(enum LDKSemanticError a);
33508 export function ParseOrSemanticError_semantic_error(a: SemanticError): bigint {
33509 if(!isWasmInitialized) {
33510 throw new Error("initializeWasm() must be awaited first!");
33512 const nativeResponseValue = wasm.TS_ParseOrSemanticError_semantic_error(a);
33513 return nativeResponseValue;
33515 // void Invoice_free(struct LDKInvoice this_obj);
33517 export function Invoice_free(this_obj: bigint): void {
33518 if(!isWasmInitialized) {
33519 throw new Error("initializeWasm() must be awaited first!");
33521 const nativeResponseValue = wasm.TS_Invoice_free(this_obj);
33522 // debug statements here
33524 // bool Invoice_eq(const struct LDKInvoice *NONNULL_PTR a, const struct LDKInvoice *NONNULL_PTR b);
33526 export function Invoice_eq(a: bigint, b: bigint): boolean {
33527 if(!isWasmInitialized) {
33528 throw new Error("initializeWasm() must be awaited first!");
33530 const nativeResponseValue = wasm.TS_Invoice_eq(a, b);
33531 return nativeResponseValue;
33533 // uint64_t Invoice_clone_ptr(LDKInvoice *NONNULL_PTR arg);
33535 export function Invoice_clone_ptr(arg: bigint): bigint {
33536 if(!isWasmInitialized) {
33537 throw new Error("initializeWasm() must be awaited first!");
33539 const nativeResponseValue = wasm.TS_Invoice_clone_ptr(arg);
33540 return nativeResponseValue;
33542 // struct LDKInvoice Invoice_clone(const struct LDKInvoice *NONNULL_PTR orig);
33544 export function Invoice_clone(orig: bigint): bigint {
33545 if(!isWasmInitialized) {
33546 throw new Error("initializeWasm() must be awaited first!");
33548 const nativeResponseValue = wasm.TS_Invoice_clone(orig);
33549 return nativeResponseValue;
33551 // uint64_t Invoice_hash(const struct LDKInvoice *NONNULL_PTR o);
33553 export function Invoice_hash(o: bigint): bigint {
33554 if(!isWasmInitialized) {
33555 throw new Error("initializeWasm() must be awaited first!");
33557 const nativeResponseValue = wasm.TS_Invoice_hash(o);
33558 return nativeResponseValue;
33560 // void SignedRawInvoice_free(struct LDKSignedRawInvoice this_obj);
33562 export function SignedRawInvoice_free(this_obj: bigint): void {
33563 if(!isWasmInitialized) {
33564 throw new Error("initializeWasm() must be awaited first!");
33566 const nativeResponseValue = wasm.TS_SignedRawInvoice_free(this_obj);
33567 // debug statements here
33569 // bool SignedRawInvoice_eq(const struct LDKSignedRawInvoice *NONNULL_PTR a, const struct LDKSignedRawInvoice *NONNULL_PTR b);
33571 export function SignedRawInvoice_eq(a: bigint, b: bigint): boolean {
33572 if(!isWasmInitialized) {
33573 throw new Error("initializeWasm() must be awaited first!");
33575 const nativeResponseValue = wasm.TS_SignedRawInvoice_eq(a, b);
33576 return nativeResponseValue;
33578 // uint64_t SignedRawInvoice_clone_ptr(LDKSignedRawInvoice *NONNULL_PTR arg);
33580 export function SignedRawInvoice_clone_ptr(arg: bigint): bigint {
33581 if(!isWasmInitialized) {
33582 throw new Error("initializeWasm() must be awaited first!");
33584 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone_ptr(arg);
33585 return nativeResponseValue;
33587 // struct LDKSignedRawInvoice SignedRawInvoice_clone(const struct LDKSignedRawInvoice *NONNULL_PTR orig);
33589 export function SignedRawInvoice_clone(orig: bigint): bigint {
33590 if(!isWasmInitialized) {
33591 throw new Error("initializeWasm() must be awaited first!");
33593 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone(orig);
33594 return nativeResponseValue;
33596 // uint64_t SignedRawInvoice_hash(const struct LDKSignedRawInvoice *NONNULL_PTR o);
33598 export function SignedRawInvoice_hash(o: bigint): bigint {
33599 if(!isWasmInitialized) {
33600 throw new Error("initializeWasm() must be awaited first!");
33602 const nativeResponseValue = wasm.TS_SignedRawInvoice_hash(o);
33603 return nativeResponseValue;
33605 // void RawInvoice_free(struct LDKRawInvoice this_obj);
33607 export function RawInvoice_free(this_obj: bigint): void {
33608 if(!isWasmInitialized) {
33609 throw new Error("initializeWasm() must be awaited first!");
33611 const nativeResponseValue = wasm.TS_RawInvoice_free(this_obj);
33612 // debug statements here
33614 // struct LDKRawDataPart RawInvoice_get_data(const struct LDKRawInvoice *NONNULL_PTR this_ptr);
33616 export function RawInvoice_get_data(this_ptr: bigint): bigint {
33617 if(!isWasmInitialized) {
33618 throw new Error("initializeWasm() must be awaited first!");
33620 const nativeResponseValue = wasm.TS_RawInvoice_get_data(this_ptr);
33621 return nativeResponseValue;
33623 // void RawInvoice_set_data(struct LDKRawInvoice *NONNULL_PTR this_ptr, struct LDKRawDataPart val);
33625 export function RawInvoice_set_data(this_ptr: bigint, val: bigint): void {
33626 if(!isWasmInitialized) {
33627 throw new Error("initializeWasm() must be awaited first!");
33629 const nativeResponseValue = wasm.TS_RawInvoice_set_data(this_ptr, val);
33630 // debug statements here
33632 // bool RawInvoice_eq(const struct LDKRawInvoice *NONNULL_PTR a, const struct LDKRawInvoice *NONNULL_PTR b);
33634 export function RawInvoice_eq(a: bigint, b: bigint): boolean {
33635 if(!isWasmInitialized) {
33636 throw new Error("initializeWasm() must be awaited first!");
33638 const nativeResponseValue = wasm.TS_RawInvoice_eq(a, b);
33639 return nativeResponseValue;
33641 // uint64_t RawInvoice_clone_ptr(LDKRawInvoice *NONNULL_PTR arg);
33643 export function RawInvoice_clone_ptr(arg: bigint): bigint {
33644 if(!isWasmInitialized) {
33645 throw new Error("initializeWasm() must be awaited first!");
33647 const nativeResponseValue = wasm.TS_RawInvoice_clone_ptr(arg);
33648 return nativeResponseValue;
33650 // struct LDKRawInvoice RawInvoice_clone(const struct LDKRawInvoice *NONNULL_PTR orig);
33652 export function RawInvoice_clone(orig: bigint): bigint {
33653 if(!isWasmInitialized) {
33654 throw new Error("initializeWasm() must be awaited first!");
33656 const nativeResponseValue = wasm.TS_RawInvoice_clone(orig);
33657 return nativeResponseValue;
33659 // uint64_t RawInvoice_hash(const struct LDKRawInvoice *NONNULL_PTR o);
33661 export function RawInvoice_hash(o: bigint): bigint {
33662 if(!isWasmInitialized) {
33663 throw new Error("initializeWasm() must be awaited first!");
33665 const nativeResponseValue = wasm.TS_RawInvoice_hash(o);
33666 return nativeResponseValue;
33668 // void RawDataPart_free(struct LDKRawDataPart this_obj);
33670 export function RawDataPart_free(this_obj: bigint): void {
33671 if(!isWasmInitialized) {
33672 throw new Error("initializeWasm() must be awaited first!");
33674 const nativeResponseValue = wasm.TS_RawDataPart_free(this_obj);
33675 // debug statements here
33677 // struct LDKPositiveTimestamp RawDataPart_get_timestamp(const struct LDKRawDataPart *NONNULL_PTR this_ptr);
33679 export function RawDataPart_get_timestamp(this_ptr: bigint): bigint {
33680 if(!isWasmInitialized) {
33681 throw new Error("initializeWasm() must be awaited first!");
33683 const nativeResponseValue = wasm.TS_RawDataPart_get_timestamp(this_ptr);
33684 return nativeResponseValue;
33686 // void RawDataPart_set_timestamp(struct LDKRawDataPart *NONNULL_PTR this_ptr, struct LDKPositiveTimestamp val);
33688 export function RawDataPart_set_timestamp(this_ptr: bigint, val: bigint): void {
33689 if(!isWasmInitialized) {
33690 throw new Error("initializeWasm() must be awaited first!");
33692 const nativeResponseValue = wasm.TS_RawDataPart_set_timestamp(this_ptr, val);
33693 // debug statements here
33695 // bool RawDataPart_eq(const struct LDKRawDataPart *NONNULL_PTR a, const struct LDKRawDataPart *NONNULL_PTR b);
33697 export function RawDataPart_eq(a: bigint, b: bigint): boolean {
33698 if(!isWasmInitialized) {
33699 throw new Error("initializeWasm() must be awaited first!");
33701 const nativeResponseValue = wasm.TS_RawDataPart_eq(a, b);
33702 return nativeResponseValue;
33704 // uint64_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg);
33706 export function RawDataPart_clone_ptr(arg: bigint): bigint {
33707 if(!isWasmInitialized) {
33708 throw new Error("initializeWasm() must be awaited first!");
33710 const nativeResponseValue = wasm.TS_RawDataPart_clone_ptr(arg);
33711 return nativeResponseValue;
33713 // struct LDKRawDataPart RawDataPart_clone(const struct LDKRawDataPart *NONNULL_PTR orig);
33715 export function RawDataPart_clone(orig: bigint): bigint {
33716 if(!isWasmInitialized) {
33717 throw new Error("initializeWasm() must be awaited first!");
33719 const nativeResponseValue = wasm.TS_RawDataPart_clone(orig);
33720 return nativeResponseValue;
33722 // uint64_t RawDataPart_hash(const struct LDKRawDataPart *NONNULL_PTR o);
33724 export function RawDataPart_hash(o: bigint): bigint {
33725 if(!isWasmInitialized) {
33726 throw new Error("initializeWasm() must be awaited first!");
33728 const nativeResponseValue = wasm.TS_RawDataPart_hash(o);
33729 return nativeResponseValue;
33731 // void PositiveTimestamp_free(struct LDKPositiveTimestamp this_obj);
33733 export function PositiveTimestamp_free(this_obj: bigint): void {
33734 if(!isWasmInitialized) {
33735 throw new Error("initializeWasm() must be awaited first!");
33737 const nativeResponseValue = wasm.TS_PositiveTimestamp_free(this_obj);
33738 // debug statements here
33740 // bool PositiveTimestamp_eq(const struct LDKPositiveTimestamp *NONNULL_PTR a, const struct LDKPositiveTimestamp *NONNULL_PTR b);
33742 export function PositiveTimestamp_eq(a: bigint, b: bigint): boolean {
33743 if(!isWasmInitialized) {
33744 throw new Error("initializeWasm() must be awaited first!");
33746 const nativeResponseValue = wasm.TS_PositiveTimestamp_eq(a, b);
33747 return nativeResponseValue;
33749 // uint64_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg);
33751 export function PositiveTimestamp_clone_ptr(arg: bigint): bigint {
33752 if(!isWasmInitialized) {
33753 throw new Error("initializeWasm() must be awaited first!");
33755 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone_ptr(arg);
33756 return nativeResponseValue;
33758 // struct LDKPositiveTimestamp PositiveTimestamp_clone(const struct LDKPositiveTimestamp *NONNULL_PTR orig);
33760 export function PositiveTimestamp_clone(orig: bigint): bigint {
33761 if(!isWasmInitialized) {
33762 throw new Error("initializeWasm() must be awaited first!");
33764 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone(orig);
33765 return nativeResponseValue;
33767 // uint64_t PositiveTimestamp_hash(const struct LDKPositiveTimestamp *NONNULL_PTR o);
33769 export function PositiveTimestamp_hash(o: bigint): bigint {
33770 if(!isWasmInitialized) {
33771 throw new Error("initializeWasm() must be awaited first!");
33773 const nativeResponseValue = wasm.TS_PositiveTimestamp_hash(o);
33774 return nativeResponseValue;
33776 // enum LDKSiPrefix SiPrefix_clone(const enum LDKSiPrefix *NONNULL_PTR orig);
33778 export function SiPrefix_clone(orig: bigint): SiPrefix {
33779 if(!isWasmInitialized) {
33780 throw new Error("initializeWasm() must be awaited first!");
33782 const nativeResponseValue = wasm.TS_SiPrefix_clone(orig);
33783 return nativeResponseValue;
33785 // enum LDKSiPrefix SiPrefix_milli(void);
33787 export function SiPrefix_milli(): SiPrefix {
33788 if(!isWasmInitialized) {
33789 throw new Error("initializeWasm() must be awaited first!");
33791 const nativeResponseValue = wasm.TS_SiPrefix_milli();
33792 return nativeResponseValue;
33794 // enum LDKSiPrefix SiPrefix_micro(void);
33796 export function SiPrefix_micro(): SiPrefix {
33797 if(!isWasmInitialized) {
33798 throw new Error("initializeWasm() must be awaited first!");
33800 const nativeResponseValue = wasm.TS_SiPrefix_micro();
33801 return nativeResponseValue;
33803 // enum LDKSiPrefix SiPrefix_nano(void);
33805 export function SiPrefix_nano(): SiPrefix {
33806 if(!isWasmInitialized) {
33807 throw new Error("initializeWasm() must be awaited first!");
33809 const nativeResponseValue = wasm.TS_SiPrefix_nano();
33810 return nativeResponseValue;
33812 // enum LDKSiPrefix SiPrefix_pico(void);
33814 export function SiPrefix_pico(): SiPrefix {
33815 if(!isWasmInitialized) {
33816 throw new Error("initializeWasm() must be awaited first!");
33818 const nativeResponseValue = wasm.TS_SiPrefix_pico();
33819 return nativeResponseValue;
33821 // bool SiPrefix_eq(const enum LDKSiPrefix *NONNULL_PTR a, const enum LDKSiPrefix *NONNULL_PTR b);
33823 export function SiPrefix_eq(a: bigint, b: bigint): boolean {
33824 if(!isWasmInitialized) {
33825 throw new Error("initializeWasm() must be awaited first!");
33827 const nativeResponseValue = wasm.TS_SiPrefix_eq(a, b);
33828 return nativeResponseValue;
33830 // uint64_t SiPrefix_hash(const enum LDKSiPrefix *NONNULL_PTR o);
33832 export function SiPrefix_hash(o: bigint): bigint {
33833 if(!isWasmInitialized) {
33834 throw new Error("initializeWasm() must be awaited first!");
33836 const nativeResponseValue = wasm.TS_SiPrefix_hash(o);
33837 return nativeResponseValue;
33839 // MUST_USE_RES uint64_t SiPrefix_multiplier(const enum LDKSiPrefix *NONNULL_PTR this_arg);
33841 export function SiPrefix_multiplier(this_arg: bigint): bigint {
33842 if(!isWasmInitialized) {
33843 throw new Error("initializeWasm() must be awaited first!");
33845 const nativeResponseValue = wasm.TS_SiPrefix_multiplier(this_arg);
33846 return nativeResponseValue;
33848 // enum LDKCurrency Currency_clone(const enum LDKCurrency *NONNULL_PTR orig);
33850 export function Currency_clone(orig: bigint): Currency {
33851 if(!isWasmInitialized) {
33852 throw new Error("initializeWasm() must be awaited first!");
33854 const nativeResponseValue = wasm.TS_Currency_clone(orig);
33855 return nativeResponseValue;
33857 // enum LDKCurrency Currency_bitcoin(void);
33859 export function Currency_bitcoin(): Currency {
33860 if(!isWasmInitialized) {
33861 throw new Error("initializeWasm() must be awaited first!");
33863 const nativeResponseValue = wasm.TS_Currency_bitcoin();
33864 return nativeResponseValue;
33866 // enum LDKCurrency Currency_bitcoin_testnet(void);
33868 export function Currency_bitcoin_testnet(): Currency {
33869 if(!isWasmInitialized) {
33870 throw new Error("initializeWasm() must be awaited first!");
33872 const nativeResponseValue = wasm.TS_Currency_bitcoin_testnet();
33873 return nativeResponseValue;
33875 // enum LDKCurrency Currency_regtest(void);
33877 export function Currency_regtest(): Currency {
33878 if(!isWasmInitialized) {
33879 throw new Error("initializeWasm() must be awaited first!");
33881 const nativeResponseValue = wasm.TS_Currency_regtest();
33882 return nativeResponseValue;
33884 // enum LDKCurrency Currency_simnet(void);
33886 export function Currency_simnet(): Currency {
33887 if(!isWasmInitialized) {
33888 throw new Error("initializeWasm() must be awaited first!");
33890 const nativeResponseValue = wasm.TS_Currency_simnet();
33891 return nativeResponseValue;
33893 // enum LDKCurrency Currency_signet(void);
33895 export function Currency_signet(): Currency {
33896 if(!isWasmInitialized) {
33897 throw new Error("initializeWasm() must be awaited first!");
33899 const nativeResponseValue = wasm.TS_Currency_signet();
33900 return nativeResponseValue;
33902 // uint64_t Currency_hash(const enum LDKCurrency *NONNULL_PTR o);
33904 export function Currency_hash(o: bigint): bigint {
33905 if(!isWasmInitialized) {
33906 throw new Error("initializeWasm() must be awaited first!");
33908 const nativeResponseValue = wasm.TS_Currency_hash(o);
33909 return nativeResponseValue;
33911 // bool Currency_eq(const enum LDKCurrency *NONNULL_PTR a, const enum LDKCurrency *NONNULL_PTR b);
33913 export function Currency_eq(a: bigint, b: bigint): boolean {
33914 if(!isWasmInitialized) {
33915 throw new Error("initializeWasm() must be awaited first!");
33917 const nativeResponseValue = wasm.TS_Currency_eq(a, b);
33918 return nativeResponseValue;
33920 // void Sha256_free(struct LDKSha256 this_obj);
33922 export function Sha256_free(this_obj: bigint): void {
33923 if(!isWasmInitialized) {
33924 throw new Error("initializeWasm() must be awaited first!");
33926 const nativeResponseValue = wasm.TS_Sha256_free(this_obj);
33927 // debug statements here
33929 // uint64_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg);
33931 export function Sha256_clone_ptr(arg: bigint): bigint {
33932 if(!isWasmInitialized) {
33933 throw new Error("initializeWasm() must be awaited first!");
33935 const nativeResponseValue = wasm.TS_Sha256_clone_ptr(arg);
33936 return nativeResponseValue;
33938 // struct LDKSha256 Sha256_clone(const struct LDKSha256 *NONNULL_PTR orig);
33940 export function Sha256_clone(orig: bigint): bigint {
33941 if(!isWasmInitialized) {
33942 throw new Error("initializeWasm() must be awaited first!");
33944 const nativeResponseValue = wasm.TS_Sha256_clone(orig);
33945 return nativeResponseValue;
33947 // uint64_t Sha256_hash(const struct LDKSha256 *NONNULL_PTR o);
33949 export function Sha256_hash(o: bigint): bigint {
33950 if(!isWasmInitialized) {
33951 throw new Error("initializeWasm() must be awaited first!");
33953 const nativeResponseValue = wasm.TS_Sha256_hash(o);
33954 return nativeResponseValue;
33956 // bool Sha256_eq(const struct LDKSha256 *NONNULL_PTR a, const struct LDKSha256 *NONNULL_PTR b);
33958 export function Sha256_eq(a: bigint, b: bigint): boolean {
33959 if(!isWasmInitialized) {
33960 throw new Error("initializeWasm() must be awaited first!");
33962 const nativeResponseValue = wasm.TS_Sha256_eq(a, b);
33963 return nativeResponseValue;
33965 // void Description_free(struct LDKDescription this_obj);
33967 export function Description_free(this_obj: bigint): void {
33968 if(!isWasmInitialized) {
33969 throw new Error("initializeWasm() must be awaited first!");
33971 const nativeResponseValue = wasm.TS_Description_free(this_obj);
33972 // debug statements here
33974 // uint64_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg);
33976 export function Description_clone_ptr(arg: bigint): bigint {
33977 if(!isWasmInitialized) {
33978 throw new Error("initializeWasm() must be awaited first!");
33980 const nativeResponseValue = wasm.TS_Description_clone_ptr(arg);
33981 return nativeResponseValue;
33983 // struct LDKDescription Description_clone(const struct LDKDescription *NONNULL_PTR orig);
33985 export function Description_clone(orig: bigint): bigint {
33986 if(!isWasmInitialized) {
33987 throw new Error("initializeWasm() must be awaited first!");
33989 const nativeResponseValue = wasm.TS_Description_clone(orig);
33990 return nativeResponseValue;
33992 // uint64_t Description_hash(const struct LDKDescription *NONNULL_PTR o);
33994 export function Description_hash(o: bigint): bigint {
33995 if(!isWasmInitialized) {
33996 throw new Error("initializeWasm() must be awaited first!");
33998 const nativeResponseValue = wasm.TS_Description_hash(o);
33999 return nativeResponseValue;
34001 // bool Description_eq(const struct LDKDescription *NONNULL_PTR a, const struct LDKDescription *NONNULL_PTR b);
34003 export function Description_eq(a: bigint, b: bigint): boolean {
34004 if(!isWasmInitialized) {
34005 throw new Error("initializeWasm() must be awaited first!");
34007 const nativeResponseValue = wasm.TS_Description_eq(a, b);
34008 return nativeResponseValue;
34010 // void PayeePubKey_free(struct LDKPayeePubKey this_obj);
34012 export function PayeePubKey_free(this_obj: bigint): void {
34013 if(!isWasmInitialized) {
34014 throw new Error("initializeWasm() must be awaited first!");
34016 const nativeResponseValue = wasm.TS_PayeePubKey_free(this_obj);
34017 // debug statements here
34019 // struct LDKPublicKey PayeePubKey_get_a(const struct LDKPayeePubKey *NONNULL_PTR this_ptr);
34021 export function PayeePubKey_get_a(this_ptr: bigint): number {
34022 if(!isWasmInitialized) {
34023 throw new Error("initializeWasm() must be awaited first!");
34025 const nativeResponseValue = wasm.TS_PayeePubKey_get_a(this_ptr);
34026 return nativeResponseValue;
34028 // void PayeePubKey_set_a(struct LDKPayeePubKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
34030 export function PayeePubKey_set_a(this_ptr: bigint, val: number): void {
34031 if(!isWasmInitialized) {
34032 throw new Error("initializeWasm() must be awaited first!");
34034 const nativeResponseValue = wasm.TS_PayeePubKey_set_a(this_ptr, val);
34035 // debug statements here
34037 // MUST_USE_RES struct LDKPayeePubKey PayeePubKey_new(struct LDKPublicKey a_arg);
34039 export function PayeePubKey_new(a_arg: number): bigint {
34040 if(!isWasmInitialized) {
34041 throw new Error("initializeWasm() must be awaited first!");
34043 const nativeResponseValue = wasm.TS_PayeePubKey_new(a_arg);
34044 return nativeResponseValue;
34046 // uint64_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg);
34048 export function PayeePubKey_clone_ptr(arg: bigint): bigint {
34049 if(!isWasmInitialized) {
34050 throw new Error("initializeWasm() must be awaited first!");
34052 const nativeResponseValue = wasm.TS_PayeePubKey_clone_ptr(arg);
34053 return nativeResponseValue;
34055 // struct LDKPayeePubKey PayeePubKey_clone(const struct LDKPayeePubKey *NONNULL_PTR orig);
34057 export function PayeePubKey_clone(orig: bigint): bigint {
34058 if(!isWasmInitialized) {
34059 throw new Error("initializeWasm() must be awaited first!");
34061 const nativeResponseValue = wasm.TS_PayeePubKey_clone(orig);
34062 return nativeResponseValue;
34064 // uint64_t PayeePubKey_hash(const struct LDKPayeePubKey *NONNULL_PTR o);
34066 export function PayeePubKey_hash(o: bigint): bigint {
34067 if(!isWasmInitialized) {
34068 throw new Error("initializeWasm() must be awaited first!");
34070 const nativeResponseValue = wasm.TS_PayeePubKey_hash(o);
34071 return nativeResponseValue;
34073 // bool PayeePubKey_eq(const struct LDKPayeePubKey *NONNULL_PTR a, const struct LDKPayeePubKey *NONNULL_PTR b);
34075 export function PayeePubKey_eq(a: bigint, b: bigint): boolean {
34076 if(!isWasmInitialized) {
34077 throw new Error("initializeWasm() must be awaited first!");
34079 const nativeResponseValue = wasm.TS_PayeePubKey_eq(a, b);
34080 return nativeResponseValue;
34082 // void ExpiryTime_free(struct LDKExpiryTime this_obj);
34084 export function ExpiryTime_free(this_obj: bigint): void {
34085 if(!isWasmInitialized) {
34086 throw new Error("initializeWasm() must be awaited first!");
34088 const nativeResponseValue = wasm.TS_ExpiryTime_free(this_obj);
34089 // debug statements here
34091 // uint64_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg);
34093 export function ExpiryTime_clone_ptr(arg: bigint): bigint {
34094 if(!isWasmInitialized) {
34095 throw new Error("initializeWasm() must be awaited first!");
34097 const nativeResponseValue = wasm.TS_ExpiryTime_clone_ptr(arg);
34098 return nativeResponseValue;
34100 // struct LDKExpiryTime ExpiryTime_clone(const struct LDKExpiryTime *NONNULL_PTR orig);
34102 export function ExpiryTime_clone(orig: bigint): bigint {
34103 if(!isWasmInitialized) {
34104 throw new Error("initializeWasm() must be awaited first!");
34106 const nativeResponseValue = wasm.TS_ExpiryTime_clone(orig);
34107 return nativeResponseValue;
34109 // uint64_t ExpiryTime_hash(const struct LDKExpiryTime *NONNULL_PTR o);
34111 export function ExpiryTime_hash(o: bigint): bigint {
34112 if(!isWasmInitialized) {
34113 throw new Error("initializeWasm() must be awaited first!");
34115 const nativeResponseValue = wasm.TS_ExpiryTime_hash(o);
34116 return nativeResponseValue;
34118 // bool ExpiryTime_eq(const struct LDKExpiryTime *NONNULL_PTR a, const struct LDKExpiryTime *NONNULL_PTR b);
34120 export function ExpiryTime_eq(a: bigint, b: bigint): boolean {
34121 if(!isWasmInitialized) {
34122 throw new Error("initializeWasm() must be awaited first!");
34124 const nativeResponseValue = wasm.TS_ExpiryTime_eq(a, b);
34125 return nativeResponseValue;
34127 // void MinFinalCltvExpiry_free(struct LDKMinFinalCltvExpiry this_obj);
34129 export function MinFinalCltvExpiry_free(this_obj: bigint): void {
34130 if(!isWasmInitialized) {
34131 throw new Error("initializeWasm() must be awaited first!");
34133 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_free(this_obj);
34134 // debug statements here
34136 // uint64_t MinFinalCltvExpiry_get_a(const struct LDKMinFinalCltvExpiry *NONNULL_PTR this_ptr);
34138 export function MinFinalCltvExpiry_get_a(this_ptr: bigint): bigint {
34139 if(!isWasmInitialized) {
34140 throw new Error("initializeWasm() must be awaited first!");
34142 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_get_a(this_ptr);
34143 return nativeResponseValue;
34145 // void MinFinalCltvExpiry_set_a(struct LDKMinFinalCltvExpiry *NONNULL_PTR this_ptr, uint64_t val);
34147 export function MinFinalCltvExpiry_set_a(this_ptr: bigint, val: bigint): void {
34148 if(!isWasmInitialized) {
34149 throw new Error("initializeWasm() must be awaited first!");
34151 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_set_a(this_ptr, val);
34152 // debug statements here
34154 // MUST_USE_RES struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_new(uint64_t a_arg);
34156 export function MinFinalCltvExpiry_new(a_arg: bigint): bigint {
34157 if(!isWasmInitialized) {
34158 throw new Error("initializeWasm() must be awaited first!");
34160 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_new(a_arg);
34161 return nativeResponseValue;
34163 // uint64_t MinFinalCltvExpiry_clone_ptr(LDKMinFinalCltvExpiry *NONNULL_PTR arg);
34165 export function MinFinalCltvExpiry_clone_ptr(arg: bigint): bigint {
34166 if(!isWasmInitialized) {
34167 throw new Error("initializeWasm() must be awaited first!");
34169 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_clone_ptr(arg);
34170 return nativeResponseValue;
34172 // struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_clone(const struct LDKMinFinalCltvExpiry *NONNULL_PTR orig);
34174 export function MinFinalCltvExpiry_clone(orig: bigint): bigint {
34175 if(!isWasmInitialized) {
34176 throw new Error("initializeWasm() must be awaited first!");
34178 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_clone(orig);
34179 return nativeResponseValue;
34181 // uint64_t MinFinalCltvExpiry_hash(const struct LDKMinFinalCltvExpiry *NONNULL_PTR o);
34183 export function MinFinalCltvExpiry_hash(o: bigint): bigint {
34184 if(!isWasmInitialized) {
34185 throw new Error("initializeWasm() must be awaited first!");
34187 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_hash(o);
34188 return nativeResponseValue;
34190 // bool MinFinalCltvExpiry_eq(const struct LDKMinFinalCltvExpiry *NONNULL_PTR a, const struct LDKMinFinalCltvExpiry *NONNULL_PTR b);
34192 export function MinFinalCltvExpiry_eq(a: bigint, b: bigint): boolean {
34193 if(!isWasmInitialized) {
34194 throw new Error("initializeWasm() must be awaited first!");
34196 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_eq(a, b);
34197 return nativeResponseValue;
34199 // void Fallback_free(struct LDKFallback this_ptr);
34201 export function Fallback_free(this_ptr: bigint): void {
34202 if(!isWasmInitialized) {
34203 throw new Error("initializeWasm() must be awaited first!");
34205 const nativeResponseValue = wasm.TS_Fallback_free(this_ptr);
34206 // debug statements here
34208 // uint64_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg);
34210 export function Fallback_clone_ptr(arg: bigint): bigint {
34211 if(!isWasmInitialized) {
34212 throw new Error("initializeWasm() must be awaited first!");
34214 const nativeResponseValue = wasm.TS_Fallback_clone_ptr(arg);
34215 return nativeResponseValue;
34217 // struct LDKFallback Fallback_clone(const struct LDKFallback *NONNULL_PTR orig);
34219 export function Fallback_clone(orig: bigint): bigint {
34220 if(!isWasmInitialized) {
34221 throw new Error("initializeWasm() must be awaited first!");
34223 const nativeResponseValue = wasm.TS_Fallback_clone(orig);
34224 return nativeResponseValue;
34226 // struct LDKFallback Fallback_seg_wit_program(struct LDKu5 version, struct LDKCVec_u8Z program);
34228 export function Fallback_seg_wit_program(version: number, program: number): bigint {
34229 if(!isWasmInitialized) {
34230 throw new Error("initializeWasm() must be awaited first!");
34232 const nativeResponseValue = wasm.TS_Fallback_seg_wit_program(version, program);
34233 return nativeResponseValue;
34235 // struct LDKFallback Fallback_pub_key_hash(struct LDKTwentyBytes a);
34237 export function Fallback_pub_key_hash(a: number): bigint {
34238 if(!isWasmInitialized) {
34239 throw new Error("initializeWasm() must be awaited first!");
34241 const nativeResponseValue = wasm.TS_Fallback_pub_key_hash(a);
34242 return nativeResponseValue;
34244 // struct LDKFallback Fallback_script_hash(struct LDKTwentyBytes a);
34246 export function Fallback_script_hash(a: number): bigint {
34247 if(!isWasmInitialized) {
34248 throw new Error("initializeWasm() must be awaited first!");
34250 const nativeResponseValue = wasm.TS_Fallback_script_hash(a);
34251 return nativeResponseValue;
34253 // uint64_t Fallback_hash(const struct LDKFallback *NONNULL_PTR o);
34255 export function Fallback_hash(o: bigint): bigint {
34256 if(!isWasmInitialized) {
34257 throw new Error("initializeWasm() must be awaited first!");
34259 const nativeResponseValue = wasm.TS_Fallback_hash(o);
34260 return nativeResponseValue;
34262 // bool Fallback_eq(const struct LDKFallback *NONNULL_PTR a, const struct LDKFallback *NONNULL_PTR b);
34264 export function Fallback_eq(a: bigint, b: bigint): boolean {
34265 if(!isWasmInitialized) {
34266 throw new Error("initializeWasm() must be awaited first!");
34268 const nativeResponseValue = wasm.TS_Fallback_eq(a, b);
34269 return nativeResponseValue;
34271 // void InvoiceSignature_free(struct LDKInvoiceSignature this_obj);
34273 export function InvoiceSignature_free(this_obj: bigint): void {
34274 if(!isWasmInitialized) {
34275 throw new Error("initializeWasm() must be awaited first!");
34277 const nativeResponseValue = wasm.TS_InvoiceSignature_free(this_obj);
34278 // debug statements here
34280 // uint64_t InvoiceSignature_clone_ptr(LDKInvoiceSignature *NONNULL_PTR arg);
34282 export function InvoiceSignature_clone_ptr(arg: bigint): bigint {
34283 if(!isWasmInitialized) {
34284 throw new Error("initializeWasm() must be awaited first!");
34286 const nativeResponseValue = wasm.TS_InvoiceSignature_clone_ptr(arg);
34287 return nativeResponseValue;
34289 // struct LDKInvoiceSignature InvoiceSignature_clone(const struct LDKInvoiceSignature *NONNULL_PTR orig);
34291 export function InvoiceSignature_clone(orig: bigint): bigint {
34292 if(!isWasmInitialized) {
34293 throw new Error("initializeWasm() must be awaited first!");
34295 const nativeResponseValue = wasm.TS_InvoiceSignature_clone(orig);
34296 return nativeResponseValue;
34298 // uint64_t InvoiceSignature_hash(const struct LDKInvoiceSignature *NONNULL_PTR o);
34300 export function InvoiceSignature_hash(o: bigint): bigint {
34301 if(!isWasmInitialized) {
34302 throw new Error("initializeWasm() must be awaited first!");
34304 const nativeResponseValue = wasm.TS_InvoiceSignature_hash(o);
34305 return nativeResponseValue;
34307 // bool InvoiceSignature_eq(const struct LDKInvoiceSignature *NONNULL_PTR a, const struct LDKInvoiceSignature *NONNULL_PTR b);
34309 export function InvoiceSignature_eq(a: bigint, b: bigint): boolean {
34310 if(!isWasmInitialized) {
34311 throw new Error("initializeWasm() must be awaited first!");
34313 const nativeResponseValue = wasm.TS_InvoiceSignature_eq(a, b);
34314 return nativeResponseValue;
34316 // void PrivateRoute_free(struct LDKPrivateRoute this_obj);
34318 export function PrivateRoute_free(this_obj: bigint): void {
34319 if(!isWasmInitialized) {
34320 throw new Error("initializeWasm() must be awaited first!");
34322 const nativeResponseValue = wasm.TS_PrivateRoute_free(this_obj);
34323 // debug statements here
34325 // uint64_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg);
34327 export function PrivateRoute_clone_ptr(arg: bigint): bigint {
34328 if(!isWasmInitialized) {
34329 throw new Error("initializeWasm() must be awaited first!");
34331 const nativeResponseValue = wasm.TS_PrivateRoute_clone_ptr(arg);
34332 return nativeResponseValue;
34334 // struct LDKPrivateRoute PrivateRoute_clone(const struct LDKPrivateRoute *NONNULL_PTR orig);
34336 export function PrivateRoute_clone(orig: bigint): bigint {
34337 if(!isWasmInitialized) {
34338 throw new Error("initializeWasm() must be awaited first!");
34340 const nativeResponseValue = wasm.TS_PrivateRoute_clone(orig);
34341 return nativeResponseValue;
34343 // uint64_t PrivateRoute_hash(const struct LDKPrivateRoute *NONNULL_PTR o);
34345 export function PrivateRoute_hash(o: bigint): bigint {
34346 if(!isWasmInitialized) {
34347 throw new Error("initializeWasm() must be awaited first!");
34349 const nativeResponseValue = wasm.TS_PrivateRoute_hash(o);
34350 return nativeResponseValue;
34352 // bool PrivateRoute_eq(const struct LDKPrivateRoute *NONNULL_PTR a, const struct LDKPrivateRoute *NONNULL_PTR b);
34354 export function PrivateRoute_eq(a: bigint, b: bigint): boolean {
34355 if(!isWasmInitialized) {
34356 throw new Error("initializeWasm() must be awaited first!");
34358 const nativeResponseValue = wasm.TS_PrivateRoute_eq(a, b);
34359 return nativeResponseValue;
34361 // MUST_USE_RES struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ SignedRawInvoice_into_parts(struct LDKSignedRawInvoice this_arg);
34363 export function SignedRawInvoice_into_parts(this_arg: bigint): bigint {
34364 if(!isWasmInitialized) {
34365 throw new Error("initializeWasm() must be awaited first!");
34367 const nativeResponseValue = wasm.TS_SignedRawInvoice_into_parts(this_arg);
34368 return nativeResponseValue;
34370 // MUST_USE_RES struct LDKRawInvoice SignedRawInvoice_raw_invoice(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
34372 export function SignedRawInvoice_raw_invoice(this_arg: bigint): bigint {
34373 if(!isWasmInitialized) {
34374 throw new Error("initializeWasm() must be awaited first!");
34376 const nativeResponseValue = wasm.TS_SignedRawInvoice_raw_invoice(this_arg);
34377 return nativeResponseValue;
34379 // MUST_USE_RES const uint8_t (*SignedRawInvoice_signable_hash(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg))[32];
34381 export function SignedRawInvoice_signable_hash(this_arg: bigint): number {
34382 if(!isWasmInitialized) {
34383 throw new Error("initializeWasm() must be awaited first!");
34385 const nativeResponseValue = wasm.TS_SignedRawInvoice_signable_hash(this_arg);
34386 return nativeResponseValue;
34388 // MUST_USE_RES struct LDKInvoiceSignature SignedRawInvoice_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
34390 export function SignedRawInvoice_signature(this_arg: bigint): bigint {
34391 if(!isWasmInitialized) {
34392 throw new Error("initializeWasm() must be awaited first!");
34394 const nativeResponseValue = wasm.TS_SignedRawInvoice_signature(this_arg);
34395 return nativeResponseValue;
34397 // MUST_USE_RES struct LDKCResult_PayeePubKeyErrorZ SignedRawInvoice_recover_payee_pub_key(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
34399 export function SignedRawInvoice_recover_payee_pub_key(this_arg: bigint): bigint {
34400 if(!isWasmInitialized) {
34401 throw new Error("initializeWasm() must be awaited first!");
34403 const nativeResponseValue = wasm.TS_SignedRawInvoice_recover_payee_pub_key(this_arg);
34404 return nativeResponseValue;
34406 // MUST_USE_RES bool SignedRawInvoice_check_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
34408 export function SignedRawInvoice_check_signature(this_arg: bigint): boolean {
34409 if(!isWasmInitialized) {
34410 throw new Error("initializeWasm() must be awaited first!");
34412 const nativeResponseValue = wasm.TS_SignedRawInvoice_check_signature(this_arg);
34413 return nativeResponseValue;
34415 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_signable_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
34417 export function RawInvoice_signable_hash(this_arg: bigint): number {
34418 if(!isWasmInitialized) {
34419 throw new Error("initializeWasm() must be awaited first!");
34421 const nativeResponseValue = wasm.TS_RawInvoice_signable_hash(this_arg);
34422 return nativeResponseValue;
34424 // MUST_USE_RES struct LDKSha256 RawInvoice_payment_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
34426 export function RawInvoice_payment_hash(this_arg: bigint): bigint {
34427 if(!isWasmInitialized) {
34428 throw new Error("initializeWasm() must be awaited first!");
34430 const nativeResponseValue = wasm.TS_RawInvoice_payment_hash(this_arg);
34431 return nativeResponseValue;
34433 // MUST_USE_RES struct LDKDescription RawInvoice_description(const struct LDKRawInvoice *NONNULL_PTR this_arg);
34435 export function RawInvoice_description(this_arg: bigint): bigint {
34436 if(!isWasmInitialized) {
34437 throw new Error("initializeWasm() must be awaited first!");
34439 const nativeResponseValue = wasm.TS_RawInvoice_description(this_arg);
34440 return nativeResponseValue;
34442 // MUST_USE_RES struct LDKPayeePubKey RawInvoice_payee_pub_key(const struct LDKRawInvoice *NONNULL_PTR this_arg);
34444 export function RawInvoice_payee_pub_key(this_arg: bigint): bigint {
34445 if(!isWasmInitialized) {
34446 throw new Error("initializeWasm() must be awaited first!");
34448 const nativeResponseValue = wasm.TS_RawInvoice_payee_pub_key(this_arg);
34449 return nativeResponseValue;
34451 // MUST_USE_RES struct LDKSha256 RawInvoice_description_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
34453 export function RawInvoice_description_hash(this_arg: bigint): bigint {
34454 if(!isWasmInitialized) {
34455 throw new Error("initializeWasm() must be awaited first!");
34457 const nativeResponseValue = wasm.TS_RawInvoice_description_hash(this_arg);
34458 return nativeResponseValue;
34460 // MUST_USE_RES struct LDKExpiryTime RawInvoice_expiry_time(const struct LDKRawInvoice *NONNULL_PTR this_arg);
34462 export function RawInvoice_expiry_time(this_arg: bigint): bigint {
34463 if(!isWasmInitialized) {
34464 throw new Error("initializeWasm() must be awaited first!");
34466 const nativeResponseValue = wasm.TS_RawInvoice_expiry_time(this_arg);
34467 return nativeResponseValue;
34469 // MUST_USE_RES struct LDKMinFinalCltvExpiry RawInvoice_min_final_cltv_expiry(const struct LDKRawInvoice *NONNULL_PTR this_arg);
34471 export function RawInvoice_min_final_cltv_expiry(this_arg: bigint): bigint {
34472 if(!isWasmInitialized) {
34473 throw new Error("initializeWasm() must be awaited first!");
34475 const nativeResponseValue = wasm.TS_RawInvoice_min_final_cltv_expiry(this_arg);
34476 return nativeResponseValue;
34478 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_payment_secret(const struct LDKRawInvoice *NONNULL_PTR this_arg);
34480 export function RawInvoice_payment_secret(this_arg: bigint): number {
34481 if(!isWasmInitialized) {
34482 throw new Error("initializeWasm() must be awaited first!");
34484 const nativeResponseValue = wasm.TS_RawInvoice_payment_secret(this_arg);
34485 return nativeResponseValue;
34487 // MUST_USE_RES struct LDKInvoiceFeatures RawInvoice_features(const struct LDKRawInvoice *NONNULL_PTR this_arg);
34489 export function RawInvoice_features(this_arg: bigint): bigint {
34490 if(!isWasmInitialized) {
34491 throw new Error("initializeWasm() must be awaited first!");
34493 const nativeResponseValue = wasm.TS_RawInvoice_features(this_arg);
34494 return nativeResponseValue;
34496 // MUST_USE_RES struct LDKCVec_PrivateRouteZ RawInvoice_private_routes(const struct LDKRawInvoice *NONNULL_PTR this_arg);
34498 export function RawInvoice_private_routes(this_arg: bigint): number {
34499 if(!isWasmInitialized) {
34500 throw new Error("initializeWasm() must be awaited first!");
34502 const nativeResponseValue = wasm.TS_RawInvoice_private_routes(this_arg);
34503 return nativeResponseValue;
34505 // MUST_USE_RES struct LDKCOption_u64Z RawInvoice_amount_pico_btc(const struct LDKRawInvoice *NONNULL_PTR this_arg);
34507 export function RawInvoice_amount_pico_btc(this_arg: bigint): bigint {
34508 if(!isWasmInitialized) {
34509 throw new Error("initializeWasm() must be awaited first!");
34511 const nativeResponseValue = wasm.TS_RawInvoice_amount_pico_btc(this_arg);
34512 return nativeResponseValue;
34514 // MUST_USE_RES enum LDKCurrency RawInvoice_currency(const struct LDKRawInvoice *NONNULL_PTR this_arg);
34516 export function RawInvoice_currency(this_arg: bigint): Currency {
34517 if(!isWasmInitialized) {
34518 throw new Error("initializeWasm() must be awaited first!");
34520 const nativeResponseValue = wasm.TS_RawInvoice_currency(this_arg);
34521 return nativeResponseValue;
34523 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_unix_timestamp(uint64_t unix_seconds);
34525 export function PositiveTimestamp_from_unix_timestamp(unix_seconds: bigint): bigint {
34526 if(!isWasmInitialized) {
34527 throw new Error("initializeWasm() must be awaited first!");
34529 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_unix_timestamp(unix_seconds);
34530 return nativeResponseValue;
34532 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_duration_since_epoch(uint64_t duration);
34534 export function PositiveTimestamp_from_duration_since_epoch(duration: bigint): bigint {
34535 if(!isWasmInitialized) {
34536 throw new Error("initializeWasm() must be awaited first!");
34538 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_duration_since_epoch(duration);
34539 return nativeResponseValue;
34541 // MUST_USE_RES uint64_t PositiveTimestamp_as_unix_timestamp(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
34543 export function PositiveTimestamp_as_unix_timestamp(this_arg: bigint): bigint {
34544 if(!isWasmInitialized) {
34545 throw new Error("initializeWasm() must be awaited first!");
34547 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_unix_timestamp(this_arg);
34548 return nativeResponseValue;
34550 // MUST_USE_RES uint64_t PositiveTimestamp_as_duration_since_epoch(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
34552 export function PositiveTimestamp_as_duration_since_epoch(this_arg: bigint): bigint {
34553 if(!isWasmInitialized) {
34554 throw new Error("initializeWasm() must be awaited first!");
34556 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_duration_since_epoch(this_arg);
34557 return nativeResponseValue;
34559 // MUST_USE_RES struct LDKSignedRawInvoice Invoice_into_signed_raw(struct LDKInvoice this_arg);
34561 export function Invoice_into_signed_raw(this_arg: bigint): bigint {
34562 if(!isWasmInitialized) {
34563 throw new Error("initializeWasm() must be awaited first!");
34565 const nativeResponseValue = wasm.TS_Invoice_into_signed_raw(this_arg);
34566 return nativeResponseValue;
34568 // MUST_USE_RES struct LDKCResult_NoneSemanticErrorZ Invoice_check_signature(const struct LDKInvoice *NONNULL_PTR this_arg);
34570 export function Invoice_check_signature(this_arg: bigint): bigint {
34571 if(!isWasmInitialized) {
34572 throw new Error("initializeWasm() must be awaited first!");
34574 const nativeResponseValue = wasm.TS_Invoice_check_signature(this_arg);
34575 return nativeResponseValue;
34577 // MUST_USE_RES struct LDKCResult_InvoiceSemanticErrorZ Invoice_from_signed(struct LDKSignedRawInvoice signed_invoice);
34579 export function Invoice_from_signed(signed_invoice: bigint): bigint {
34580 if(!isWasmInitialized) {
34581 throw new Error("initializeWasm() must be awaited first!");
34583 const nativeResponseValue = wasm.TS_Invoice_from_signed(signed_invoice);
34584 return nativeResponseValue;
34586 // MUST_USE_RES uint64_t Invoice_duration_since_epoch(const struct LDKInvoice *NONNULL_PTR this_arg);
34588 export function Invoice_duration_since_epoch(this_arg: bigint): bigint {
34589 if(!isWasmInitialized) {
34590 throw new Error("initializeWasm() must be awaited first!");
34592 const nativeResponseValue = wasm.TS_Invoice_duration_since_epoch(this_arg);
34593 return nativeResponseValue;
34595 // MUST_USE_RES const uint8_t (*Invoice_payment_hash(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
34597 export function Invoice_payment_hash(this_arg: bigint): number {
34598 if(!isWasmInitialized) {
34599 throw new Error("initializeWasm() must be awaited first!");
34601 const nativeResponseValue = wasm.TS_Invoice_payment_hash(this_arg);
34602 return nativeResponseValue;
34604 // MUST_USE_RES struct LDKPublicKey Invoice_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
34606 export function Invoice_payee_pub_key(this_arg: bigint): number {
34607 if(!isWasmInitialized) {
34608 throw new Error("initializeWasm() must be awaited first!");
34610 const nativeResponseValue = wasm.TS_Invoice_payee_pub_key(this_arg);
34611 return nativeResponseValue;
34613 // MUST_USE_RES const uint8_t (*Invoice_payment_secret(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
34615 export function Invoice_payment_secret(this_arg: bigint): number {
34616 if(!isWasmInitialized) {
34617 throw new Error("initializeWasm() must be awaited first!");
34619 const nativeResponseValue = wasm.TS_Invoice_payment_secret(this_arg);
34620 return nativeResponseValue;
34622 // MUST_USE_RES struct LDKInvoiceFeatures Invoice_features(const struct LDKInvoice *NONNULL_PTR this_arg);
34624 export function Invoice_features(this_arg: bigint): bigint {
34625 if(!isWasmInitialized) {
34626 throw new Error("initializeWasm() must be awaited first!");
34628 const nativeResponseValue = wasm.TS_Invoice_features(this_arg);
34629 return nativeResponseValue;
34631 // MUST_USE_RES struct LDKPublicKey Invoice_recover_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
34633 export function Invoice_recover_payee_pub_key(this_arg: bigint): number {
34634 if(!isWasmInitialized) {
34635 throw new Error("initializeWasm() must be awaited first!");
34637 const nativeResponseValue = wasm.TS_Invoice_recover_payee_pub_key(this_arg);
34638 return nativeResponseValue;
34640 // MUST_USE_RES uint64_t Invoice_expiry_time(const struct LDKInvoice *NONNULL_PTR this_arg);
34642 export function Invoice_expiry_time(this_arg: bigint): bigint {
34643 if(!isWasmInitialized) {
34644 throw new Error("initializeWasm() must be awaited first!");
34646 const nativeResponseValue = wasm.TS_Invoice_expiry_time(this_arg);
34647 return nativeResponseValue;
34649 // MUST_USE_RES bool Invoice_would_expire(const struct LDKInvoice *NONNULL_PTR this_arg, uint64_t at_time);
34651 export function Invoice_would_expire(this_arg: bigint, at_time: bigint): boolean {
34652 if(!isWasmInitialized) {
34653 throw new Error("initializeWasm() must be awaited first!");
34655 const nativeResponseValue = wasm.TS_Invoice_would_expire(this_arg, at_time);
34656 return nativeResponseValue;
34658 // MUST_USE_RES uint64_t Invoice_min_final_cltv_expiry(const struct LDKInvoice *NONNULL_PTR this_arg);
34660 export function Invoice_min_final_cltv_expiry(this_arg: bigint): bigint {
34661 if(!isWasmInitialized) {
34662 throw new Error("initializeWasm() must be awaited first!");
34664 const nativeResponseValue = wasm.TS_Invoice_min_final_cltv_expiry(this_arg);
34665 return nativeResponseValue;
34667 // MUST_USE_RES struct LDKCVec_PrivateRouteZ Invoice_private_routes(const struct LDKInvoice *NONNULL_PTR this_arg);
34669 export function Invoice_private_routes(this_arg: bigint): number {
34670 if(!isWasmInitialized) {
34671 throw new Error("initializeWasm() must be awaited first!");
34673 const nativeResponseValue = wasm.TS_Invoice_private_routes(this_arg);
34674 return nativeResponseValue;
34676 // MUST_USE_RES struct LDKCVec_RouteHintZ Invoice_route_hints(const struct LDKInvoice *NONNULL_PTR this_arg);
34678 export function Invoice_route_hints(this_arg: bigint): number {
34679 if(!isWasmInitialized) {
34680 throw new Error("initializeWasm() must be awaited first!");
34682 const nativeResponseValue = wasm.TS_Invoice_route_hints(this_arg);
34683 return nativeResponseValue;
34685 // MUST_USE_RES enum LDKCurrency Invoice_currency(const struct LDKInvoice *NONNULL_PTR this_arg);
34687 export function Invoice_currency(this_arg: bigint): Currency {
34688 if(!isWasmInitialized) {
34689 throw new Error("initializeWasm() must be awaited first!");
34691 const nativeResponseValue = wasm.TS_Invoice_currency(this_arg);
34692 return nativeResponseValue;
34694 // MUST_USE_RES struct LDKCOption_u64Z Invoice_amount_milli_satoshis(const struct LDKInvoice *NONNULL_PTR this_arg);
34696 export function Invoice_amount_milli_satoshis(this_arg: bigint): bigint {
34697 if(!isWasmInitialized) {
34698 throw new Error("initializeWasm() must be awaited first!");
34700 const nativeResponseValue = wasm.TS_Invoice_amount_milli_satoshis(this_arg);
34701 return nativeResponseValue;
34703 // MUST_USE_RES struct LDKCResult_DescriptionCreationErrorZ Description_new(struct LDKStr description);
34705 export function Description_new(description: number): bigint {
34706 if(!isWasmInitialized) {
34707 throw new Error("initializeWasm() must be awaited first!");
34709 const nativeResponseValue = wasm.TS_Description_new(description);
34710 return nativeResponseValue;
34712 // MUST_USE_RES struct LDKStr Description_into_inner(struct LDKDescription this_arg);
34714 export function Description_into_inner(this_arg: bigint): number {
34715 if(!isWasmInitialized) {
34716 throw new Error("initializeWasm() must be awaited first!");
34718 const nativeResponseValue = wasm.TS_Description_into_inner(this_arg);
34719 return nativeResponseValue;
34721 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_seconds(uint64_t seconds);
34723 export function ExpiryTime_from_seconds(seconds: bigint): bigint {
34724 if(!isWasmInitialized) {
34725 throw new Error("initializeWasm() must be awaited first!");
34727 const nativeResponseValue = wasm.TS_ExpiryTime_from_seconds(seconds);
34728 return nativeResponseValue;
34730 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_duration(uint64_t duration);
34732 export function ExpiryTime_from_duration(duration: bigint): bigint {
34733 if(!isWasmInitialized) {
34734 throw new Error("initializeWasm() must be awaited first!");
34736 const nativeResponseValue = wasm.TS_ExpiryTime_from_duration(duration);
34737 return nativeResponseValue;
34739 // MUST_USE_RES uint64_t ExpiryTime_as_seconds(const struct LDKExpiryTime *NONNULL_PTR this_arg);
34741 export function ExpiryTime_as_seconds(this_arg: bigint): bigint {
34742 if(!isWasmInitialized) {
34743 throw new Error("initializeWasm() must be awaited first!");
34745 const nativeResponseValue = wasm.TS_ExpiryTime_as_seconds(this_arg);
34746 return nativeResponseValue;
34748 // MUST_USE_RES uint64_t ExpiryTime_as_duration(const struct LDKExpiryTime *NONNULL_PTR this_arg);
34750 export function ExpiryTime_as_duration(this_arg: bigint): bigint {
34751 if(!isWasmInitialized) {
34752 throw new Error("initializeWasm() must be awaited first!");
34754 const nativeResponseValue = wasm.TS_ExpiryTime_as_duration(this_arg);
34755 return nativeResponseValue;
34757 // MUST_USE_RES struct LDKCResult_PrivateRouteCreationErrorZ PrivateRoute_new(struct LDKRouteHint hops);
34759 export function PrivateRoute_new(hops: bigint): bigint {
34760 if(!isWasmInitialized) {
34761 throw new Error("initializeWasm() must be awaited first!");
34763 const nativeResponseValue = wasm.TS_PrivateRoute_new(hops);
34764 return nativeResponseValue;
34766 // MUST_USE_RES struct LDKRouteHint PrivateRoute_into_inner(struct LDKPrivateRoute this_arg);
34768 export function PrivateRoute_into_inner(this_arg: bigint): bigint {
34769 if(!isWasmInitialized) {
34770 throw new Error("initializeWasm() must be awaited first!");
34772 const nativeResponseValue = wasm.TS_PrivateRoute_into_inner(this_arg);
34773 return nativeResponseValue;
34775 // enum LDKCreationError CreationError_clone(const enum LDKCreationError *NONNULL_PTR orig);
34777 export function CreationError_clone(orig: bigint): CreationError {
34778 if(!isWasmInitialized) {
34779 throw new Error("initializeWasm() must be awaited first!");
34781 const nativeResponseValue = wasm.TS_CreationError_clone(orig);
34782 return nativeResponseValue;
34784 // enum LDKCreationError CreationError_description_too_long(void);
34786 export function CreationError_description_too_long(): CreationError {
34787 if(!isWasmInitialized) {
34788 throw new Error("initializeWasm() must be awaited first!");
34790 const nativeResponseValue = wasm.TS_CreationError_description_too_long();
34791 return nativeResponseValue;
34793 // enum LDKCreationError CreationError_route_too_long(void);
34795 export function CreationError_route_too_long(): CreationError {
34796 if(!isWasmInitialized) {
34797 throw new Error("initializeWasm() must be awaited first!");
34799 const nativeResponseValue = wasm.TS_CreationError_route_too_long();
34800 return nativeResponseValue;
34802 // enum LDKCreationError CreationError_timestamp_out_of_bounds(void);
34804 export function CreationError_timestamp_out_of_bounds(): CreationError {
34805 if(!isWasmInitialized) {
34806 throw new Error("initializeWasm() must be awaited first!");
34808 const nativeResponseValue = wasm.TS_CreationError_timestamp_out_of_bounds();
34809 return nativeResponseValue;
34811 // enum LDKCreationError CreationError_invalid_amount(void);
34813 export function CreationError_invalid_amount(): CreationError {
34814 if(!isWasmInitialized) {
34815 throw new Error("initializeWasm() must be awaited first!");
34817 const nativeResponseValue = wasm.TS_CreationError_invalid_amount();
34818 return nativeResponseValue;
34820 // enum LDKCreationError CreationError_missing_route_hints(void);
34822 export function CreationError_missing_route_hints(): CreationError {
34823 if(!isWasmInitialized) {
34824 throw new Error("initializeWasm() must be awaited first!");
34826 const nativeResponseValue = wasm.TS_CreationError_missing_route_hints();
34827 return nativeResponseValue;
34829 // bool CreationError_eq(const enum LDKCreationError *NONNULL_PTR a, const enum LDKCreationError *NONNULL_PTR b);
34831 export function CreationError_eq(a: bigint, b: bigint): boolean {
34832 if(!isWasmInitialized) {
34833 throw new Error("initializeWasm() must be awaited first!");
34835 const nativeResponseValue = wasm.TS_CreationError_eq(a, b);
34836 return nativeResponseValue;
34838 // struct LDKStr CreationError_to_str(const enum LDKCreationError *NONNULL_PTR o);
34840 export function CreationError_to_str(o: bigint): number {
34841 if(!isWasmInitialized) {
34842 throw new Error("initializeWasm() must be awaited first!");
34844 const nativeResponseValue = wasm.TS_CreationError_to_str(o);
34845 return nativeResponseValue;
34847 // enum LDKSemanticError SemanticError_clone(const enum LDKSemanticError *NONNULL_PTR orig);
34849 export function SemanticError_clone(orig: bigint): SemanticError {
34850 if(!isWasmInitialized) {
34851 throw new Error("initializeWasm() must be awaited first!");
34853 const nativeResponseValue = wasm.TS_SemanticError_clone(orig);
34854 return nativeResponseValue;
34856 // enum LDKSemanticError SemanticError_no_payment_hash(void);
34858 export function SemanticError_no_payment_hash(): SemanticError {
34859 if(!isWasmInitialized) {
34860 throw new Error("initializeWasm() must be awaited first!");
34862 const nativeResponseValue = wasm.TS_SemanticError_no_payment_hash();
34863 return nativeResponseValue;
34865 // enum LDKSemanticError SemanticError_multiple_payment_hashes(void);
34867 export function SemanticError_multiple_payment_hashes(): SemanticError {
34868 if(!isWasmInitialized) {
34869 throw new Error("initializeWasm() must be awaited first!");
34871 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_hashes();
34872 return nativeResponseValue;
34874 // enum LDKSemanticError SemanticError_no_description(void);
34876 export function SemanticError_no_description(): SemanticError {
34877 if(!isWasmInitialized) {
34878 throw new Error("initializeWasm() must be awaited first!");
34880 const nativeResponseValue = wasm.TS_SemanticError_no_description();
34881 return nativeResponseValue;
34883 // enum LDKSemanticError SemanticError_multiple_descriptions(void);
34885 export function SemanticError_multiple_descriptions(): SemanticError {
34886 if(!isWasmInitialized) {
34887 throw new Error("initializeWasm() must be awaited first!");
34889 const nativeResponseValue = wasm.TS_SemanticError_multiple_descriptions();
34890 return nativeResponseValue;
34892 // enum LDKSemanticError SemanticError_no_payment_secret(void);
34894 export function SemanticError_no_payment_secret(): SemanticError {
34895 if(!isWasmInitialized) {
34896 throw new Error("initializeWasm() must be awaited first!");
34898 const nativeResponseValue = wasm.TS_SemanticError_no_payment_secret();
34899 return nativeResponseValue;
34901 // enum LDKSemanticError SemanticError_multiple_payment_secrets(void);
34903 export function SemanticError_multiple_payment_secrets(): SemanticError {
34904 if(!isWasmInitialized) {
34905 throw new Error("initializeWasm() must be awaited first!");
34907 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_secrets();
34908 return nativeResponseValue;
34910 // enum LDKSemanticError SemanticError_invalid_features(void);
34912 export function SemanticError_invalid_features(): SemanticError {
34913 if(!isWasmInitialized) {
34914 throw new Error("initializeWasm() must be awaited first!");
34916 const nativeResponseValue = wasm.TS_SemanticError_invalid_features();
34917 return nativeResponseValue;
34919 // enum LDKSemanticError SemanticError_invalid_recovery_id(void);
34921 export function SemanticError_invalid_recovery_id(): SemanticError {
34922 if(!isWasmInitialized) {
34923 throw new Error("initializeWasm() must be awaited first!");
34925 const nativeResponseValue = wasm.TS_SemanticError_invalid_recovery_id();
34926 return nativeResponseValue;
34928 // enum LDKSemanticError SemanticError_invalid_signature(void);
34930 export function SemanticError_invalid_signature(): SemanticError {
34931 if(!isWasmInitialized) {
34932 throw new Error("initializeWasm() must be awaited first!");
34934 const nativeResponseValue = wasm.TS_SemanticError_invalid_signature();
34935 return nativeResponseValue;
34937 // enum LDKSemanticError SemanticError_imprecise_amount(void);
34939 export function SemanticError_imprecise_amount(): SemanticError {
34940 if(!isWasmInitialized) {
34941 throw new Error("initializeWasm() must be awaited first!");
34943 const nativeResponseValue = wasm.TS_SemanticError_imprecise_amount();
34944 return nativeResponseValue;
34946 // bool SemanticError_eq(const enum LDKSemanticError *NONNULL_PTR a, const enum LDKSemanticError *NONNULL_PTR b);
34948 export function SemanticError_eq(a: bigint, b: bigint): boolean {
34949 if(!isWasmInitialized) {
34950 throw new Error("initializeWasm() must be awaited first!");
34952 const nativeResponseValue = wasm.TS_SemanticError_eq(a, b);
34953 return nativeResponseValue;
34955 // struct LDKStr SemanticError_to_str(const enum LDKSemanticError *NONNULL_PTR o);
34957 export function SemanticError_to_str(o: bigint): number {
34958 if(!isWasmInitialized) {
34959 throw new Error("initializeWasm() must be awaited first!");
34961 const nativeResponseValue = wasm.TS_SemanticError_to_str(o);
34962 return nativeResponseValue;
34964 // void SignOrCreationError_free(struct LDKSignOrCreationError this_ptr);
34966 export function SignOrCreationError_free(this_ptr: bigint): void {
34967 if(!isWasmInitialized) {
34968 throw new Error("initializeWasm() must be awaited first!");
34970 const nativeResponseValue = wasm.TS_SignOrCreationError_free(this_ptr);
34971 // debug statements here
34973 // uint64_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg);
34975 export function SignOrCreationError_clone_ptr(arg: bigint): bigint {
34976 if(!isWasmInitialized) {
34977 throw new Error("initializeWasm() must be awaited first!");
34979 const nativeResponseValue = wasm.TS_SignOrCreationError_clone_ptr(arg);
34980 return nativeResponseValue;
34982 // struct LDKSignOrCreationError SignOrCreationError_clone(const struct LDKSignOrCreationError *NONNULL_PTR orig);
34984 export function SignOrCreationError_clone(orig: bigint): bigint {
34985 if(!isWasmInitialized) {
34986 throw new Error("initializeWasm() must be awaited first!");
34988 const nativeResponseValue = wasm.TS_SignOrCreationError_clone(orig);
34989 return nativeResponseValue;
34991 // struct LDKSignOrCreationError SignOrCreationError_sign_error(void);
34993 export function SignOrCreationError_sign_error(): bigint {
34994 if(!isWasmInitialized) {
34995 throw new Error("initializeWasm() must be awaited first!");
34997 const nativeResponseValue = wasm.TS_SignOrCreationError_sign_error();
34998 return nativeResponseValue;
35000 // struct LDKSignOrCreationError SignOrCreationError_creation_error(enum LDKCreationError a);
35002 export function SignOrCreationError_creation_error(a: CreationError): bigint {
35003 if(!isWasmInitialized) {
35004 throw new Error("initializeWasm() must be awaited first!");
35006 const nativeResponseValue = wasm.TS_SignOrCreationError_creation_error(a);
35007 return nativeResponseValue;
35009 // bool SignOrCreationError_eq(const struct LDKSignOrCreationError *NONNULL_PTR a, const struct LDKSignOrCreationError *NONNULL_PTR b);
35011 export function SignOrCreationError_eq(a: bigint, b: bigint): boolean {
35012 if(!isWasmInitialized) {
35013 throw new Error("initializeWasm() must be awaited first!");
35015 const nativeResponseValue = wasm.TS_SignOrCreationError_eq(a, b);
35016 return nativeResponseValue;
35018 // struct LDKStr SignOrCreationError_to_str(const struct LDKSignOrCreationError *NONNULL_PTR o);
35020 export function SignOrCreationError_to_str(o: bigint): number {
35021 if(!isWasmInitialized) {
35022 throw new Error("initializeWasm() must be awaited first!");
35024 const nativeResponseValue = wasm.TS_SignOrCreationError_to_str(o);
35025 return nativeResponseValue;
35027 // void InvoicePayer_free(struct LDKInvoicePayer this_obj);
35029 export function InvoicePayer_free(this_obj: bigint): void {
35030 if(!isWasmInitialized) {
35031 throw new Error("initializeWasm() must be awaited first!");
35033 const nativeResponseValue = wasm.TS_InvoicePayer_free(this_obj);
35034 // debug statements here
35036 // void Payer_free(struct LDKPayer this_ptr);
35038 export function Payer_free(this_ptr: bigint): void {
35039 if(!isWasmInitialized) {
35040 throw new Error("initializeWasm() must be awaited first!");
35042 const nativeResponseValue = wasm.TS_Payer_free(this_ptr);
35043 // debug statements here
35045 // void Router_free(struct LDKRouter this_ptr);
35047 export function Router_free(this_ptr: bigint): void {
35048 if(!isWasmInitialized) {
35049 throw new Error("initializeWasm() must be awaited first!");
35051 const nativeResponseValue = wasm.TS_Router_free(this_ptr);
35052 // debug statements here
35054 // void Retry_free(struct LDKRetry this_ptr);
35056 export function Retry_free(this_ptr: bigint): void {
35057 if(!isWasmInitialized) {
35058 throw new Error("initializeWasm() must be awaited first!");
35060 const nativeResponseValue = wasm.TS_Retry_free(this_ptr);
35061 // debug statements here
35063 // uint64_t Retry_clone_ptr(LDKRetry *NONNULL_PTR arg);
35065 export function Retry_clone_ptr(arg: bigint): bigint {
35066 if(!isWasmInitialized) {
35067 throw new Error("initializeWasm() must be awaited first!");
35069 const nativeResponseValue = wasm.TS_Retry_clone_ptr(arg);
35070 return nativeResponseValue;
35072 // struct LDKRetry Retry_clone(const struct LDKRetry *NONNULL_PTR orig);
35074 export function Retry_clone(orig: bigint): bigint {
35075 if(!isWasmInitialized) {
35076 throw new Error("initializeWasm() must be awaited first!");
35078 const nativeResponseValue = wasm.TS_Retry_clone(orig);
35079 return nativeResponseValue;
35081 // struct LDKRetry Retry_attempts(uintptr_t a);
35083 export function Retry_attempts(a: number): bigint {
35084 if(!isWasmInitialized) {
35085 throw new Error("initializeWasm() must be awaited first!");
35087 const nativeResponseValue = wasm.TS_Retry_attempts(a);
35088 return nativeResponseValue;
35090 // bool Retry_eq(const struct LDKRetry *NONNULL_PTR a, const struct LDKRetry *NONNULL_PTR b);
35092 export function Retry_eq(a: bigint, b: bigint): boolean {
35093 if(!isWasmInitialized) {
35094 throw new Error("initializeWasm() must be awaited first!");
35096 const nativeResponseValue = wasm.TS_Retry_eq(a, b);
35097 return nativeResponseValue;
35099 // uint64_t Retry_hash(const struct LDKRetry *NONNULL_PTR o);
35101 export function Retry_hash(o: bigint): bigint {
35102 if(!isWasmInitialized) {
35103 throw new Error("initializeWasm() must be awaited first!");
35105 const nativeResponseValue = wasm.TS_Retry_hash(o);
35106 return nativeResponseValue;
35108 // void PaymentError_free(struct LDKPaymentError this_ptr);
35110 export function PaymentError_free(this_ptr: bigint): void {
35111 if(!isWasmInitialized) {
35112 throw new Error("initializeWasm() must be awaited first!");
35114 const nativeResponseValue = wasm.TS_PaymentError_free(this_ptr);
35115 // debug statements here
35117 // uint64_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg);
35119 export function PaymentError_clone_ptr(arg: bigint): bigint {
35120 if(!isWasmInitialized) {
35121 throw new Error("initializeWasm() must be awaited first!");
35123 const nativeResponseValue = wasm.TS_PaymentError_clone_ptr(arg);
35124 return nativeResponseValue;
35126 // struct LDKPaymentError PaymentError_clone(const struct LDKPaymentError *NONNULL_PTR orig);
35128 export function PaymentError_clone(orig: bigint): bigint {
35129 if(!isWasmInitialized) {
35130 throw new Error("initializeWasm() must be awaited first!");
35132 const nativeResponseValue = wasm.TS_PaymentError_clone(orig);
35133 return nativeResponseValue;
35135 // struct LDKPaymentError PaymentError_invoice(struct LDKStr a);
35137 export function PaymentError_invoice(a: number): bigint {
35138 if(!isWasmInitialized) {
35139 throw new Error("initializeWasm() must be awaited first!");
35141 const nativeResponseValue = wasm.TS_PaymentError_invoice(a);
35142 return nativeResponseValue;
35144 // struct LDKPaymentError PaymentError_routing(struct LDKLightningError a);
35146 export function PaymentError_routing(a: bigint): bigint {
35147 if(!isWasmInitialized) {
35148 throw new Error("initializeWasm() must be awaited first!");
35150 const nativeResponseValue = wasm.TS_PaymentError_routing(a);
35151 return nativeResponseValue;
35153 // struct LDKPaymentError PaymentError_sending(struct LDKPaymentSendFailure a);
35155 export function PaymentError_sending(a: bigint): bigint {
35156 if(!isWasmInitialized) {
35157 throw new Error("initializeWasm() must be awaited first!");
35159 const nativeResponseValue = wasm.TS_PaymentError_sending(a);
35160 return nativeResponseValue;
35162 // MUST_USE_RES struct LDKInvoicePayer InvoicePayer_new(struct LDKPayer payer, struct LDKRouter router, struct LDKLogger logger, struct LDKEventHandler event_handler, struct LDKRetry retry);
35164 export function InvoicePayer_new(payer: bigint, router: bigint, logger: bigint, event_handler: bigint, retry: bigint): bigint {
35165 if(!isWasmInitialized) {
35166 throw new Error("initializeWasm() must be awaited first!");
35168 const nativeResponseValue = wasm.TS_InvoicePayer_new(payer, router, logger, event_handler, retry);
35169 return nativeResponseValue;
35171 // MUST_USE_RES struct LDKCResult_PaymentIdPaymentErrorZ InvoicePayer_pay_invoice(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const struct LDKInvoice *NONNULL_PTR invoice);
35173 export function InvoicePayer_pay_invoice(this_arg: bigint, invoice: bigint): bigint {
35174 if(!isWasmInitialized) {
35175 throw new Error("initializeWasm() must be awaited first!");
35177 const nativeResponseValue = wasm.TS_InvoicePayer_pay_invoice(this_arg, invoice);
35178 return nativeResponseValue;
35180 // 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);
35182 export function InvoicePayer_pay_zero_value_invoice(this_arg: bigint, invoice: bigint, amount_msats: bigint): bigint {
35183 if(!isWasmInitialized) {
35184 throw new Error("initializeWasm() must be awaited first!");
35186 const nativeResponseValue = wasm.TS_InvoicePayer_pay_zero_value_invoice(this_arg, invoice, amount_msats);
35187 return nativeResponseValue;
35189 // 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);
35191 export function InvoicePayer_pay_pubkey(this_arg: bigint, pubkey: number, payment_preimage: number, amount_msats: bigint, final_cltv_expiry_delta: number): bigint {
35192 if(!isWasmInitialized) {
35193 throw new Error("initializeWasm() must be awaited first!");
35195 const nativeResponseValue = wasm.TS_InvoicePayer_pay_pubkey(this_arg, pubkey, payment_preimage, amount_msats, final_cltv_expiry_delta);
35196 return nativeResponseValue;
35198 // void InvoicePayer_remove_cached_payment(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
35200 export function InvoicePayer_remove_cached_payment(this_arg: bigint, payment_hash: number): void {
35201 if(!isWasmInitialized) {
35202 throw new Error("initializeWasm() must be awaited first!");
35204 const nativeResponseValue = wasm.TS_InvoicePayer_remove_cached_payment(this_arg, payment_hash);
35205 // debug statements here
35207 // struct LDKEventHandler InvoicePayer_as_EventHandler(const struct LDKInvoicePayer *NONNULL_PTR this_arg);
35209 export function InvoicePayer_as_EventHandler(this_arg: bigint): bigint {
35210 if(!isWasmInitialized) {
35211 throw new Error("initializeWasm() must be awaited first!");
35213 const nativeResponseValue = wasm.TS_InvoicePayer_as_EventHandler(this_arg);
35214 return nativeResponseValue;
35216 // void InFlightHtlcs_free(struct LDKInFlightHtlcs this_obj);
35218 export function InFlightHtlcs_free(this_obj: bigint): void {
35219 if(!isWasmInitialized) {
35220 throw new Error("initializeWasm() must be awaited first!");
35222 const nativeResponseValue = wasm.TS_InFlightHtlcs_free(this_obj);
35223 // debug statements here
35225 // MUST_USE_RES struct LDKCOption_u64Z InFlightHtlcs_used_liquidity_msat(const struct LDKInFlightHtlcs *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR source, const struct LDKNodeId *NONNULL_PTR target, uint64_t channel_scid);
35227 export function InFlightHtlcs_used_liquidity_msat(this_arg: bigint, source: bigint, target: bigint, channel_scid: bigint): bigint {
35228 if(!isWasmInitialized) {
35229 throw new Error("initializeWasm() must be awaited first!");
35231 const nativeResponseValue = wasm.TS_InFlightHtlcs_used_liquidity_msat(this_arg, source, target, channel_scid);
35232 return nativeResponseValue;
35234 // struct LDKCVec_u8Z InFlightHtlcs_write(const struct LDKInFlightHtlcs *NONNULL_PTR obj);
35236 export function InFlightHtlcs_write(obj: bigint): number {
35237 if(!isWasmInitialized) {
35238 throw new Error("initializeWasm() must be awaited first!");
35240 const nativeResponseValue = wasm.TS_InFlightHtlcs_write(obj);
35241 return nativeResponseValue;
35243 // struct LDKCResult_InFlightHtlcsDecodeErrorZ InFlightHtlcs_read(struct LDKu8slice ser);
35245 export function InFlightHtlcs_read(ser: number): bigint {
35246 if(!isWasmInitialized) {
35247 throw new Error("initializeWasm() must be awaited first!");
35249 const nativeResponseValue = wasm.TS_InFlightHtlcs_read(ser);
35250 return nativeResponseValue;
35252 // struct LDKCResult_InvoiceSignOrCreationErrorZ create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(const struct LDKChannelManager *NONNULL_PTR channelmanager, struct LDKKeysInterface keys_manager, enum LDKCurrency network, struct LDKCOption_u64Z amt_msat, struct LDKSha256 description_hash, uint64_t duration_since_epoch, uint32_t invoice_expiry_delta_secs);
35254 export function create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(channelmanager: bigint, keys_manager: bigint, network: Currency, amt_msat: bigint, description_hash: bigint, duration_since_epoch: bigint, invoice_expiry_delta_secs: number): bigint {
35255 if(!isWasmInitialized) {
35256 throw new Error("initializeWasm() must be awaited first!");
35258 const nativeResponseValue = wasm.TS_create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(channelmanager, keys_manager, network, amt_msat, description_hash, duration_since_epoch, invoice_expiry_delta_secs);
35259 return nativeResponseValue;
35261 // struct LDKCResult_InvoiceSignOrCreationErrorZ create_invoice_from_channelmanager_and_duration_since_epoch(const struct LDKChannelManager *NONNULL_PTR channelmanager, struct LDKKeysInterface keys_manager, enum LDKCurrency network, struct LDKCOption_u64Z amt_msat, struct LDKStr description, uint64_t duration_since_epoch, uint32_t invoice_expiry_delta_secs);
35263 export function create_invoice_from_channelmanager_and_duration_since_epoch(channelmanager: bigint, keys_manager: bigint, network: Currency, amt_msat: bigint, description: number, duration_since_epoch: bigint, invoice_expiry_delta_secs: number): bigint {
35264 if(!isWasmInitialized) {
35265 throw new Error("initializeWasm() must be awaited first!");
35267 const nativeResponseValue = wasm.TS_create_invoice_from_channelmanager_and_duration_since_epoch(channelmanager, keys_manager, network, amt_msat, description, duration_since_epoch, invoice_expiry_delta_secs);
35268 return nativeResponseValue;
35270 // void DefaultRouter_free(struct LDKDefaultRouter this_obj);
35272 export function DefaultRouter_free(this_obj: bigint): void {
35273 if(!isWasmInitialized) {
35274 throw new Error("initializeWasm() must be awaited first!");
35276 const nativeResponseValue = wasm.TS_DefaultRouter_free(this_obj);
35277 // debug statements here
35279 // MUST_USE_RES struct LDKDefaultRouter DefaultRouter_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger, struct LDKThirtyTwoBytes random_seed_bytes, struct LDKLockableScore scorer);
35281 export function DefaultRouter_new(network_graph: bigint, logger: bigint, random_seed_bytes: number, scorer: bigint): bigint {
35282 if(!isWasmInitialized) {
35283 throw new Error("initializeWasm() must be awaited first!");
35285 const nativeResponseValue = wasm.TS_DefaultRouter_new(network_graph, logger, random_seed_bytes, scorer);
35286 return nativeResponseValue;
35288 // struct LDKRouter DefaultRouter_as_Router(const struct LDKDefaultRouter *NONNULL_PTR this_arg);
35290 export function DefaultRouter_as_Router(this_arg: bigint): bigint {
35291 if(!isWasmInitialized) {
35292 throw new Error("initializeWasm() must be awaited first!");
35294 const nativeResponseValue = wasm.TS_DefaultRouter_as_Router(this_arg);
35295 return nativeResponseValue;
35297 // struct LDKPayer ChannelManager_as_Payer(const struct LDKChannelManager *NONNULL_PTR this_arg);
35299 export function ChannelManager_as_Payer(this_arg: bigint): bigint {
35300 if(!isWasmInitialized) {
35301 throw new Error("initializeWasm() must be awaited first!");
35303 const nativeResponseValue = wasm.TS_ChannelManager_as_Payer(this_arg);
35304 return nativeResponseValue;
35306 // struct LDKCResult_SiPrefixParseErrorZ SiPrefix_from_str(struct LDKStr s);
35308 export function SiPrefix_from_str(s: number): bigint {
35309 if(!isWasmInitialized) {
35310 throw new Error("initializeWasm() must be awaited first!");
35312 const nativeResponseValue = wasm.TS_SiPrefix_from_str(s);
35313 return nativeResponseValue;
35315 // struct LDKCResult_InvoiceParseOrSemanticErrorZ Invoice_from_str(struct LDKStr s);
35317 export function Invoice_from_str(s: number): bigint {
35318 if(!isWasmInitialized) {
35319 throw new Error("initializeWasm() must be awaited first!");
35321 const nativeResponseValue = wasm.TS_Invoice_from_str(s);
35322 return nativeResponseValue;
35324 // struct LDKCResult_SignedRawInvoiceParseErrorZ SignedRawInvoice_from_str(struct LDKStr s);
35326 export function SignedRawInvoice_from_str(s: number): bigint {
35327 if(!isWasmInitialized) {
35328 throw new Error("initializeWasm() must be awaited first!");
35330 const nativeResponseValue = wasm.TS_SignedRawInvoice_from_str(s);
35331 return nativeResponseValue;
35333 // struct LDKStr ParseError_to_str(const struct LDKParseError *NONNULL_PTR o);
35335 export function ParseError_to_str(o: bigint): number {
35336 if(!isWasmInitialized) {
35337 throw new Error("initializeWasm() must be awaited first!");
35339 const nativeResponseValue = wasm.TS_ParseError_to_str(o);
35340 return nativeResponseValue;
35342 // struct LDKStr ParseOrSemanticError_to_str(const struct LDKParseOrSemanticError *NONNULL_PTR o);
35344 export function ParseOrSemanticError_to_str(o: bigint): number {
35345 if(!isWasmInitialized) {
35346 throw new Error("initializeWasm() must be awaited first!");
35348 const nativeResponseValue = wasm.TS_ParseOrSemanticError_to_str(o);
35349 return nativeResponseValue;
35351 // struct LDKStr Invoice_to_str(const struct LDKInvoice *NONNULL_PTR o);
35353 export function Invoice_to_str(o: bigint): number {
35354 if(!isWasmInitialized) {
35355 throw new Error("initializeWasm() must be awaited first!");
35357 const nativeResponseValue = wasm.TS_Invoice_to_str(o);
35358 return nativeResponseValue;
35360 // struct LDKStr SignedRawInvoice_to_str(const struct LDKSignedRawInvoice *NONNULL_PTR o);
35362 export function SignedRawInvoice_to_str(o: bigint): number {
35363 if(!isWasmInitialized) {
35364 throw new Error("initializeWasm() must be awaited first!");
35366 const nativeResponseValue = wasm.TS_SignedRawInvoice_to_str(o);
35367 return nativeResponseValue;
35369 // struct LDKStr Currency_to_str(const enum LDKCurrency *NONNULL_PTR o);
35371 export function Currency_to_str(o: bigint): number {
35372 if(!isWasmInitialized) {
35373 throw new Error("initializeWasm() must be awaited first!");
35375 const nativeResponseValue = wasm.TS_Currency_to_str(o);
35376 return nativeResponseValue;
35378 // struct LDKStr SiPrefix_to_str(const enum LDKSiPrefix *NONNULL_PTR o);
35380 export function SiPrefix_to_str(o: bigint): number {
35381 if(!isWasmInitialized) {
35382 throw new Error("initializeWasm() must be awaited first!");
35384 const nativeResponseValue = wasm.TS_SiPrefix_to_str(o);
35385 return nativeResponseValue;
35389 js_invoke = function(obj_ptr: number, fn_id: number, arg1: bigint|number, arg2: bigint|number, arg3: bigint|number, arg4: bigint|number, arg5: bigint|number, arg6: bigint|number, arg7: bigint|number, arg8: bigint|number, arg9: bigint|number, arg10: bigint|number) {
35390 const weak: WeakRef<object> = js_objs[obj_ptr];
35391 if (weak == null || weak == undefined) {
35392 console.error("Got function call on unknown/free'd JS object!");
35393 throw new Error("Got function call on unknown/free'd JS object!");
35395 const obj: object = weak.deref();
35396 if (obj == null || obj == undefined) {
35397 console.error("Got function call on GC'd JS object!");
35398 throw new Error("Got function call on GC'd JS object!");
35402 case 0: fn = Object.getOwnPropertyDescriptor(obj, "log"); break;
35403 case 1: fn = Object.getOwnPropertyDescriptor(obj, "get_utxo"); break;
35404 case 2: fn = Object.getOwnPropertyDescriptor(obj, "get_per_commitment_point"); break;
35405 case 3: fn = Object.getOwnPropertyDescriptor(obj, "release_commitment_secret"); break;
35406 case 4: fn = Object.getOwnPropertyDescriptor(obj, "validate_holder_commitment"); break;
35407 case 5: fn = Object.getOwnPropertyDescriptor(obj, "channel_keys_id"); break;
35408 case 6: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_commitment"); break;
35409 case 7: fn = Object.getOwnPropertyDescriptor(obj, "validate_counterparty_revocation"); break;
35410 case 8: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_commitment_and_htlcs"); break;
35411 case 9: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_output"); break;
35412 case 10: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_htlc"); break;
35413 case 11: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_htlc_transaction"); break;
35414 case 12: fn = Object.getOwnPropertyDescriptor(obj, "sign_closing_transaction"); break;
35415 case 13: fn = Object.getOwnPropertyDescriptor(obj, "sign_channel_announcement"); break;
35416 case 14: fn = Object.getOwnPropertyDescriptor(obj, "ready_channel"); break;
35417 case 15: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
35418 case 16: fn = Object.getOwnPropertyDescriptor(obj, "watch_channel"); break;
35419 case 17: fn = Object.getOwnPropertyDescriptor(obj, "update_channel"); break;
35420 case 18: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_monitor_events"); break;
35421 case 19: fn = Object.getOwnPropertyDescriptor(obj, "broadcast_transaction"); break;
35422 case 20: fn = Object.getOwnPropertyDescriptor(obj, "get_node_secret"); break;
35423 case 21: fn = Object.getOwnPropertyDescriptor(obj, "ecdh"); break;
35424 case 22: fn = Object.getOwnPropertyDescriptor(obj, "get_destination_script"); break;
35425 case 23: fn = Object.getOwnPropertyDescriptor(obj, "get_shutdown_scriptpubkey"); break;
35426 case 24: fn = Object.getOwnPropertyDescriptor(obj, "get_channel_signer"); break;
35427 case 25: fn = Object.getOwnPropertyDescriptor(obj, "get_secure_random_bytes"); break;
35428 case 26: fn = Object.getOwnPropertyDescriptor(obj, "read_chan_signer"); break;
35429 case 27: fn = Object.getOwnPropertyDescriptor(obj, "sign_invoice"); break;
35430 case 28: fn = Object.getOwnPropertyDescriptor(obj, "get_inbound_payment_key_material"); break;
35431 case 29: fn = Object.getOwnPropertyDescriptor(obj, "get_est_sat_per_1000_weight"); break;
35432 case 30: fn = Object.getOwnPropertyDescriptor(obj, "type_id"); break;
35433 case 31: fn = Object.getOwnPropertyDescriptor(obj, "debug_str"); break;
35434 case 32: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
35435 case 33: fn = Object.getOwnPropertyDescriptor(obj, "register_tx"); break;
35436 case 34: fn = Object.getOwnPropertyDescriptor(obj, "register_output"); break;
35437 case 35: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg_events"); break;
35438 case 36: fn = Object.getOwnPropertyDescriptor(obj, "next_onion_message_for_peer"); break;
35439 case 37: fn = Object.getOwnPropertyDescriptor(obj, "handle_event"); break;
35440 case 38: fn = Object.getOwnPropertyDescriptor(obj, "process_pending_events"); break;
35441 case 39: fn = Object.getOwnPropertyDescriptor(obj, "channel_penalty_msat"); break;
35442 case 40: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_failed"); break;
35443 case 41: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_successful"); break;
35444 case 42: fn = Object.getOwnPropertyDescriptor(obj, "probe_failed"); break;
35445 case 43: fn = Object.getOwnPropertyDescriptor(obj, "probe_successful"); break;
35446 case 44: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
35447 case 45: fn = Object.getOwnPropertyDescriptor(obj, "lock"); break;
35448 case 46: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
35449 case 47: fn = Object.getOwnPropertyDescriptor(obj, "persist_manager"); break;
35450 case 48: fn = Object.getOwnPropertyDescriptor(obj, "persist_graph"); break;
35451 case 49: fn = Object.getOwnPropertyDescriptor(obj, "persist_scorer"); break;
35452 case 50: fn = Object.getOwnPropertyDescriptor(obj, "call"); break;
35453 case 51: fn = Object.getOwnPropertyDescriptor(obj, "filtered_block_connected"); break;
35454 case 52: fn = Object.getOwnPropertyDescriptor(obj, "block_connected"); break;
35455 case 53: fn = Object.getOwnPropertyDescriptor(obj, "block_disconnected"); break;
35456 case 54: fn = Object.getOwnPropertyDescriptor(obj, "transactions_confirmed"); break;
35457 case 55: fn = Object.getOwnPropertyDescriptor(obj, "transaction_unconfirmed"); break;
35458 case 56: fn = Object.getOwnPropertyDescriptor(obj, "best_block_updated"); break;
35459 case 57: fn = Object.getOwnPropertyDescriptor(obj, "get_relevant_txids"); break;
35460 case 58: fn = Object.getOwnPropertyDescriptor(obj, "persist_new_channel"); break;
35461 case 59: fn = Object.getOwnPropertyDescriptor(obj, "update_persisted_channel"); break;
35462 case 60: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel"); break;
35463 case 61: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel"); break;
35464 case 62: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_created"); break;
35465 case 63: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_signed"); break;
35466 case 64: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_ready"); break;
35467 case 65: fn = Object.getOwnPropertyDescriptor(obj, "handle_shutdown"); break;
35468 case 66: fn = Object.getOwnPropertyDescriptor(obj, "handle_closing_signed"); break;
35469 case 67: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_add_htlc"); break;
35470 case 68: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fulfill_htlc"); break;
35471 case 69: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_htlc"); break;
35472 case 70: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_malformed_htlc"); break;
35473 case 71: fn = Object.getOwnPropertyDescriptor(obj, "handle_commitment_signed"); break;
35474 case 72: fn = Object.getOwnPropertyDescriptor(obj, "handle_revoke_and_ack"); break;
35475 case 73: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fee"); break;
35476 case 74: fn = Object.getOwnPropertyDescriptor(obj, "handle_announcement_signatures"); break;
35477 case 75: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
35478 case 76: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
35479 case 77: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_reestablish"); break;
35480 case 78: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
35481 case 79: fn = Object.getOwnPropertyDescriptor(obj, "handle_error"); break;
35482 case 80: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
35483 case 81: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
35484 case 82: fn = Object.getOwnPropertyDescriptor(obj, "handle_node_announcement"); break;
35485 case 83: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_announcement"); break;
35486 case 84: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
35487 case 85: fn = Object.getOwnPropertyDescriptor(obj, "get_next_channel_announcement"); break;
35488 case 86: fn = Object.getOwnPropertyDescriptor(obj, "get_next_node_announcement"); break;
35489 case 87: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
35490 case 88: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_channel_range"); break;
35491 case 89: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_short_channel_ids_end"); break;
35492 case 90: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_channel_range"); break;
35493 case 91: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_short_channel_ids"); break;
35494 case 92: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
35495 case 93: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
35496 case 94: fn = Object.getOwnPropertyDescriptor(obj, "handle_onion_message"); break;
35497 case 95: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
35498 case 96: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
35499 case 97: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
35500 case 98: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
35501 case 99: fn = Object.getOwnPropertyDescriptor(obj, "read"); break;
35502 case 100: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
35503 case 101: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg"); break;
35504 case 102: fn = Object.getOwnPropertyDescriptor(obj, "send_data"); break;
35505 case 103: fn = Object.getOwnPropertyDescriptor(obj, "disconnect_socket"); break;
35506 case 104: fn = Object.getOwnPropertyDescriptor(obj, "eq"); break;
35507 case 105: fn = Object.getOwnPropertyDescriptor(obj, "hash"); break;
35508 case 106: fn = Object.getOwnPropertyDescriptor(obj, "node_id"); break;
35509 case 107: fn = Object.getOwnPropertyDescriptor(obj, "first_hops"); break;
35510 case 108: fn = Object.getOwnPropertyDescriptor(obj, "send_payment"); break;
35511 case 109: fn = Object.getOwnPropertyDescriptor(obj, "send_spontaneous_payment"); break;
35512 case 110: fn = Object.getOwnPropertyDescriptor(obj, "retry_payment"); break;
35513 case 111: fn = Object.getOwnPropertyDescriptor(obj, "abandon_payment"); break;
35514 case 112: fn = Object.getOwnPropertyDescriptor(obj, "find_route"); break;
35515 case 113: fn = Object.getOwnPropertyDescriptor(obj, "notify_payment_path_failed"); break;
35516 case 114: fn = Object.getOwnPropertyDescriptor(obj, "notify_payment_path_successful"); break;
35517 case 115: fn = Object.getOwnPropertyDescriptor(obj, "notify_payment_probe_successful"); break;
35518 case 116: fn = Object.getOwnPropertyDescriptor(obj, "notify_payment_probe_failed"); break;
35520 console.error("Got unknown function call from C!");
35521 throw new Error("Got unknown function call from C!");
35523 if (fn == null || fn == undefined) {
35524 console.error("Got function call on incorrect JS object!");
35525 throw new Error("Got function call on incorrect JS object!");
35527 const ret = fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
35528 if (ret === undefined || ret === null) return BigInt(0);
35529 return BigInt(ret);