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|null): number {
133 if (inputArray == null) return 0;
134 const cArrayPointer = wasm.TS_malloc(inputArray.length + 8);
135 const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
136 arrayLengthView[0] = BigInt(inputArray.length);
137 const arrayMemoryView = new Uint8Array(wasm.memory.buffer, cArrayPointer + 8, inputArray.length);
138 arrayMemoryView.set(inputArray);
139 return cArrayPointer;
142 export function encodeUint32Array (inputArray: Uint32Array|Array<number>|null): number {
143 if (inputArray == null) return 0;
144 const cArrayPointer = wasm.TS_malloc((inputArray.length + 2) * 4);
145 const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
146 arrayLengthView[0] = BigInt(inputArray.length);
147 const arrayMemoryView = new Uint32Array(wasm.memory.buffer, cArrayPointer + 8, inputArray.length);
148 arrayMemoryView.set(inputArray);
149 return cArrayPointer;
152 export function encodeUint64Array (inputArray: BigUint64Array|Array<bigint>|null): number {
153 if (inputArray == null) return 0;
154 const cArrayPointer = wasm.TS_malloc((inputArray.length + 1) * 8);
155 const arrayMemoryView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, inputArray.length + 1);
156 arrayMemoryView[0] = BigInt(inputArray.length);
157 arrayMemoryView.set(inputArray, 1);
158 return cArrayPointer;
162 export function check_arr_len(arr: Uint8Array|null, len: number): Uint8Array|null {
163 if (arr !== null && arr.length != len) { throw new Error("Expected array of length " + len + " got " + arr.length); }
168 export function getArrayLength(arrayPointer: number): number {
169 const arraySizeViewer = new BigUint64Array(wasm.memory.buffer, arrayPointer, 1);
170 const len = arraySizeViewer[0]!;
171 if (len >= (2n ** 32n)) throw new Error("Bogus Array Size");
172 return Number(len % (2n ** 32n));
175 export function decodeUint8Array (arrayPointer: number, free = true): Uint8Array {
176 const arraySize = getArrayLength(arrayPointer);
177 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 8, arraySize);
178 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
179 // will free the underlying memory when it becomes unreachable instead of copying here.
180 // Note that doing so may have edge-case interactions with memory resizing (invalidating the buffer).
181 const actualArray = actualArrayViewer.slice(0, arraySize);
183 wasm.TS_free(arrayPointer);
187 const decodeUint32Array = (arrayPointer: number, free = true) => {
188 const arraySize = getArrayLength(arrayPointer);
189 const actualArrayViewer = new Uint32Array(
190 wasm.memory.buffer, // value
191 arrayPointer + 8, // offset (ignoring length bytes)
192 arraySize // uint32 count
194 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
195 // will free the underlying memory when it becomes unreachable instead of copying here.
196 const actualArray = actualArrayViewer.slice(0, arraySize);
198 wasm.TS_free(arrayPointer);
203 export function decodeUint64Array (arrayPointer: number, free = true): bigint[] {
204 const arraySize = getArrayLength(arrayPointer);
205 const actualArrayViewer = new BigUint64Array(
206 wasm.memory.buffer, // value
207 arrayPointer + 8, // offset (ignoring length bytes)
208 arraySize // uint32 count
210 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
211 // will free the underlying memory when it becomes unreachable instead of copying here.
212 const actualArray = new Array(arraySize);
213 for (var i = 0; i < arraySize; i++) actualArray[i] = actualArrayViewer[i];
215 wasm.TS_free(arrayPointer);
220 export function freeWasmMemory(pointer: number) { wasm.TS_free(pointer); }
223 export function getU64ArrayElem(arrayPointer: number, idx: number): bigint {
224 const actualArrayViewer = new BigUint64Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
225 return actualArrayViewer[idx]!;
229 export function getU32ArrayElem(arrayPointer: number, idx: number): number {
230 const actualArrayViewer = new Uint32Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
231 return actualArrayViewer[idx]!;
235 export function getU8ArrayElem(arrayPointer: number, idx: number): number {
236 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
237 return actualArrayViewer[idx]!;
242 export function encodeString(str: string): number {
243 const charArray = new TextEncoder().encode(str);
244 return encodeUint8Array(charArray);
248 export function decodeString(stringPointer: number, free = true): string {
249 const arraySize = getArrayLength(stringPointer);
250 const memoryView = new Uint8Array(wasm.memory.buffer, stringPointer + 8, arraySize);
251 const result = new TextDecoder("utf-8").decode(memoryView);
254 wasm.TS_free(stringPointer);
260 /* @internal */ export function getRemainingAllocationCount(): number { return 0; }
261 /* @internal */ export function debugPrintRemainingAllocs() { }
264 * An error when accessing the chain via [`Access`].
266 export enum AccessError {
268 * The requested chain is unknown.
270 LDKAccessError_UnknownChain,
272 * The requested transaction doesn't exist or hasn't confirmed.
274 LDKAccessError_UnknownTx,
279 * An enum which can either contain a or not
281 export enum COption_NoneZ {
283 * When we're in this state, this COption_NoneZ contains a
285 LDKCOption_NoneZ_Some,
287 * When we're in this state, this COption_NoneZ contains nothing
289 LDKCOption_NoneZ_None,
294 * An enum representing the status of a channel monitor update persistence.
296 export enum ChannelMonitorUpdateStatus {
298 * The update has been durably persisted and all copies of the relevant [`ChannelMonitor`]
301 This includes performing any `fsync()` calls required to ensure the update is guaranteed to
302 be available on restart even if the application crashes.
304 LDKChannelMonitorUpdateStatus_Completed,
306 * Used to indicate a temporary failure (eg connection to a watchtower or remote backup of
307 our state failed, but is expected to succeed at some point in the future).
309 Such a failure will \"freeze\" a channel, preventing us from revoking old states or
310 submitting new commitment transactions to the counterparty. Once the update(s) which failed
311 have been successfully applied, a [`MonitorEvent::Completed`] can be used to restore the
312 channel to an operational state.
314 Note that a given [`ChannelManager`] will *never* re-generate a [`ChannelMonitorUpdate`].
315 If you return this error you must ensure that it is written to disk safely before writing
316 the latest [`ChannelManager`] state, or you should return [`PermanentFailure`] instead.
318 Even when a channel has been \"frozen\", updates to the [`ChannelMonitor`] can continue to
319 occur (e.g. if an inbound HTLC which we forwarded was claimed upstream, resulting in us
320 attempting to claim it on this channel) and those updates must still be persisted.
322 No updates to the channel will be made which could invalidate other [`ChannelMonitor`]s
323 until a [`MonitorEvent::Completed`] is provided, even if you return no error on a later
324 monitor update for the same channel.
326 For deployments where a copy of ChannelMonitors and other local state are backed up in a
327 remote location (with local copies persisted immediately), it is anticipated that all
328 updates will return [`InProgress`] until the remote copies could be updated.
330 [`PermanentFailure`]: ChannelMonitorUpdateStatus::PermanentFailure
331 [`InProgress`]: ChannelMonitorUpdateStatus::InProgress
332 [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
334 LDKChannelMonitorUpdateStatus_InProgress,
336 * Used to indicate no further channel monitor updates will be allowed (likely a disk failure
337 or a remote copy of this [`ChannelMonitor`] is no longer reachable and thus not updatable).
339 When this is returned, [`ChannelManager`] will force-close the channel but *not* broadcast
340 our current commitment transaction. This avoids a dangerous case where a local disk failure
341 (e.g. the Linux-default remounting of the disk as read-only) causes [`PermanentFailure`]s
342 for all monitor updates. If we were to broadcast our latest commitment transaction and then
343 restart, we could end up reading a previous [`ChannelMonitor`] and [`ChannelManager`],
344 revoking our now-broadcasted state before seeing it confirm and losing all our funds.
346 Note that this is somewhat of a tradeoff - if the disk is really gone and we may have lost
347 the data permanently, we really should broadcast immediately. If the data can be recovered
348 with manual intervention, we'd rather close the channel, rejecting future updates to it,
349 and broadcast the latest state only if we have HTLCs to claim which are timing out (which
350 we do as long as blocks are connected).
352 In order to broadcast the latest local commitment transaction, you'll need to call
353 [`ChannelMonitor::get_latest_holder_commitment_txn`] and broadcast the resulting
354 transactions once you've safely ensured no further channel updates can be generated by your
357 Note that at least one final [`ChannelMonitorUpdate`] may still be provided, which must
358 still be processed by a running [`ChannelMonitor`]. This final update will mark the
359 [`ChannelMonitor`] as finalized, ensuring no further updates (e.g. revocation of the latest
360 commitment transaction) are allowed.
362 Note that even if you return a [`PermanentFailure`] due to unavailability of secondary
363 [`ChannelMonitor`] copies, you should still make an attempt to store the update where
364 possible to ensure you can claim HTLC outputs on the latest commitment transaction
367 In case of distributed watchtowers deployment, the new version must be written to disk, as
368 state may have been stored but rejected due to a block forcing a commitment broadcast. This
369 storage is used to claim outputs of rejected state confirmed onchain by another watchtower,
370 lagging behind on block processing.
372 [`PermanentFailure`]: ChannelMonitorUpdateStatus::PermanentFailure
373 [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
375 LDKChannelMonitorUpdateStatus_PermanentFailure,
380 * An enum that represents the speed at which we want a transaction to confirm used for feerate
383 export enum ConfirmationTarget {
385 * We are happy with this transaction confirming slowly when feerate drops some.
387 LDKConfirmationTarget_Background,
389 * We'd like this transaction to confirm without major delay, but 12-18 blocks is fine.
391 LDKConfirmationTarget_Normal,
393 * We'd like this transaction to confirm in the next few blocks.
395 LDKConfirmationTarget_HighPriority,
400 * Errors that may occur when constructing a new `RawInvoice` or `Invoice`
402 export enum CreationError {
404 * The supplied description string was longer than 639 __bytes__ (see [`Description::new(...)`](./struct.Description.html#method.new))
406 LDKCreationError_DescriptionTooLong,
408 * The specified route has too many hops and can't be encoded
410 LDKCreationError_RouteTooLong,
412 * The Unix timestamp of the supplied date is less than zero or greater than 35-bits
414 LDKCreationError_TimestampOutOfBounds,
416 * The supplied millisatoshi amount was greater than the total bitcoin supply.
418 LDKCreationError_InvalidAmount,
420 * Route hints were required for this invoice and were missing. Applies to
423 [phantom invoices]: crate::utils::create_phantom_invoice
425 LDKCreationError_MissingRouteHints,
430 * Enum representing the crypto currencies (or networks) supported by this library
432 export enum Currency {
440 LDKCurrency_BitcoinTestnet,
457 * Represents an IO Error. Note that some information is lost in the conversion from Rust.
459 export enum IOError {
461 LDKIOError_PermissionDenied,
462 LDKIOError_ConnectionRefused,
463 LDKIOError_ConnectionReset,
464 LDKIOError_ConnectionAborted,
465 LDKIOError_NotConnected,
466 LDKIOError_AddrInUse,
467 LDKIOError_AddrNotAvailable,
468 LDKIOError_BrokenPipe,
469 LDKIOError_AlreadyExists,
470 LDKIOError_WouldBlock,
471 LDKIOError_InvalidInput,
472 LDKIOError_InvalidData,
474 LDKIOError_WriteZero,
475 LDKIOError_Interrupted,
477 LDKIOError_UnexpectedEof,
482 * An enum representing the available verbosity levels of the logger.
486 * Designates extremely verbose information, including gossip-induced messages
490 * Designates very low priority, often extremely verbose, information
494 * Designates lower priority information
498 * Designates useful information
502 * Designates hazardous situations
506 * Designates very serious errors
513 * An enum representing the possible Bitcoin or test networks which we can run on
515 export enum Network {
517 * The main Bitcoin blockchain.
521 * The testnet3 blockchain.
525 * A local test blockchain.
529 * A blockchain on which blocks are signed instead of mined.
536 * Specifies the recipient of an invoice, to indicate to [`KeysInterface::sign_invoice`] what node
537 * secret key should be used to sign the invoice.
539 export enum Recipient {
541 * The invoice should be signed with the local node secret key.
545 * The invoice should be signed with the phantom node secret key. This secret key must be the
546 same for all nodes participating in the [phantom node payment].
548 [phantom node payment]: PhantomKeysManager
550 LDKRecipient_PhantomNode,
555 * Represents an error returned from libsecp256k1 during validation of some secp256k1 data
557 export enum Secp256k1Error {
559 * Signature failed verification
561 LDKSecp256k1Error_IncorrectSignature,
563 * Badly sized message ("messages" are actually fixed-sized digests; see the MESSAGE_SIZE constant)
565 LDKSecp256k1Error_InvalidMessage,
569 LDKSecp256k1Error_InvalidPublicKey,
573 LDKSecp256k1Error_InvalidSignature,
577 LDKSecp256k1Error_InvalidSecretKey,
581 LDKSecp256k1Error_InvalidSharedSecret,
585 LDKSecp256k1Error_InvalidRecoveryId,
587 * Invalid tweak for add_assign or mul_assign
589 LDKSecp256k1Error_InvalidTweak,
591 * Didn't pass enough memory to context creation with preallocated memory
593 LDKSecp256k1Error_NotEnoughMemory,
595 * Bad set of public keys.
597 LDKSecp256k1Error_InvalidPublicKeySum,
599 * The only valid parity values are 0 or 1.
601 LDKSecp256k1Error_InvalidParityValue,
606 * Errors that may occur when converting a `RawInvoice` to an `Invoice`. They relate to the
607 * requirements sections in BOLT #11
609 export enum SemanticError {
611 * The invoice is missing the mandatory payment hash
613 LDKSemanticError_NoPaymentHash,
615 * The invoice has multiple payment hashes which isn't allowed
617 LDKSemanticError_MultiplePaymentHashes,
619 * No description or description hash are part of the invoice
621 LDKSemanticError_NoDescription,
623 * The invoice contains multiple descriptions and/or description hashes which isn't allowed
625 LDKSemanticError_MultipleDescriptions,
627 * The invoice is missing the mandatory payment secret, which all modern lightning nodes
630 LDKSemanticError_NoPaymentSecret,
632 * The invoice contains multiple payment secrets
634 LDKSemanticError_MultiplePaymentSecrets,
636 * The invoice's features are invalid
638 LDKSemanticError_InvalidFeatures,
640 * The recovery id doesn't fit the signature/pub key
642 LDKSemanticError_InvalidRecoveryId,
644 * The invoice's signature is invalid
646 LDKSemanticError_InvalidSignature,
648 * The invoice's amount was not a whole number of millisatoshis
650 LDKSemanticError_ImpreciseAmount,
655 * SI prefixes for the human readable part
657 export enum SiPrefix {
676 // struct LDKThirtyTwoBytes BigEndianScalar_get_bytes (struct LDKBigEndianScalar* thing)
678 export function BigEndianScalar_get_bytes(thing: bigint): number {
679 if(!isWasmInitialized) {
680 throw new Error("initializeWasm() must be awaited first!");
682 const nativeResponseValue = wasm.TS_BigEndianScalar_get_bytes(thing);
683 return nativeResponseValue;
685 // static void BigEndianScalar_free (struct LDKBigEndianScalar thing)
687 export function BigEndianScalar_free(thing: bigint): void {
688 if(!isWasmInitialized) {
689 throw new Error("initializeWasm() must be awaited first!");
691 const nativeResponseValue = wasm.TS_BigEndianScalar_free(thing);
692 // debug statements here
695 export class LDKBech32Error {
696 protected constructor() {}
699 export function LDKBech32Error_ty_from_ptr(ptr: bigint): number {
700 if(!isWasmInitialized) {
701 throw new Error("initializeWasm() must be awaited first!");
703 const nativeResponseValue = wasm.TS_LDKBech32Error_ty_from_ptr(ptr);
704 return nativeResponseValue;
707 export function LDKBech32Error_InvalidChar_get_invalid_char(ptr: bigint): number {
708 if(!isWasmInitialized) {
709 throw new Error("initializeWasm() must be awaited first!");
711 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidChar_get_invalid_char(ptr);
712 return nativeResponseValue;
715 export function LDKBech32Error_InvalidData_get_invalid_data(ptr: bigint): number {
716 if(!isWasmInitialized) {
717 throw new Error("initializeWasm() must be awaited first!");
719 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidData_get_invalid_data(ptr);
720 return nativeResponseValue;
722 // struct LDKCVec_u8Z TxOut_get_script_pubkey (struct LDKTxOut* thing)
724 export function TxOut_get_script_pubkey(thing: bigint): number {
725 if(!isWasmInitialized) {
726 throw new Error("initializeWasm() must be awaited first!");
728 const nativeResponseValue = wasm.TS_TxOut_get_script_pubkey(thing);
729 return nativeResponseValue;
731 // uint64_t TxOut_get_value (struct LDKTxOut* thing)
733 export function TxOut_get_value(thing: bigint): bigint {
734 if(!isWasmInitialized) {
735 throw new Error("initializeWasm() must be awaited first!");
737 const nativeResponseValue = wasm.TS_TxOut_get_value(thing);
738 return nativeResponseValue;
740 // struct LDKBlindedRoute CResult_BlindedRouteNoneZ_get_ok(LDKCResult_BlindedRouteNoneZ *NONNULL_PTR owner);
742 export function CResult_BlindedRouteNoneZ_get_ok(owner: bigint): bigint {
743 if(!isWasmInitialized) {
744 throw new Error("initializeWasm() must be awaited first!");
746 const nativeResponseValue = wasm.TS_CResult_BlindedRouteNoneZ_get_ok(owner);
747 return nativeResponseValue;
749 // void CResult_BlindedRouteNoneZ_get_err(LDKCResult_BlindedRouteNoneZ *NONNULL_PTR owner);
751 export function CResult_BlindedRouteNoneZ_get_err(owner: bigint): void {
752 if(!isWasmInitialized) {
753 throw new Error("initializeWasm() must be awaited first!");
755 const nativeResponseValue = wasm.TS_CResult_BlindedRouteNoneZ_get_err(owner);
756 // debug statements here
759 export class LDKDecodeError {
760 protected constructor() {}
763 export function LDKDecodeError_ty_from_ptr(ptr: bigint): number {
764 if(!isWasmInitialized) {
765 throw new Error("initializeWasm() must be awaited first!");
767 const nativeResponseValue = wasm.TS_LDKDecodeError_ty_from_ptr(ptr);
768 return nativeResponseValue;
771 export function LDKDecodeError_Io_get_io(ptr: bigint): IOError {
772 if(!isWasmInitialized) {
773 throw new Error("initializeWasm() must be awaited first!");
775 const nativeResponseValue = wasm.TS_LDKDecodeError_Io_get_io(ptr);
776 return nativeResponseValue;
778 // struct LDKBlindedRoute CResult_BlindedRouteDecodeErrorZ_get_ok(LDKCResult_BlindedRouteDecodeErrorZ *NONNULL_PTR owner);
780 export function CResult_BlindedRouteDecodeErrorZ_get_ok(owner: bigint): bigint {
781 if(!isWasmInitialized) {
782 throw new Error("initializeWasm() must be awaited first!");
784 const nativeResponseValue = wasm.TS_CResult_BlindedRouteDecodeErrorZ_get_ok(owner);
785 return nativeResponseValue;
787 // struct LDKDecodeError CResult_BlindedRouteDecodeErrorZ_get_err(LDKCResult_BlindedRouteDecodeErrorZ *NONNULL_PTR owner);
789 export function CResult_BlindedRouteDecodeErrorZ_get_err(owner: bigint): bigint {
790 if(!isWasmInitialized) {
791 throw new Error("initializeWasm() must be awaited first!");
793 const nativeResponseValue = wasm.TS_CResult_BlindedRouteDecodeErrorZ_get_err(owner);
794 return nativeResponseValue;
796 // struct LDKBlindedHop CResult_BlindedHopDecodeErrorZ_get_ok(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner);
798 export function CResult_BlindedHopDecodeErrorZ_get_ok(owner: bigint): bigint {
799 if(!isWasmInitialized) {
800 throw new Error("initializeWasm() must be awaited first!");
802 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_get_ok(owner);
803 return nativeResponseValue;
805 // struct LDKDecodeError CResult_BlindedHopDecodeErrorZ_get_err(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner);
807 export function CResult_BlindedHopDecodeErrorZ_get_err(owner: bigint): bigint {
808 if(!isWasmInitialized) {
809 throw new Error("initializeWasm() must be awaited first!");
811 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_get_err(owner);
812 return nativeResponseValue;
814 // void CResult_NoneNoneZ_get_ok(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
816 export function CResult_NoneNoneZ_get_ok(owner: bigint): void {
817 if(!isWasmInitialized) {
818 throw new Error("initializeWasm() must be awaited first!");
820 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_ok(owner);
821 // debug statements here
823 // void CResult_NoneNoneZ_get_err(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
825 export function CResult_NoneNoneZ_get_err(owner: bigint): void {
826 if(!isWasmInitialized) {
827 throw new Error("initializeWasm() must be awaited first!");
829 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_err(owner);
830 // debug statements here
832 // struct LDKCounterpartyCommitmentSecrets CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
834 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner: bigint): bigint {
835 if(!isWasmInitialized) {
836 throw new Error("initializeWasm() must be awaited first!");
838 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner);
839 return nativeResponseValue;
841 // struct LDKDecodeError CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
843 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner: bigint): bigint {
844 if(!isWasmInitialized) {
845 throw new Error("initializeWasm() must be awaited first!");
847 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner);
848 return nativeResponseValue;
850 // struct LDKSecretKey CResult_SecretKeyErrorZ_get_ok(LDKCResult_SecretKeyErrorZ *NONNULL_PTR owner);
852 export function CResult_SecretKeyErrorZ_get_ok(owner: bigint): number {
853 if(!isWasmInitialized) {
854 throw new Error("initializeWasm() must be awaited first!");
856 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_get_ok(owner);
857 return nativeResponseValue;
859 // enum LDKSecp256k1Error CResult_SecretKeyErrorZ_get_err(LDKCResult_SecretKeyErrorZ *NONNULL_PTR owner);
861 export function CResult_SecretKeyErrorZ_get_err(owner: bigint): Secp256k1Error {
862 if(!isWasmInitialized) {
863 throw new Error("initializeWasm() must be awaited first!");
865 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_get_err(owner);
866 return nativeResponseValue;
868 // struct LDKPublicKey CResult_PublicKeyErrorZ_get_ok(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
870 export function CResult_PublicKeyErrorZ_get_ok(owner: bigint): number {
871 if(!isWasmInitialized) {
872 throw new Error("initializeWasm() must be awaited first!");
874 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_ok(owner);
875 return nativeResponseValue;
877 // enum LDKSecp256k1Error CResult_PublicKeyErrorZ_get_err(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
879 export function CResult_PublicKeyErrorZ_get_err(owner: bigint): Secp256k1Error {
880 if(!isWasmInitialized) {
881 throw new Error("initializeWasm() must be awaited first!");
883 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_err(owner);
884 return nativeResponseValue;
886 // struct LDKTxCreationKeys CResult_TxCreationKeysDecodeErrorZ_get_ok(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
888 export function CResult_TxCreationKeysDecodeErrorZ_get_ok(owner: bigint): bigint {
889 if(!isWasmInitialized) {
890 throw new Error("initializeWasm() must be awaited first!");
892 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_ok(owner);
893 return nativeResponseValue;
895 // struct LDKDecodeError CResult_TxCreationKeysDecodeErrorZ_get_err(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
897 export function CResult_TxCreationKeysDecodeErrorZ_get_err(owner: bigint): bigint {
898 if(!isWasmInitialized) {
899 throw new Error("initializeWasm() must be awaited first!");
901 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_err(owner);
902 return nativeResponseValue;
904 // struct LDKChannelPublicKeys CResult_ChannelPublicKeysDecodeErrorZ_get_ok(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
906 export function CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner: bigint): bigint {
907 if(!isWasmInitialized) {
908 throw new Error("initializeWasm() must be awaited first!");
910 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner);
911 return nativeResponseValue;
913 // struct LDKDecodeError CResult_ChannelPublicKeysDecodeErrorZ_get_err(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
915 export function CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner: bigint): bigint {
916 if(!isWasmInitialized) {
917 throw new Error("initializeWasm() must be awaited first!");
919 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner);
920 return nativeResponseValue;
922 // struct LDKTxCreationKeys CResult_TxCreationKeysErrorZ_get_ok(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR owner);
924 export function CResult_TxCreationKeysErrorZ_get_ok(owner: bigint): bigint {
925 if(!isWasmInitialized) {
926 throw new Error("initializeWasm() must be awaited first!");
928 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_get_ok(owner);
929 return nativeResponseValue;
931 // enum LDKSecp256k1Error CResult_TxCreationKeysErrorZ_get_err(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR owner);
933 export function CResult_TxCreationKeysErrorZ_get_err(owner: bigint): Secp256k1Error {
934 if(!isWasmInitialized) {
935 throw new Error("initializeWasm() must be awaited first!");
937 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_get_err(owner);
938 return nativeResponseValue;
941 export class LDKCOption_u32Z {
942 protected constructor() {}
945 export function LDKCOption_u32Z_ty_from_ptr(ptr: bigint): number {
946 if(!isWasmInitialized) {
947 throw new Error("initializeWasm() must be awaited first!");
949 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_ty_from_ptr(ptr);
950 return nativeResponseValue;
953 export function LDKCOption_u32Z_Some_get_some(ptr: bigint): number {
954 if(!isWasmInitialized) {
955 throw new Error("initializeWasm() must be awaited first!");
957 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_Some_get_some(ptr);
958 return nativeResponseValue;
960 // struct LDKHTLCOutputInCommitment CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
962 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner: bigint): bigint {
963 if(!isWasmInitialized) {
964 throw new Error("initializeWasm() must be awaited first!");
966 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner);
967 return nativeResponseValue;
969 // struct LDKDecodeError CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
971 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner: bigint): bigint {
972 if(!isWasmInitialized) {
973 throw new Error("initializeWasm() must be awaited first!");
975 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner);
976 return nativeResponseValue;
978 // struct LDKCounterpartyChannelTransactionParameters CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
980 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
981 if(!isWasmInitialized) {
982 throw new Error("initializeWasm() must be awaited first!");
984 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner);
985 return nativeResponseValue;
987 // struct LDKDecodeError CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
989 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner: bigint): bigint {
990 if(!isWasmInitialized) {
991 throw new Error("initializeWasm() must be awaited first!");
993 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner);
994 return nativeResponseValue;
996 // struct LDKChannelTransactionParameters CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
998 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
999 if(!isWasmInitialized) {
1000 throw new Error("initializeWasm() must be awaited first!");
1002 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner);
1003 return nativeResponseValue;
1005 // struct LDKDecodeError CResult_ChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
1007 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner: bigint): bigint {
1008 if(!isWasmInitialized) {
1009 throw new Error("initializeWasm() must be awaited first!");
1011 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner);
1012 return nativeResponseValue;
1014 // struct LDKHolderCommitmentTransaction CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
1016 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
1017 if(!isWasmInitialized) {
1018 throw new Error("initializeWasm() must be awaited first!");
1020 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner);
1021 return nativeResponseValue;
1023 // struct LDKDecodeError CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
1025 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
1026 if(!isWasmInitialized) {
1027 throw new Error("initializeWasm() must be awaited first!");
1029 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner);
1030 return nativeResponseValue;
1032 // struct LDKBuiltCommitmentTransaction CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
1034 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
1035 if(!isWasmInitialized) {
1036 throw new Error("initializeWasm() must be awaited first!");
1038 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner);
1039 return nativeResponseValue;
1041 // struct LDKDecodeError CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
1043 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
1044 if(!isWasmInitialized) {
1045 throw new Error("initializeWasm() must be awaited first!");
1047 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner);
1048 return nativeResponseValue;
1050 // struct LDKTrustedClosingTransaction CResult_TrustedClosingTransactionNoneZ_get_ok(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
1052 export function CResult_TrustedClosingTransactionNoneZ_get_ok(owner: bigint): bigint {
1053 if(!isWasmInitialized) {
1054 throw new Error("initializeWasm() must be awaited first!");
1056 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_ok(owner);
1057 return nativeResponseValue;
1059 // void CResult_TrustedClosingTransactionNoneZ_get_err(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
1061 export function CResult_TrustedClosingTransactionNoneZ_get_err(owner: bigint): void {
1062 if(!isWasmInitialized) {
1063 throw new Error("initializeWasm() must be awaited first!");
1065 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_err(owner);
1066 // debug statements here
1068 // struct LDKCommitmentTransaction CResult_CommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
1070 export function CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
1071 if(!isWasmInitialized) {
1072 throw new Error("initializeWasm() must be awaited first!");
1074 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner);
1075 return nativeResponseValue;
1077 // struct LDKDecodeError CResult_CommitmentTransactionDecodeErrorZ_get_err(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
1079 export function CResult_CommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
1080 if(!isWasmInitialized) {
1081 throw new Error("initializeWasm() must be awaited first!");
1083 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_err(owner);
1084 return nativeResponseValue;
1086 // struct LDKTrustedCommitmentTransaction CResult_TrustedCommitmentTransactionNoneZ_get_ok(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
1088 export function CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner: bigint): bigint {
1089 if(!isWasmInitialized) {
1090 throw new Error("initializeWasm() must be awaited first!");
1092 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner);
1093 return nativeResponseValue;
1095 // void CResult_TrustedCommitmentTransactionNoneZ_get_err(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
1097 export function CResult_TrustedCommitmentTransactionNoneZ_get_err(owner: bigint): void {
1098 if(!isWasmInitialized) {
1099 throw new Error("initializeWasm() must be awaited first!");
1101 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_err(owner);
1102 // debug statements here
1104 // struct LDKCVec_SignatureZ CResult_CVec_SignatureZNoneZ_get_ok(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
1106 export function CResult_CVec_SignatureZNoneZ_get_ok(owner: bigint): number {
1107 if(!isWasmInitialized) {
1108 throw new Error("initializeWasm() must be awaited first!");
1110 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_ok(owner);
1111 return nativeResponseValue;
1113 // void CResult_CVec_SignatureZNoneZ_get_err(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
1115 export function CResult_CVec_SignatureZNoneZ_get_err(owner: bigint): void {
1116 if(!isWasmInitialized) {
1117 throw new Error("initializeWasm() must be awaited first!");
1119 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_err(owner);
1120 // debug statements here
1122 // struct LDKShutdownScript CResult_ShutdownScriptDecodeErrorZ_get_ok(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
1124 export function CResult_ShutdownScriptDecodeErrorZ_get_ok(owner: bigint): bigint {
1125 if(!isWasmInitialized) {
1126 throw new Error("initializeWasm() must be awaited first!");
1128 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_ok(owner);
1129 return nativeResponseValue;
1131 // struct LDKDecodeError CResult_ShutdownScriptDecodeErrorZ_get_err(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
1133 export function CResult_ShutdownScriptDecodeErrorZ_get_err(owner: bigint): bigint {
1134 if(!isWasmInitialized) {
1135 throw new Error("initializeWasm() must be awaited first!");
1137 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_err(owner);
1138 return nativeResponseValue;
1140 // struct LDKShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
1142 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner: bigint): bigint {
1143 if(!isWasmInitialized) {
1144 throw new Error("initializeWasm() must be awaited first!");
1146 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner);
1147 return nativeResponseValue;
1149 // struct LDKInvalidShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
1151 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner: bigint): bigint {
1152 if(!isWasmInitialized) {
1153 throw new Error("initializeWasm() must be awaited first!");
1155 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner);
1156 return nativeResponseValue;
1158 // struct LDKRouteHop CResult_RouteHopDecodeErrorZ_get_ok(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
1160 export function CResult_RouteHopDecodeErrorZ_get_ok(owner: bigint): bigint {
1161 if(!isWasmInitialized) {
1162 throw new Error("initializeWasm() must be awaited first!");
1164 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_ok(owner);
1165 return nativeResponseValue;
1167 // struct LDKDecodeError CResult_RouteHopDecodeErrorZ_get_err(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
1169 export function CResult_RouteHopDecodeErrorZ_get_err(owner: bigint): bigint {
1170 if(!isWasmInitialized) {
1171 throw new Error("initializeWasm() must be awaited first!");
1173 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_err(owner);
1174 return nativeResponseValue;
1176 // struct LDKRoute CResult_RouteDecodeErrorZ_get_ok(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
1178 export function CResult_RouteDecodeErrorZ_get_ok(owner: bigint): bigint {
1179 if(!isWasmInitialized) {
1180 throw new Error("initializeWasm() must be awaited first!");
1182 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_ok(owner);
1183 return nativeResponseValue;
1185 // struct LDKDecodeError CResult_RouteDecodeErrorZ_get_err(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
1187 export function CResult_RouteDecodeErrorZ_get_err(owner: bigint): bigint {
1188 if(!isWasmInitialized) {
1189 throw new Error("initializeWasm() must be awaited first!");
1191 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_err(owner);
1192 return nativeResponseValue;
1194 // struct LDKRouteParameters CResult_RouteParametersDecodeErrorZ_get_ok(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
1196 export function CResult_RouteParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
1197 if(!isWasmInitialized) {
1198 throw new Error("initializeWasm() must be awaited first!");
1200 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_ok(owner);
1201 return nativeResponseValue;
1203 // struct LDKDecodeError CResult_RouteParametersDecodeErrorZ_get_err(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
1205 export function CResult_RouteParametersDecodeErrorZ_get_err(owner: bigint): bigint {
1206 if(!isWasmInitialized) {
1207 throw new Error("initializeWasm() must be awaited first!");
1209 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_err(owner);
1210 return nativeResponseValue;
1213 export class LDKCOption_u64Z {
1214 protected constructor() {}
1217 export function LDKCOption_u64Z_ty_from_ptr(ptr: bigint): number {
1218 if(!isWasmInitialized) {
1219 throw new Error("initializeWasm() must be awaited first!");
1221 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_ty_from_ptr(ptr);
1222 return nativeResponseValue;
1225 export function LDKCOption_u64Z_Some_get_some(ptr: bigint): bigint {
1226 if(!isWasmInitialized) {
1227 throw new Error("initializeWasm() must be awaited first!");
1229 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_Some_get_some(ptr);
1230 return nativeResponseValue;
1232 // struct LDKPaymentParameters CResult_PaymentParametersDecodeErrorZ_get_ok(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
1234 export function CResult_PaymentParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
1235 if(!isWasmInitialized) {
1236 throw new Error("initializeWasm() must be awaited first!");
1238 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_ok(owner);
1239 return nativeResponseValue;
1241 // struct LDKDecodeError CResult_PaymentParametersDecodeErrorZ_get_err(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
1243 export function CResult_PaymentParametersDecodeErrorZ_get_err(owner: bigint): bigint {
1244 if(!isWasmInitialized) {
1245 throw new Error("initializeWasm() must be awaited first!");
1247 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_err(owner);
1248 return nativeResponseValue;
1250 // struct LDKRouteHint CResult_RouteHintDecodeErrorZ_get_ok(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
1252 export function CResult_RouteHintDecodeErrorZ_get_ok(owner: bigint): bigint {
1253 if(!isWasmInitialized) {
1254 throw new Error("initializeWasm() must be awaited first!");
1256 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_ok(owner);
1257 return nativeResponseValue;
1259 // struct LDKDecodeError CResult_RouteHintDecodeErrorZ_get_err(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
1261 export function CResult_RouteHintDecodeErrorZ_get_err(owner: bigint): bigint {
1262 if(!isWasmInitialized) {
1263 throw new Error("initializeWasm() must be awaited first!");
1265 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_err(owner);
1266 return nativeResponseValue;
1268 // struct LDKRouteHintHop CResult_RouteHintHopDecodeErrorZ_get_ok(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
1270 export function CResult_RouteHintHopDecodeErrorZ_get_ok(owner: bigint): bigint {
1271 if(!isWasmInitialized) {
1272 throw new Error("initializeWasm() must be awaited first!");
1274 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_ok(owner);
1275 return nativeResponseValue;
1277 // struct LDKDecodeError CResult_RouteHintHopDecodeErrorZ_get_err(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
1279 export function CResult_RouteHintHopDecodeErrorZ_get_err(owner: bigint): bigint {
1280 if(!isWasmInitialized) {
1281 throw new Error("initializeWasm() must be awaited first!");
1283 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_err(owner);
1284 return nativeResponseValue;
1286 // struct LDKRoute CResult_RouteLightningErrorZ_get_ok(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
1288 export function CResult_RouteLightningErrorZ_get_ok(owner: bigint): bigint {
1289 if(!isWasmInitialized) {
1290 throw new Error("initializeWasm() must be awaited first!");
1292 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_ok(owner);
1293 return nativeResponseValue;
1295 // struct LDKLightningError CResult_RouteLightningErrorZ_get_err(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
1297 export function CResult_RouteLightningErrorZ_get_err(owner: bigint): bigint {
1298 if(!isWasmInitialized) {
1299 throw new Error("initializeWasm() must be awaited first!");
1301 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_err(owner);
1302 return nativeResponseValue;
1305 export class LDKPaymentPurpose {
1306 protected constructor() {}
1309 export function LDKPaymentPurpose_ty_from_ptr(ptr: bigint): number {
1310 if(!isWasmInitialized) {
1311 throw new Error("initializeWasm() must be awaited first!");
1313 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_ty_from_ptr(ptr);
1314 return nativeResponseValue;
1317 export function LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr: bigint): number {
1318 if(!isWasmInitialized) {
1319 throw new Error("initializeWasm() must be awaited first!");
1321 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr);
1322 return nativeResponseValue;
1325 export function LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr: bigint): number {
1326 if(!isWasmInitialized) {
1327 throw new Error("initializeWasm() must be awaited first!");
1329 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr);
1330 return nativeResponseValue;
1333 export function LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr: bigint): number {
1334 if(!isWasmInitialized) {
1335 throw new Error("initializeWasm() must be awaited first!");
1337 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr);
1338 return nativeResponseValue;
1340 // struct LDKPaymentPurpose CResult_PaymentPurposeDecodeErrorZ_get_ok(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
1342 export function CResult_PaymentPurposeDecodeErrorZ_get_ok(owner: bigint): bigint {
1343 if(!isWasmInitialized) {
1344 throw new Error("initializeWasm() must be awaited first!");
1346 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_ok(owner);
1347 return nativeResponseValue;
1349 // struct LDKDecodeError CResult_PaymentPurposeDecodeErrorZ_get_err(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
1351 export function CResult_PaymentPurposeDecodeErrorZ_get_err(owner: bigint): bigint {
1352 if(!isWasmInitialized) {
1353 throw new Error("initializeWasm() must be awaited first!");
1355 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_err(owner);
1356 return nativeResponseValue;
1359 export class LDKClosureReason {
1360 protected constructor() {}
1363 export function LDKClosureReason_ty_from_ptr(ptr: bigint): number {
1364 if(!isWasmInitialized) {
1365 throw new Error("initializeWasm() must be awaited first!");
1367 const nativeResponseValue = wasm.TS_LDKClosureReason_ty_from_ptr(ptr);
1368 return nativeResponseValue;
1371 export function LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr: bigint): number {
1372 if(!isWasmInitialized) {
1373 throw new Error("initializeWasm() must be awaited first!");
1375 const nativeResponseValue = wasm.TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr);
1376 return nativeResponseValue;
1379 export function LDKClosureReason_ProcessingError_get_err(ptr: bigint): number {
1380 if(!isWasmInitialized) {
1381 throw new Error("initializeWasm() must be awaited first!");
1383 const nativeResponseValue = wasm.TS_LDKClosureReason_ProcessingError_get_err(ptr);
1384 return nativeResponseValue;
1387 export class LDKCOption_ClosureReasonZ {
1388 protected constructor() {}
1391 export function LDKCOption_ClosureReasonZ_ty_from_ptr(ptr: bigint): number {
1392 if(!isWasmInitialized) {
1393 throw new Error("initializeWasm() must be awaited first!");
1395 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_ty_from_ptr(ptr);
1396 return nativeResponseValue;
1399 export function LDKCOption_ClosureReasonZ_Some_get_some(ptr: bigint): bigint {
1400 if(!isWasmInitialized) {
1401 throw new Error("initializeWasm() must be awaited first!");
1403 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_Some_get_some(ptr);
1404 return nativeResponseValue;
1406 // struct LDKCOption_ClosureReasonZ CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
1408 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner: bigint): bigint {
1409 if(!isWasmInitialized) {
1410 throw new Error("initializeWasm() must be awaited first!");
1412 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner);
1413 return nativeResponseValue;
1415 // struct LDKDecodeError CResult_COption_ClosureReasonZDecodeErrorZ_get_err(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
1417 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner: bigint): bigint {
1418 if(!isWasmInitialized) {
1419 throw new Error("initializeWasm() must be awaited first!");
1421 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner);
1422 return nativeResponseValue;
1425 export class LDKHTLCDestination {
1426 protected constructor() {}
1429 export function LDKHTLCDestination_ty_from_ptr(ptr: bigint): number {
1430 if(!isWasmInitialized) {
1431 throw new Error("initializeWasm() must be awaited first!");
1433 const nativeResponseValue = wasm.TS_LDKHTLCDestination_ty_from_ptr(ptr);
1434 return nativeResponseValue;
1437 export function LDKHTLCDestination_NextHopChannel_get_node_id(ptr: bigint): number {
1438 if(!isWasmInitialized) {
1439 throw new Error("initializeWasm() must be awaited first!");
1441 const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_node_id(ptr);
1442 return nativeResponseValue;
1445 export function LDKHTLCDestination_NextHopChannel_get_channel_id(ptr: bigint): number {
1446 if(!isWasmInitialized) {
1447 throw new Error("initializeWasm() must be awaited first!");
1449 const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_channel_id(ptr);
1450 return nativeResponseValue;
1453 export function LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr: bigint): bigint {
1454 if(!isWasmInitialized) {
1455 throw new Error("initializeWasm() must be awaited first!");
1457 const nativeResponseValue = wasm.TS_LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr);
1458 return nativeResponseValue;
1461 export function LDKHTLCDestination_FailedPayment_get_payment_hash(ptr: bigint): number {
1462 if(!isWasmInitialized) {
1463 throw new Error("initializeWasm() must be awaited first!");
1465 const nativeResponseValue = wasm.TS_LDKHTLCDestination_FailedPayment_get_payment_hash(ptr);
1466 return nativeResponseValue;
1469 export class LDKCOption_HTLCDestinationZ {
1470 protected constructor() {}
1473 export function LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr: bigint): number {
1474 if(!isWasmInitialized) {
1475 throw new Error("initializeWasm() must be awaited first!");
1477 const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr);
1478 return nativeResponseValue;
1481 export function LDKCOption_HTLCDestinationZ_Some_get_some(ptr: bigint): bigint {
1482 if(!isWasmInitialized) {
1483 throw new Error("initializeWasm() must be awaited first!");
1485 const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_Some_get_some(ptr);
1486 return nativeResponseValue;
1488 // struct LDKCOption_HTLCDestinationZ CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
1490 export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner: bigint): bigint {
1491 if(!isWasmInitialized) {
1492 throw new Error("initializeWasm() must be awaited first!");
1494 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner);
1495 return nativeResponseValue;
1497 // struct LDKDecodeError CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
1499 export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner: bigint): bigint {
1500 if(!isWasmInitialized) {
1501 throw new Error("initializeWasm() must be awaited first!");
1503 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner);
1504 return nativeResponseValue;
1507 export class LDKNetworkUpdate {
1508 protected constructor() {}
1511 export function LDKNetworkUpdate_ty_from_ptr(ptr: bigint): number {
1512 if(!isWasmInitialized) {
1513 throw new Error("initializeWasm() must be awaited first!");
1515 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ty_from_ptr(ptr);
1516 return nativeResponseValue;
1519 export function LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr: bigint): bigint {
1520 if(!isWasmInitialized) {
1521 throw new Error("initializeWasm() must be awaited first!");
1523 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr);
1524 return nativeResponseValue;
1527 export function LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr: bigint): bigint {
1528 if(!isWasmInitialized) {
1529 throw new Error("initializeWasm() must be awaited first!");
1531 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr);
1532 return nativeResponseValue;
1535 export function LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr: bigint): boolean {
1536 if(!isWasmInitialized) {
1537 throw new Error("initializeWasm() must be awaited first!");
1539 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr);
1540 return nativeResponseValue;
1543 export function LDKNetworkUpdate_NodeFailure_get_node_id(ptr: bigint): number {
1544 if(!isWasmInitialized) {
1545 throw new Error("initializeWasm() must be awaited first!");
1547 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_node_id(ptr);
1548 return nativeResponseValue;
1551 export function LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr: bigint): boolean {
1552 if(!isWasmInitialized) {
1553 throw new Error("initializeWasm() must be awaited first!");
1555 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr);
1556 return nativeResponseValue;
1559 export class LDKCOption_NetworkUpdateZ {
1560 protected constructor() {}
1563 export function LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr: bigint): number {
1564 if(!isWasmInitialized) {
1565 throw new Error("initializeWasm() must be awaited first!");
1567 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr);
1568 return nativeResponseValue;
1571 export function LDKCOption_NetworkUpdateZ_Some_get_some(ptr: bigint): bigint {
1572 if(!isWasmInitialized) {
1573 throw new Error("initializeWasm() must be awaited first!");
1575 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_Some_get_some(ptr);
1576 return nativeResponseValue;
1579 export class LDKSpendableOutputDescriptor {
1580 protected constructor() {}
1583 export function LDKSpendableOutputDescriptor_ty_from_ptr(ptr: bigint): number {
1584 if(!isWasmInitialized) {
1585 throw new Error("initializeWasm() must be awaited first!");
1587 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_ty_from_ptr(ptr);
1588 return nativeResponseValue;
1591 export function LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr: bigint): bigint {
1592 if(!isWasmInitialized) {
1593 throw new Error("initializeWasm() must be awaited first!");
1595 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr);
1596 return nativeResponseValue;
1599 export function LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr: bigint): bigint {
1600 if(!isWasmInitialized) {
1601 throw new Error("initializeWasm() must be awaited first!");
1603 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr);
1604 return nativeResponseValue;
1607 export function LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr: bigint): bigint {
1608 if(!isWasmInitialized) {
1609 throw new Error("initializeWasm() must be awaited first!");
1611 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr);
1612 return nativeResponseValue;
1615 export function LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr: bigint): bigint {
1616 if(!isWasmInitialized) {
1617 throw new Error("initializeWasm() must be awaited first!");
1619 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr);
1620 return nativeResponseValue;
1623 export class LDKEvent {
1624 protected constructor() {}
1627 export function LDKEvent_ty_from_ptr(ptr: bigint): number {
1628 if(!isWasmInitialized) {
1629 throw new Error("initializeWasm() must be awaited first!");
1631 const nativeResponseValue = wasm.TS_LDKEvent_ty_from_ptr(ptr);
1632 return nativeResponseValue;
1635 export function LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr: bigint): number {
1636 if(!isWasmInitialized) {
1637 throw new Error("initializeWasm() must be awaited first!");
1639 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr);
1640 return nativeResponseValue;
1643 export function LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr: bigint): number {
1644 if(!isWasmInitialized) {
1645 throw new Error("initializeWasm() must be awaited first!");
1647 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr);
1648 return nativeResponseValue;
1651 export function LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr: bigint): bigint {
1652 if(!isWasmInitialized) {
1653 throw new Error("initializeWasm() must be awaited first!");
1655 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr);
1656 return nativeResponseValue;
1659 export function LDKEvent_FundingGenerationReady_get_output_script(ptr: bigint): number {
1660 if(!isWasmInitialized) {
1661 throw new Error("initializeWasm() must be awaited first!");
1663 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_output_script(ptr);
1664 return nativeResponseValue;
1667 export function LDKEvent_FundingGenerationReady_get_user_channel_id(ptr: bigint): bigint {
1668 if(!isWasmInitialized) {
1669 throw new Error("initializeWasm() must be awaited first!");
1671 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_user_channel_id(ptr);
1672 return nativeResponseValue;
1675 export function LDKEvent_PaymentReceived_get_payment_hash(ptr: bigint): number {
1676 if(!isWasmInitialized) {
1677 throw new Error("initializeWasm() must be awaited first!");
1679 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_payment_hash(ptr);
1680 return nativeResponseValue;
1683 export function LDKEvent_PaymentReceived_get_amount_msat(ptr: bigint): bigint {
1684 if(!isWasmInitialized) {
1685 throw new Error("initializeWasm() must be awaited first!");
1687 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_amount_msat(ptr);
1688 return nativeResponseValue;
1691 export function LDKEvent_PaymentReceived_get_purpose(ptr: bigint): bigint {
1692 if(!isWasmInitialized) {
1693 throw new Error("initializeWasm() must be awaited first!");
1695 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_purpose(ptr);
1696 return nativeResponseValue;
1699 export function LDKEvent_PaymentClaimed_get_payment_hash(ptr: bigint): number {
1700 if(!isWasmInitialized) {
1701 throw new Error("initializeWasm() must be awaited first!");
1703 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_payment_hash(ptr);
1704 return nativeResponseValue;
1707 export function LDKEvent_PaymentClaimed_get_amount_msat(ptr: bigint): bigint {
1708 if(!isWasmInitialized) {
1709 throw new Error("initializeWasm() must be awaited first!");
1711 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_amount_msat(ptr);
1712 return nativeResponseValue;
1715 export function LDKEvent_PaymentClaimed_get_purpose(ptr: bigint): bigint {
1716 if(!isWasmInitialized) {
1717 throw new Error("initializeWasm() must be awaited first!");
1719 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_purpose(ptr);
1720 return nativeResponseValue;
1723 export function LDKEvent_PaymentSent_get_payment_id(ptr: bigint): number {
1724 if(!isWasmInitialized) {
1725 throw new Error("initializeWasm() must be awaited first!");
1727 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_id(ptr);
1728 return nativeResponseValue;
1731 export function LDKEvent_PaymentSent_get_payment_preimage(ptr: bigint): number {
1732 if(!isWasmInitialized) {
1733 throw new Error("initializeWasm() must be awaited first!");
1735 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_preimage(ptr);
1736 return nativeResponseValue;
1739 export function LDKEvent_PaymentSent_get_payment_hash(ptr: bigint): number {
1740 if(!isWasmInitialized) {
1741 throw new Error("initializeWasm() must be awaited first!");
1743 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_hash(ptr);
1744 return nativeResponseValue;
1747 export function LDKEvent_PaymentSent_get_fee_paid_msat(ptr: bigint): bigint {
1748 if(!isWasmInitialized) {
1749 throw new Error("initializeWasm() must be awaited first!");
1751 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_fee_paid_msat(ptr);
1752 return nativeResponseValue;
1755 export function LDKEvent_PaymentFailed_get_payment_id(ptr: bigint): number {
1756 if(!isWasmInitialized) {
1757 throw new Error("initializeWasm() must be awaited first!");
1759 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_id(ptr);
1760 return nativeResponseValue;
1763 export function LDKEvent_PaymentFailed_get_payment_hash(ptr: bigint): number {
1764 if(!isWasmInitialized) {
1765 throw new Error("initializeWasm() must be awaited first!");
1767 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_hash(ptr);
1768 return nativeResponseValue;
1771 export function LDKEvent_PaymentPathSuccessful_get_payment_id(ptr: bigint): number {
1772 if(!isWasmInitialized) {
1773 throw new Error("initializeWasm() must be awaited first!");
1775 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_id(ptr);
1776 return nativeResponseValue;
1779 export function LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr: bigint): number {
1780 if(!isWasmInitialized) {
1781 throw new Error("initializeWasm() must be awaited first!");
1783 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr);
1784 return nativeResponseValue;
1787 export function LDKEvent_PaymentPathSuccessful_get_path(ptr: bigint): number {
1788 if(!isWasmInitialized) {
1789 throw new Error("initializeWasm() must be awaited first!");
1791 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_path(ptr);
1792 return nativeResponseValue;
1795 export function LDKEvent_PaymentPathFailed_get_payment_id(ptr: bigint): number {
1796 if(!isWasmInitialized) {
1797 throw new Error("initializeWasm() must be awaited first!");
1799 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_id(ptr);
1800 return nativeResponseValue;
1803 export function LDKEvent_PaymentPathFailed_get_payment_hash(ptr: bigint): number {
1804 if(!isWasmInitialized) {
1805 throw new Error("initializeWasm() must be awaited first!");
1807 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_hash(ptr);
1808 return nativeResponseValue;
1811 export function LDKEvent_PaymentPathFailed_get_payment_failed_permanently(ptr: bigint): boolean {
1812 if(!isWasmInitialized) {
1813 throw new Error("initializeWasm() must be awaited first!");
1815 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_failed_permanently(ptr);
1816 return nativeResponseValue;
1819 export function LDKEvent_PaymentPathFailed_get_network_update(ptr: bigint): bigint {
1820 if(!isWasmInitialized) {
1821 throw new Error("initializeWasm() must be awaited first!");
1823 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_network_update(ptr);
1824 return nativeResponseValue;
1827 export function LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr: bigint): boolean {
1828 if(!isWasmInitialized) {
1829 throw new Error("initializeWasm() must be awaited first!");
1831 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr);
1832 return nativeResponseValue;
1835 export function LDKEvent_PaymentPathFailed_get_path(ptr: bigint): number {
1836 if(!isWasmInitialized) {
1837 throw new Error("initializeWasm() must be awaited first!");
1839 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_path(ptr);
1840 return nativeResponseValue;
1843 export function LDKEvent_PaymentPathFailed_get_short_channel_id(ptr: bigint): bigint {
1844 if(!isWasmInitialized) {
1845 throw new Error("initializeWasm() must be awaited first!");
1847 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_short_channel_id(ptr);
1848 return nativeResponseValue;
1851 export function LDKEvent_PaymentPathFailed_get_retry(ptr: bigint): bigint {
1852 if(!isWasmInitialized) {
1853 throw new Error("initializeWasm() must be awaited first!");
1855 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_retry(ptr);
1856 return nativeResponseValue;
1859 export function LDKEvent_ProbeSuccessful_get_payment_id(ptr: bigint): number {
1860 if(!isWasmInitialized) {
1861 throw new Error("initializeWasm() must be awaited first!");
1863 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_payment_id(ptr);
1864 return nativeResponseValue;
1867 export function LDKEvent_ProbeSuccessful_get_payment_hash(ptr: bigint): number {
1868 if(!isWasmInitialized) {
1869 throw new Error("initializeWasm() must be awaited first!");
1871 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_payment_hash(ptr);
1872 return nativeResponseValue;
1875 export function LDKEvent_ProbeSuccessful_get_path(ptr: bigint): number {
1876 if(!isWasmInitialized) {
1877 throw new Error("initializeWasm() must be awaited first!");
1879 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_path(ptr);
1880 return nativeResponseValue;
1883 export function LDKEvent_ProbeFailed_get_payment_id(ptr: bigint): number {
1884 if(!isWasmInitialized) {
1885 throw new Error("initializeWasm() must be awaited first!");
1887 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_payment_id(ptr);
1888 return nativeResponseValue;
1891 export function LDKEvent_ProbeFailed_get_payment_hash(ptr: bigint): number {
1892 if(!isWasmInitialized) {
1893 throw new Error("initializeWasm() must be awaited first!");
1895 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_payment_hash(ptr);
1896 return nativeResponseValue;
1899 export function LDKEvent_ProbeFailed_get_path(ptr: bigint): number {
1900 if(!isWasmInitialized) {
1901 throw new Error("initializeWasm() must be awaited first!");
1903 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_path(ptr);
1904 return nativeResponseValue;
1907 export function LDKEvent_ProbeFailed_get_short_channel_id(ptr: bigint): bigint {
1908 if(!isWasmInitialized) {
1909 throw new Error("initializeWasm() must be awaited first!");
1911 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_short_channel_id(ptr);
1912 return nativeResponseValue;
1915 export function LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr: bigint): bigint {
1916 if(!isWasmInitialized) {
1917 throw new Error("initializeWasm() must be awaited first!");
1919 const nativeResponseValue = wasm.TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr);
1920 return nativeResponseValue;
1923 export function LDKEvent_SpendableOutputs_get_outputs(ptr: bigint): number {
1924 if(!isWasmInitialized) {
1925 throw new Error("initializeWasm() must be awaited first!");
1927 const nativeResponseValue = wasm.TS_LDKEvent_SpendableOutputs_get_outputs(ptr);
1928 return nativeResponseValue;
1931 export function LDKEvent_PaymentForwarded_get_prev_channel_id(ptr: bigint): number {
1932 if(!isWasmInitialized) {
1933 throw new Error("initializeWasm() must be awaited first!");
1935 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_prev_channel_id(ptr);
1936 return nativeResponseValue;
1939 export function LDKEvent_PaymentForwarded_get_next_channel_id(ptr: bigint): number {
1940 if(!isWasmInitialized) {
1941 throw new Error("initializeWasm() must be awaited first!");
1943 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_next_channel_id(ptr);
1944 return nativeResponseValue;
1947 export function LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr: bigint): bigint {
1948 if(!isWasmInitialized) {
1949 throw new Error("initializeWasm() must be awaited first!");
1951 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr);
1952 return nativeResponseValue;
1955 export function LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr: bigint): boolean {
1956 if(!isWasmInitialized) {
1957 throw new Error("initializeWasm() must be awaited first!");
1959 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr);
1960 return nativeResponseValue;
1963 export function LDKEvent_ChannelClosed_get_channel_id(ptr: bigint): number {
1964 if(!isWasmInitialized) {
1965 throw new Error("initializeWasm() must be awaited first!");
1967 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_channel_id(ptr);
1968 return nativeResponseValue;
1971 export function LDKEvent_ChannelClosed_get_user_channel_id(ptr: bigint): bigint {
1972 if(!isWasmInitialized) {
1973 throw new Error("initializeWasm() must be awaited first!");
1975 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_user_channel_id(ptr);
1976 return nativeResponseValue;
1979 export function LDKEvent_ChannelClosed_get_reason(ptr: bigint): bigint {
1980 if(!isWasmInitialized) {
1981 throw new Error("initializeWasm() must be awaited first!");
1983 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_reason(ptr);
1984 return nativeResponseValue;
1987 export function LDKEvent_DiscardFunding_get_channel_id(ptr: bigint): number {
1988 if(!isWasmInitialized) {
1989 throw new Error("initializeWasm() must be awaited first!");
1991 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_channel_id(ptr);
1992 return nativeResponseValue;
1995 export function LDKEvent_DiscardFunding_get_transaction(ptr: bigint): number {
1996 if(!isWasmInitialized) {
1997 throw new Error("initializeWasm() must be awaited first!");
1999 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_transaction(ptr);
2000 return nativeResponseValue;
2003 export function LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr: bigint): number {
2004 if(!isWasmInitialized) {
2005 throw new Error("initializeWasm() must be awaited first!");
2007 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr);
2008 return nativeResponseValue;
2011 export function LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr: bigint): number {
2012 if(!isWasmInitialized) {
2013 throw new Error("initializeWasm() must be awaited first!");
2015 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr);
2016 return nativeResponseValue;
2019 export function LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr: bigint): bigint {
2020 if(!isWasmInitialized) {
2021 throw new Error("initializeWasm() must be awaited first!");
2023 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr);
2024 return nativeResponseValue;
2027 export function LDKEvent_OpenChannelRequest_get_push_msat(ptr: bigint): bigint {
2028 if(!isWasmInitialized) {
2029 throw new Error("initializeWasm() must be awaited first!");
2031 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_push_msat(ptr);
2032 return nativeResponseValue;
2035 export function LDKEvent_OpenChannelRequest_get_channel_type(ptr: bigint): bigint {
2036 if(!isWasmInitialized) {
2037 throw new Error("initializeWasm() must be awaited first!");
2039 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_channel_type(ptr);
2040 return nativeResponseValue;
2043 export function LDKEvent_HTLCHandlingFailed_get_prev_channel_id(ptr: bigint): number {
2044 if(!isWasmInitialized) {
2045 throw new Error("initializeWasm() must be awaited first!");
2047 const nativeResponseValue = wasm.TS_LDKEvent_HTLCHandlingFailed_get_prev_channel_id(ptr);
2048 return nativeResponseValue;
2051 export function LDKEvent_HTLCHandlingFailed_get_failed_next_destination(ptr: bigint): bigint {
2052 if(!isWasmInitialized) {
2053 throw new Error("initializeWasm() must be awaited first!");
2055 const nativeResponseValue = wasm.TS_LDKEvent_HTLCHandlingFailed_get_failed_next_destination(ptr);
2056 return nativeResponseValue;
2059 export class LDKCOption_EventZ {
2060 protected constructor() {}
2063 export function LDKCOption_EventZ_ty_from_ptr(ptr: bigint): number {
2064 if(!isWasmInitialized) {
2065 throw new Error("initializeWasm() must be awaited first!");
2067 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_ty_from_ptr(ptr);
2068 return nativeResponseValue;
2071 export function LDKCOption_EventZ_Some_get_some(ptr: bigint): bigint {
2072 if(!isWasmInitialized) {
2073 throw new Error("initializeWasm() must be awaited first!");
2075 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_Some_get_some(ptr);
2076 return nativeResponseValue;
2078 // struct LDKCOption_EventZ CResult_COption_EventZDecodeErrorZ_get_ok(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
2080 export function CResult_COption_EventZDecodeErrorZ_get_ok(owner: bigint): bigint {
2081 if(!isWasmInitialized) {
2082 throw new Error("initializeWasm() must be awaited first!");
2084 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_ok(owner);
2085 return nativeResponseValue;
2087 // struct LDKDecodeError CResult_COption_EventZDecodeErrorZ_get_err(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
2089 export function CResult_COption_EventZDecodeErrorZ_get_err(owner: bigint): bigint {
2090 if(!isWasmInitialized) {
2091 throw new Error("initializeWasm() must be awaited first!");
2093 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_err(owner);
2094 return nativeResponseValue;
2097 export class LDKErrorAction {
2098 protected constructor() {}
2101 export function LDKErrorAction_ty_from_ptr(ptr: bigint): number {
2102 if(!isWasmInitialized) {
2103 throw new Error("initializeWasm() must be awaited first!");
2105 const nativeResponseValue = wasm.TS_LDKErrorAction_ty_from_ptr(ptr);
2106 return nativeResponseValue;
2109 export function LDKErrorAction_DisconnectPeer_get_msg(ptr: bigint): bigint {
2110 if(!isWasmInitialized) {
2111 throw new Error("initializeWasm() must be awaited first!");
2113 const nativeResponseValue = wasm.TS_LDKErrorAction_DisconnectPeer_get_msg(ptr);
2114 return nativeResponseValue;
2117 export function LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr: bigint): Level {
2118 if(!isWasmInitialized) {
2119 throw new Error("initializeWasm() must be awaited first!");
2121 const nativeResponseValue = wasm.TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr);
2122 return nativeResponseValue;
2125 export function LDKErrorAction_SendErrorMessage_get_msg(ptr: bigint): bigint {
2126 if(!isWasmInitialized) {
2127 throw new Error("initializeWasm() must be awaited first!");
2129 const nativeResponseValue = wasm.TS_LDKErrorAction_SendErrorMessage_get_msg(ptr);
2130 return nativeResponseValue;
2133 export function LDKErrorAction_SendWarningMessage_get_msg(ptr: bigint): bigint {
2134 if(!isWasmInitialized) {
2135 throw new Error("initializeWasm() must be awaited first!");
2137 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_msg(ptr);
2138 return nativeResponseValue;
2141 export function LDKErrorAction_SendWarningMessage_get_log_level(ptr: bigint): Level {
2142 if(!isWasmInitialized) {
2143 throw new Error("initializeWasm() must be awaited first!");
2145 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_log_level(ptr);
2146 return nativeResponseValue;
2149 export class LDKMessageSendEvent {
2150 protected constructor() {}
2153 export function LDKMessageSendEvent_ty_from_ptr(ptr: bigint): number {
2154 if(!isWasmInitialized) {
2155 throw new Error("initializeWasm() must be awaited first!");
2157 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_ty_from_ptr(ptr);
2158 return nativeResponseValue;
2161 export function LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr: bigint): number {
2162 if(!isWasmInitialized) {
2163 throw new Error("initializeWasm() must be awaited first!");
2165 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr);
2166 return nativeResponseValue;
2169 export function LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr: bigint): bigint {
2170 if(!isWasmInitialized) {
2171 throw new Error("initializeWasm() must be awaited first!");
2173 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr);
2174 return nativeResponseValue;
2177 export function LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr: bigint): number {
2178 if(!isWasmInitialized) {
2179 throw new Error("initializeWasm() must be awaited first!");
2181 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr);
2182 return nativeResponseValue;
2185 export function LDKMessageSendEvent_SendOpenChannel_get_msg(ptr: bigint): bigint {
2186 if(!isWasmInitialized) {
2187 throw new Error("initializeWasm() must be awaited first!");
2189 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_msg(ptr);
2190 return nativeResponseValue;
2193 export function LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr: bigint): number {
2194 if(!isWasmInitialized) {
2195 throw new Error("initializeWasm() must be awaited first!");
2197 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr);
2198 return nativeResponseValue;
2201 export function LDKMessageSendEvent_SendFundingCreated_get_msg(ptr: bigint): bigint {
2202 if(!isWasmInitialized) {
2203 throw new Error("initializeWasm() must be awaited first!");
2205 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_msg(ptr);
2206 return nativeResponseValue;
2209 export function LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr: bigint): number {
2210 if(!isWasmInitialized) {
2211 throw new Error("initializeWasm() must be awaited first!");
2213 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr);
2214 return nativeResponseValue;
2217 export function LDKMessageSendEvent_SendFundingSigned_get_msg(ptr: bigint): bigint {
2218 if(!isWasmInitialized) {
2219 throw new Error("initializeWasm() must be awaited first!");
2221 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_msg(ptr);
2222 return nativeResponseValue;
2225 export function LDKMessageSendEvent_SendChannelReady_get_node_id(ptr: bigint): number {
2226 if(!isWasmInitialized) {
2227 throw new Error("initializeWasm() must be awaited first!");
2229 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_node_id(ptr);
2230 return nativeResponseValue;
2233 export function LDKMessageSendEvent_SendChannelReady_get_msg(ptr: bigint): bigint {
2234 if(!isWasmInitialized) {
2235 throw new Error("initializeWasm() must be awaited first!");
2237 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_msg(ptr);
2238 return nativeResponseValue;
2241 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr: bigint): number {
2242 if(!isWasmInitialized) {
2243 throw new Error("initializeWasm() must be awaited first!");
2245 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr);
2246 return nativeResponseValue;
2249 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr: bigint): bigint {
2250 if(!isWasmInitialized) {
2251 throw new Error("initializeWasm() must be awaited first!");
2253 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr);
2254 return nativeResponseValue;
2257 export function LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr: bigint): number {
2258 if(!isWasmInitialized) {
2259 throw new Error("initializeWasm() must be awaited first!");
2261 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr);
2262 return nativeResponseValue;
2265 export function LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr: bigint): bigint {
2266 if(!isWasmInitialized) {
2267 throw new Error("initializeWasm() must be awaited first!");
2269 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr);
2270 return nativeResponseValue;
2273 export function LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr: bigint): number {
2274 if(!isWasmInitialized) {
2275 throw new Error("initializeWasm() must be awaited first!");
2277 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr);
2278 return nativeResponseValue;
2281 export function LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr: bigint): bigint {
2282 if(!isWasmInitialized) {
2283 throw new Error("initializeWasm() must be awaited first!");
2285 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr);
2286 return nativeResponseValue;
2289 export function LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr: bigint): number {
2290 if(!isWasmInitialized) {
2291 throw new Error("initializeWasm() must be awaited first!");
2293 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr);
2294 return nativeResponseValue;
2297 export function LDKMessageSendEvent_SendClosingSigned_get_msg(ptr: bigint): bigint {
2298 if(!isWasmInitialized) {
2299 throw new Error("initializeWasm() must be awaited first!");
2301 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_msg(ptr);
2302 return nativeResponseValue;
2305 export function LDKMessageSendEvent_SendShutdown_get_node_id(ptr: bigint): number {
2306 if(!isWasmInitialized) {
2307 throw new Error("initializeWasm() must be awaited first!");
2309 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_node_id(ptr);
2310 return nativeResponseValue;
2313 export function LDKMessageSendEvent_SendShutdown_get_msg(ptr: bigint): bigint {
2314 if(!isWasmInitialized) {
2315 throw new Error("initializeWasm() must be awaited first!");
2317 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_msg(ptr);
2318 return nativeResponseValue;
2321 export function LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr: bigint): number {
2322 if(!isWasmInitialized) {
2323 throw new Error("initializeWasm() must be awaited first!");
2325 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr);
2326 return nativeResponseValue;
2329 export function LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr: bigint): bigint {
2330 if(!isWasmInitialized) {
2331 throw new Error("initializeWasm() must be awaited first!");
2333 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr);
2334 return nativeResponseValue;
2337 export function LDKMessageSendEvent_SendChannelAnnouncement_get_node_id(ptr: bigint): number {
2338 if(!isWasmInitialized) {
2339 throw new Error("initializeWasm() must be awaited first!");
2341 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelAnnouncement_get_node_id(ptr);
2342 return nativeResponseValue;
2345 export function LDKMessageSendEvent_SendChannelAnnouncement_get_msg(ptr: bigint): bigint {
2346 if(!isWasmInitialized) {
2347 throw new Error("initializeWasm() must be awaited first!");
2349 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelAnnouncement_get_msg(ptr);
2350 return nativeResponseValue;
2353 export function LDKMessageSendEvent_SendChannelAnnouncement_get_update_msg(ptr: bigint): bigint {
2354 if(!isWasmInitialized) {
2355 throw new Error("initializeWasm() must be awaited first!");
2357 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelAnnouncement_get_update_msg(ptr);
2358 return nativeResponseValue;
2361 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr: bigint): bigint {
2362 if(!isWasmInitialized) {
2363 throw new Error("initializeWasm() must be awaited first!");
2365 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr);
2366 return nativeResponseValue;
2369 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr: bigint): bigint {
2370 if(!isWasmInitialized) {
2371 throw new Error("initializeWasm() must be awaited first!");
2373 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr);
2374 return nativeResponseValue;
2377 export function LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr: bigint): bigint {
2378 if(!isWasmInitialized) {
2379 throw new Error("initializeWasm() must be awaited first!");
2381 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr);
2382 return nativeResponseValue;
2385 export function LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr: bigint): number {
2386 if(!isWasmInitialized) {
2387 throw new Error("initializeWasm() must be awaited first!");
2389 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr);
2390 return nativeResponseValue;
2393 export function LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr: bigint): bigint {
2394 if(!isWasmInitialized) {
2395 throw new Error("initializeWasm() must be awaited first!");
2397 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr);
2398 return nativeResponseValue;
2401 export function LDKMessageSendEvent_HandleError_get_node_id(ptr: bigint): number {
2402 if(!isWasmInitialized) {
2403 throw new Error("initializeWasm() must be awaited first!");
2405 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_node_id(ptr);
2406 return nativeResponseValue;
2409 export function LDKMessageSendEvent_HandleError_get_action(ptr: bigint): bigint {
2410 if(!isWasmInitialized) {
2411 throw new Error("initializeWasm() must be awaited first!");
2413 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_action(ptr);
2414 return nativeResponseValue;
2417 export function LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr: bigint): number {
2418 if(!isWasmInitialized) {
2419 throw new Error("initializeWasm() must be awaited first!");
2421 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr);
2422 return nativeResponseValue;
2425 export function LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr: bigint): bigint {
2426 if(!isWasmInitialized) {
2427 throw new Error("initializeWasm() must be awaited first!");
2429 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr);
2430 return nativeResponseValue;
2433 export function LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr: bigint): number {
2434 if(!isWasmInitialized) {
2435 throw new Error("initializeWasm() must be awaited first!");
2437 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr);
2438 return nativeResponseValue;
2441 export function LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr: bigint): bigint {
2442 if(!isWasmInitialized) {
2443 throw new Error("initializeWasm() must be awaited first!");
2445 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr);
2446 return nativeResponseValue;
2449 export function LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr: bigint): number {
2450 if(!isWasmInitialized) {
2451 throw new Error("initializeWasm() must be awaited first!");
2453 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr);
2454 return nativeResponseValue;
2457 export function LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr: bigint): bigint {
2458 if(!isWasmInitialized) {
2459 throw new Error("initializeWasm() must be awaited first!");
2461 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr);
2462 return nativeResponseValue;
2465 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr: bigint): number {
2466 if(!isWasmInitialized) {
2467 throw new Error("initializeWasm() must be awaited first!");
2469 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr);
2470 return nativeResponseValue;
2473 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr: bigint): bigint {
2474 if(!isWasmInitialized) {
2475 throw new Error("initializeWasm() must be awaited first!");
2477 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr);
2478 return nativeResponseValue;
2480 // struct LDKTxOut CResult_TxOutAccessErrorZ_get_ok(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
2482 export function CResult_TxOutAccessErrorZ_get_ok(owner: bigint): bigint {
2483 if(!isWasmInitialized) {
2484 throw new Error("initializeWasm() must be awaited first!");
2486 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_ok(owner);
2487 return nativeResponseValue;
2489 // enum LDKAccessError CResult_TxOutAccessErrorZ_get_err(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
2491 export function CResult_TxOutAccessErrorZ_get_err(owner: bigint): AccessError {
2492 if(!isWasmInitialized) {
2493 throw new Error("initializeWasm() must be awaited first!");
2495 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_err(owner);
2496 return nativeResponseValue;
2498 // uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2500 export function C2Tuple_usizeTransactionZ_get_a(owner: bigint): number {
2501 if(!isWasmInitialized) {
2502 throw new Error("initializeWasm() must be awaited first!");
2504 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_a(owner);
2505 return nativeResponseValue;
2507 // struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2509 export function C2Tuple_usizeTransactionZ_get_b(owner: bigint): number {
2510 if(!isWasmInitialized) {
2511 throw new Error("initializeWasm() must be awaited first!");
2513 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_b(owner);
2514 return nativeResponseValue;
2517 export class LDKMonitorEvent {
2518 protected constructor() {}
2521 export function LDKMonitorEvent_ty_from_ptr(ptr: bigint): number {
2522 if(!isWasmInitialized) {
2523 throw new Error("initializeWasm() must be awaited first!");
2525 const nativeResponseValue = wasm.TS_LDKMonitorEvent_ty_from_ptr(ptr);
2526 return nativeResponseValue;
2529 export function LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr: bigint): bigint {
2530 if(!isWasmInitialized) {
2531 throw new Error("initializeWasm() must be awaited first!");
2533 const nativeResponseValue = wasm.TS_LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr);
2534 return nativeResponseValue;
2537 export function LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr: bigint): bigint {
2538 if(!isWasmInitialized) {
2539 throw new Error("initializeWasm() must be awaited first!");
2541 const nativeResponseValue = wasm.TS_LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr);
2542 return nativeResponseValue;
2545 export function LDKMonitorEvent_Completed_get_funding_txo(ptr: bigint): bigint {
2546 if(!isWasmInitialized) {
2547 throw new Error("initializeWasm() must be awaited first!");
2549 const nativeResponseValue = wasm.TS_LDKMonitorEvent_Completed_get_funding_txo(ptr);
2550 return nativeResponseValue;
2553 export function LDKMonitorEvent_Completed_get_monitor_update_id(ptr: bigint): bigint {
2554 if(!isWasmInitialized) {
2555 throw new Error("initializeWasm() must be awaited first!");
2557 const nativeResponseValue = wasm.TS_LDKMonitorEvent_Completed_get_monitor_update_id(ptr);
2558 return nativeResponseValue;
2561 export function LDKMonitorEvent_UpdateFailed_get_update_failed(ptr: bigint): bigint {
2562 if(!isWasmInitialized) {
2563 throw new Error("initializeWasm() must be awaited first!");
2565 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateFailed_get_update_failed(ptr);
2566 return nativeResponseValue;
2568 // struct LDKOutPoint C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2570 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner: bigint): bigint {
2571 if(!isWasmInitialized) {
2572 throw new Error("initializeWasm() must be awaited first!");
2574 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner);
2575 return nativeResponseValue;
2577 // struct LDKCVec_MonitorEventZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2579 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner: bigint): number {
2580 if(!isWasmInitialized) {
2581 throw new Error("initializeWasm() must be awaited first!");
2583 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner);
2584 return nativeResponseValue;
2586 // struct LDKPublicKey C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2588 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner: bigint): number {
2589 if(!isWasmInitialized) {
2590 throw new Error("initializeWasm() must be awaited first!");
2592 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner);
2593 return nativeResponseValue;
2595 // struct LDKFixedPenaltyScorer CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2597 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner: bigint): bigint {
2598 if(!isWasmInitialized) {
2599 throw new Error("initializeWasm() must be awaited first!");
2601 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner);
2602 return nativeResponseValue;
2604 // struct LDKDecodeError CResult_FixedPenaltyScorerDecodeErrorZ_get_err(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2606 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner: bigint): bigint {
2607 if(!isWasmInitialized) {
2608 throw new Error("initializeWasm() must be awaited first!");
2610 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner);
2611 return nativeResponseValue;
2613 // uint64_t C2Tuple_u64u64Z_get_a(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
2615 export function C2Tuple_u64u64Z_get_a(owner: bigint): bigint {
2616 if(!isWasmInitialized) {
2617 throw new Error("initializeWasm() must be awaited first!");
2619 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_a(owner);
2620 return nativeResponseValue;
2622 // uint64_t C2Tuple_u64u64Z_get_b(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
2624 export function C2Tuple_u64u64Z_get_b(owner: bigint): bigint {
2625 if(!isWasmInitialized) {
2626 throw new Error("initializeWasm() must be awaited first!");
2628 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_b(owner);
2629 return nativeResponseValue;
2632 export class LDKCOption_C2Tuple_u64u64ZZ {
2633 protected constructor() {}
2636 export function LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr: bigint): number {
2637 if(!isWasmInitialized) {
2638 throw new Error("initializeWasm() must be awaited first!");
2640 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr);
2641 return nativeResponseValue;
2644 export function LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr: bigint): bigint {
2645 if(!isWasmInitialized) {
2646 throw new Error("initializeWasm() must be awaited first!");
2648 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr);
2649 return nativeResponseValue;
2652 export interface LDKLogger {
2653 log (record: bigint): void;
2657 export function LDKLogger_new(impl: LDKLogger): [bigint, number] {
2658 if(!isWasmInitialized) {
2659 throw new Error("initializeWasm() must be awaited first!");
2661 var new_obj_idx = js_objs.length;
2662 for (var i = 0; i < js_objs.length; i++) {
2663 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2665 js_objs[i] = new WeakRef(impl);
2666 return [wasm.TS_LDKLogger_new(i), i];
2668 // struct LDKProbabilisticScorer CResult_ProbabilisticScorerDecodeErrorZ_get_ok(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2670 export function CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner: bigint): bigint {
2671 if(!isWasmInitialized) {
2672 throw new Error("initializeWasm() must be awaited first!");
2674 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner);
2675 return nativeResponseValue;
2677 // struct LDKDecodeError CResult_ProbabilisticScorerDecodeErrorZ_get_err(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2679 export function CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner: bigint): bigint {
2680 if(!isWasmInitialized) {
2681 throw new Error("initializeWasm() must be awaited first!");
2683 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner);
2684 return nativeResponseValue;
2686 // struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2688 export function CResult_InitFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2689 if(!isWasmInitialized) {
2690 throw new Error("initializeWasm() must be awaited first!");
2692 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_ok(owner);
2693 return nativeResponseValue;
2695 // struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2697 export function CResult_InitFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2698 if(!isWasmInitialized) {
2699 throw new Error("initializeWasm() must be awaited first!");
2701 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_err(owner);
2702 return nativeResponseValue;
2704 // struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2706 export function CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2707 if(!isWasmInitialized) {
2708 throw new Error("initializeWasm() must be awaited first!");
2710 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner);
2711 return nativeResponseValue;
2713 // struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2715 export function CResult_ChannelFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2716 if(!isWasmInitialized) {
2717 throw new Error("initializeWasm() must be awaited first!");
2719 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(owner);
2720 return nativeResponseValue;
2722 // struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2724 export function CResult_NodeFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2725 if(!isWasmInitialized) {
2726 throw new Error("initializeWasm() must be awaited first!");
2728 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(owner);
2729 return nativeResponseValue;
2731 // struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2733 export function CResult_NodeFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2734 if(!isWasmInitialized) {
2735 throw new Error("initializeWasm() must be awaited first!");
2737 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_err(owner);
2738 return nativeResponseValue;
2740 // struct LDKInvoiceFeatures CResult_InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2742 export function CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2743 if(!isWasmInitialized) {
2744 throw new Error("initializeWasm() must be awaited first!");
2746 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner);
2747 return nativeResponseValue;
2749 // struct LDKDecodeError CResult_InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2751 export function CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2752 if(!isWasmInitialized) {
2753 throw new Error("initializeWasm() must be awaited first!");
2755 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner);
2756 return nativeResponseValue;
2758 // struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2760 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2761 if(!isWasmInitialized) {
2762 throw new Error("initializeWasm() must be awaited first!");
2764 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner);
2765 return nativeResponseValue;
2767 // struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2769 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2770 if(!isWasmInitialized) {
2771 throw new Error("initializeWasm() must be awaited first!");
2773 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner);
2774 return nativeResponseValue;
2776 // struct LDKNodeId CResult_NodeIdDecodeErrorZ_get_ok(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2778 export function CResult_NodeIdDecodeErrorZ_get_ok(owner: bigint): bigint {
2779 if(!isWasmInitialized) {
2780 throw new Error("initializeWasm() must be awaited first!");
2782 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_ok(owner);
2783 return nativeResponseValue;
2785 // struct LDKDecodeError CResult_NodeIdDecodeErrorZ_get_err(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2787 export function CResult_NodeIdDecodeErrorZ_get_err(owner: bigint): bigint {
2788 if(!isWasmInitialized) {
2789 throw new Error("initializeWasm() must be awaited first!");
2791 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_err(owner);
2792 return nativeResponseValue;
2794 // struct LDKCOption_NetworkUpdateZ CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2796 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner: bigint): bigint {
2797 if(!isWasmInitialized) {
2798 throw new Error("initializeWasm() must be awaited first!");
2800 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner);
2801 return nativeResponseValue;
2803 // struct LDKDecodeError CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2805 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner: bigint): bigint {
2806 if(!isWasmInitialized) {
2807 throw new Error("initializeWasm() must be awaited first!");
2809 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner);
2810 return nativeResponseValue;
2813 export interface LDKAccess {
2814 get_utxo (genesis_hash: number, short_channel_id: bigint): bigint;
2818 export function LDKAccess_new(impl: LDKAccess): [bigint, number] {
2819 if(!isWasmInitialized) {
2820 throw new Error("initializeWasm() must be awaited first!");
2822 var new_obj_idx = js_objs.length;
2823 for (var i = 0; i < js_objs.length; i++) {
2824 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2826 js_objs[i] = new WeakRef(impl);
2827 return [wasm.TS_LDKAccess_new(i), i];
2829 // LDKCResult_TxOutAccessErrorZ Access_get_utxo LDKAccess *NONNULL_PTR this_arg, const uint8_t (*genesis_hash)[32], uint64_t short_channel_id
2831 export function Access_get_utxo(this_arg: bigint, genesis_hash: number, short_channel_id: bigint): bigint {
2832 if(!isWasmInitialized) {
2833 throw new Error("initializeWasm() must be awaited first!");
2835 const nativeResponseValue = wasm.TS_Access_get_utxo(this_arg, genesis_hash, short_channel_id);
2836 return nativeResponseValue;
2839 export class LDKCOption_AccessZ {
2840 protected constructor() {}
2843 export function LDKCOption_AccessZ_ty_from_ptr(ptr: bigint): number {
2844 if(!isWasmInitialized) {
2845 throw new Error("initializeWasm() must be awaited first!");
2847 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_ty_from_ptr(ptr);
2848 return nativeResponseValue;
2851 export function LDKCOption_AccessZ_Some_get_some(ptr: bigint): bigint {
2852 if(!isWasmInitialized) {
2853 throw new Error("initializeWasm() must be awaited first!");
2855 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_Some_get_some(ptr);
2856 return nativeResponseValue;
2858 // bool CResult_boolLightningErrorZ_get_ok(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
2860 export function CResult_boolLightningErrorZ_get_ok(owner: bigint): boolean {
2861 if(!isWasmInitialized) {
2862 throw new Error("initializeWasm() must be awaited first!");
2864 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_ok(owner);
2865 return nativeResponseValue;
2867 // struct LDKLightningError CResult_boolLightningErrorZ_get_err(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
2869 export function CResult_boolLightningErrorZ_get_err(owner: bigint): bigint {
2870 if(!isWasmInitialized) {
2871 throw new Error("initializeWasm() must be awaited first!");
2873 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_err(owner);
2874 return nativeResponseValue;
2876 // struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2878 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner: bigint): bigint {
2879 if(!isWasmInitialized) {
2880 throw new Error("initializeWasm() must be awaited first!");
2882 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner);
2883 return nativeResponseValue;
2885 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2887 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner: bigint): bigint {
2888 if(!isWasmInitialized) {
2889 throw new Error("initializeWasm() must be awaited first!");
2891 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner);
2892 return nativeResponseValue;
2894 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2896 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner: bigint): bigint {
2897 if(!isWasmInitialized) {
2898 throw new Error("initializeWasm() must be awaited first!");
2900 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner);
2901 return nativeResponseValue;
2904 export class LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
2905 protected constructor() {}
2908 export function LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_ty_from_ptr(ptr: bigint): number {
2909 if(!isWasmInitialized) {
2910 throw new Error("initializeWasm() must be awaited first!");
2912 const nativeResponseValue = wasm.TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_ty_from_ptr(ptr);
2913 return nativeResponseValue;
2916 export function LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_get_some(ptr: bigint): bigint {
2917 if(!isWasmInitialized) {
2918 throw new Error("initializeWasm() must be awaited first!");
2920 const nativeResponseValue = wasm.TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_get_some(ptr);
2921 return nativeResponseValue;
2923 // void CResult_NoneLightningErrorZ_get_ok(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
2925 export function CResult_NoneLightningErrorZ_get_ok(owner: bigint): void {
2926 if(!isWasmInitialized) {
2927 throw new Error("initializeWasm() must be awaited first!");
2929 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_ok(owner);
2930 // debug statements here
2932 // struct LDKLightningError CResult_NoneLightningErrorZ_get_err(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
2934 export function CResult_NoneLightningErrorZ_get_err(owner: bigint): bigint {
2935 if(!isWasmInitialized) {
2936 throw new Error("initializeWasm() must be awaited first!");
2938 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_err(owner);
2939 return nativeResponseValue;
2941 // struct LDKChannelUpdateInfo CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
2943 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
2944 if(!isWasmInitialized) {
2945 throw new Error("initializeWasm() must be awaited first!");
2947 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner);
2948 return nativeResponseValue;
2950 // struct LDKDecodeError CResult_ChannelUpdateInfoDecodeErrorZ_get_err(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
2952 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner: bigint): bigint {
2953 if(!isWasmInitialized) {
2954 throw new Error("initializeWasm() must be awaited first!");
2956 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner);
2957 return nativeResponseValue;
2959 // struct LDKChannelInfo CResult_ChannelInfoDecodeErrorZ_get_ok(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
2961 export function CResult_ChannelInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
2962 if(!isWasmInitialized) {
2963 throw new Error("initializeWasm() must be awaited first!");
2965 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_ok(owner);
2966 return nativeResponseValue;
2968 // struct LDKDecodeError CResult_ChannelInfoDecodeErrorZ_get_err(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
2970 export function CResult_ChannelInfoDecodeErrorZ_get_err(owner: bigint): bigint {
2971 if(!isWasmInitialized) {
2972 throw new Error("initializeWasm() must be awaited first!");
2974 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_err(owner);
2975 return nativeResponseValue;
2977 // struct LDKRoutingFees CResult_RoutingFeesDecodeErrorZ_get_ok(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
2979 export function CResult_RoutingFeesDecodeErrorZ_get_ok(owner: bigint): bigint {
2980 if(!isWasmInitialized) {
2981 throw new Error("initializeWasm() must be awaited first!");
2983 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_ok(owner);
2984 return nativeResponseValue;
2986 // struct LDKDecodeError CResult_RoutingFeesDecodeErrorZ_get_err(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
2988 export function CResult_RoutingFeesDecodeErrorZ_get_err(owner: bigint): bigint {
2989 if(!isWasmInitialized) {
2990 throw new Error("initializeWasm() must be awaited first!");
2992 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_err(owner);
2993 return nativeResponseValue;
2996 export class LDKNetAddress {
2997 protected constructor() {}
3000 export function LDKNetAddress_ty_from_ptr(ptr: bigint): number {
3001 if(!isWasmInitialized) {
3002 throw new Error("initializeWasm() must be awaited first!");
3004 const nativeResponseValue = wasm.TS_LDKNetAddress_ty_from_ptr(ptr);
3005 return nativeResponseValue;
3008 export function LDKNetAddress_IPv4_get_addr(ptr: bigint): number {
3009 if(!isWasmInitialized) {
3010 throw new Error("initializeWasm() must be awaited first!");
3012 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_addr(ptr);
3013 return nativeResponseValue;
3016 export function LDKNetAddress_IPv4_get_port(ptr: bigint): number {
3017 if(!isWasmInitialized) {
3018 throw new Error("initializeWasm() must be awaited first!");
3020 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_port(ptr);
3021 return nativeResponseValue;
3024 export function LDKNetAddress_IPv6_get_addr(ptr: bigint): number {
3025 if(!isWasmInitialized) {
3026 throw new Error("initializeWasm() must be awaited first!");
3028 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_addr(ptr);
3029 return nativeResponseValue;
3032 export function LDKNetAddress_IPv6_get_port(ptr: bigint): number {
3033 if(!isWasmInitialized) {
3034 throw new Error("initializeWasm() must be awaited first!");
3036 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_port(ptr);
3037 return nativeResponseValue;
3040 export function LDKNetAddress_OnionV2_get_onion_v2(ptr: bigint): number {
3041 if(!isWasmInitialized) {
3042 throw new Error("initializeWasm() must be awaited first!");
3044 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV2_get_onion_v2(ptr);
3045 return nativeResponseValue;
3048 export function LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr: bigint): number {
3049 if(!isWasmInitialized) {
3050 throw new Error("initializeWasm() must be awaited first!");
3052 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr);
3053 return nativeResponseValue;
3056 export function LDKNetAddress_OnionV3_get_checksum(ptr: bigint): number {
3057 if(!isWasmInitialized) {
3058 throw new Error("initializeWasm() must be awaited first!");
3060 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_checksum(ptr);
3061 return nativeResponseValue;
3064 export function LDKNetAddress_OnionV3_get_version(ptr: bigint): number {
3065 if(!isWasmInitialized) {
3066 throw new Error("initializeWasm() must be awaited first!");
3068 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_version(ptr);
3069 return nativeResponseValue;
3072 export function LDKNetAddress_OnionV3_get_port(ptr: bigint): number {
3073 if(!isWasmInitialized) {
3074 throw new Error("initializeWasm() must be awaited first!");
3076 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_port(ptr);
3077 return nativeResponseValue;
3080 export function LDKNetAddress_Hostname_get_hostname(ptr: bigint): bigint {
3081 if(!isWasmInitialized) {
3082 throw new Error("initializeWasm() must be awaited first!");
3084 const nativeResponseValue = wasm.TS_LDKNetAddress_Hostname_get_hostname(ptr);
3085 return nativeResponseValue;
3088 export function LDKNetAddress_Hostname_get_port(ptr: bigint): number {
3089 if(!isWasmInitialized) {
3090 throw new Error("initializeWasm() must be awaited first!");
3092 const nativeResponseValue = wasm.TS_LDKNetAddress_Hostname_get_port(ptr);
3093 return nativeResponseValue;
3095 // struct LDKNodeAnnouncementInfo CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
3097 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
3098 if(!isWasmInitialized) {
3099 throw new Error("initializeWasm() must be awaited first!");
3101 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner);
3102 return nativeResponseValue;
3104 // struct LDKDecodeError CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
3106 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner: bigint): bigint {
3107 if(!isWasmInitialized) {
3108 throw new Error("initializeWasm() must be awaited first!");
3110 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner);
3111 return nativeResponseValue;
3113 // struct LDKNodeAlias CResult_NodeAliasDecodeErrorZ_get_ok(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
3115 export function CResult_NodeAliasDecodeErrorZ_get_ok(owner: bigint): bigint {
3116 if(!isWasmInitialized) {
3117 throw new Error("initializeWasm() must be awaited first!");
3119 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_ok(owner);
3120 return nativeResponseValue;
3122 // struct LDKDecodeError CResult_NodeAliasDecodeErrorZ_get_err(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
3124 export function CResult_NodeAliasDecodeErrorZ_get_err(owner: bigint): bigint {
3125 if(!isWasmInitialized) {
3126 throw new Error("initializeWasm() must be awaited first!");
3128 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_err(owner);
3129 return nativeResponseValue;
3131 // struct LDKNodeInfo CResult_NodeInfoDecodeErrorZ_get_ok(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
3133 export function CResult_NodeInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
3134 if(!isWasmInitialized) {
3135 throw new Error("initializeWasm() must be awaited first!");
3137 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_ok(owner);
3138 return nativeResponseValue;
3140 // struct LDKDecodeError CResult_NodeInfoDecodeErrorZ_get_err(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
3142 export function CResult_NodeInfoDecodeErrorZ_get_err(owner: bigint): bigint {
3143 if(!isWasmInitialized) {
3144 throw new Error("initializeWasm() must be awaited first!");
3146 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_err(owner);
3147 return nativeResponseValue;
3149 // struct LDKNetworkGraph CResult_NetworkGraphDecodeErrorZ_get_ok(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
3151 export function CResult_NetworkGraphDecodeErrorZ_get_ok(owner: bigint): bigint {
3152 if(!isWasmInitialized) {
3153 throw new Error("initializeWasm() must be awaited first!");
3155 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_ok(owner);
3156 return nativeResponseValue;
3158 // struct LDKDecodeError CResult_NetworkGraphDecodeErrorZ_get_err(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
3160 export function CResult_NetworkGraphDecodeErrorZ_get_err(owner: bigint): bigint {
3161 if(!isWasmInitialized) {
3162 throw new Error("initializeWasm() must be awaited first!");
3164 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_err(owner);
3165 return nativeResponseValue;
3168 export class LDKCOption_CVec_NetAddressZZ {
3169 protected constructor() {}
3172 export function LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr: bigint): number {
3173 if(!isWasmInitialized) {
3174 throw new Error("initializeWasm() must be awaited first!");
3176 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr);
3177 return nativeResponseValue;
3180 export function LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr: bigint): number {
3181 if(!isWasmInitialized) {
3182 throw new Error("initializeWasm() must be awaited first!");
3184 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr);
3185 return nativeResponseValue;
3187 // struct LDKDelayedPaymentOutputDescriptor CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3189 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
3190 if(!isWasmInitialized) {
3191 throw new Error("initializeWasm() must be awaited first!");
3193 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
3194 return nativeResponseValue;
3196 // struct LDKDecodeError CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3198 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
3199 if(!isWasmInitialized) {
3200 throw new Error("initializeWasm() must be awaited first!");
3202 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
3203 return nativeResponseValue;
3205 // struct LDKStaticPaymentOutputDescriptor CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3207 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
3208 if(!isWasmInitialized) {
3209 throw new Error("initializeWasm() must be awaited first!");
3211 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
3212 return nativeResponseValue;
3214 // struct LDKDecodeError CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3216 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
3217 if(!isWasmInitialized) {
3218 throw new Error("initializeWasm() must be awaited first!");
3220 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
3221 return nativeResponseValue;
3223 // struct LDKSpendableOutputDescriptor CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3225 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
3226 if(!isWasmInitialized) {
3227 throw new Error("initializeWasm() must be awaited first!");
3229 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner);
3230 return nativeResponseValue;
3232 // struct LDKDecodeError CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3234 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
3235 if(!isWasmInitialized) {
3236 throw new Error("initializeWasm() must be awaited first!");
3238 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner);
3239 return nativeResponseValue;
3241 // struct LDKSignature C2Tuple_SignatureCVec_SignatureZZ_get_a(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
3243 export function C2Tuple_SignatureCVec_SignatureZZ_get_a(owner: bigint): number {
3244 if(!isWasmInitialized) {
3245 throw new Error("initializeWasm() must be awaited first!");
3247 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_a(owner);
3248 return nativeResponseValue;
3250 // struct LDKCVec_SignatureZ C2Tuple_SignatureCVec_SignatureZZ_get_b(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
3252 export function C2Tuple_SignatureCVec_SignatureZZ_get_b(owner: bigint): number {
3253 if(!isWasmInitialized) {
3254 throw new Error("initializeWasm() must be awaited first!");
3256 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_b(owner);
3257 return nativeResponseValue;
3259 // struct LDKC2Tuple_SignatureCVec_SignatureZZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
3261 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner: bigint): bigint {
3262 if(!isWasmInitialized) {
3263 throw new Error("initializeWasm() must be awaited first!");
3265 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner);
3266 return nativeResponseValue;
3268 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
3270 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner: bigint): void {
3271 if(!isWasmInitialized) {
3272 throw new Error("initializeWasm() must be awaited first!");
3274 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner);
3275 // debug statements here
3277 // struct LDKSignature CResult_SignatureNoneZ_get_ok(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
3279 export function CResult_SignatureNoneZ_get_ok(owner: bigint): number {
3280 if(!isWasmInitialized) {
3281 throw new Error("initializeWasm() must be awaited first!");
3283 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_ok(owner);
3284 return nativeResponseValue;
3286 // void CResult_SignatureNoneZ_get_err(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
3288 export function CResult_SignatureNoneZ_get_err(owner: bigint): void {
3289 if(!isWasmInitialized) {
3290 throw new Error("initializeWasm() must be awaited first!");
3292 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_err(owner);
3293 // debug statements here
3295 // struct LDKSignature C2Tuple_SignatureSignatureZ_get_a(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner);
3297 export function C2Tuple_SignatureSignatureZ_get_a(owner: bigint): number {
3298 if(!isWasmInitialized) {
3299 throw new Error("initializeWasm() must be awaited first!");
3301 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_get_a(owner);
3302 return nativeResponseValue;
3304 // struct LDKSignature C2Tuple_SignatureSignatureZ_get_b(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner);
3306 export function C2Tuple_SignatureSignatureZ_get_b(owner: bigint): number {
3307 if(!isWasmInitialized) {
3308 throw new Error("initializeWasm() must be awaited first!");
3310 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_get_b(owner);
3311 return nativeResponseValue;
3313 // struct LDKC2Tuple_SignatureSignatureZ CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner);
3315 export function CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner: bigint): bigint {
3316 if(!isWasmInitialized) {
3317 throw new Error("initializeWasm() must be awaited first!");
3319 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner);
3320 return nativeResponseValue;
3322 // void CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner);
3324 export function CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner: bigint): void {
3325 if(!isWasmInitialized) {
3326 throw new Error("initializeWasm() must be awaited first!");
3328 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner);
3329 // debug statements here
3331 // struct LDKSecretKey CResult_SecretKeyNoneZ_get_ok(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner);
3333 export function CResult_SecretKeyNoneZ_get_ok(owner: bigint): number {
3334 if(!isWasmInitialized) {
3335 throw new Error("initializeWasm() must be awaited first!");
3337 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_get_ok(owner);
3338 return nativeResponseValue;
3340 // void CResult_SecretKeyNoneZ_get_err(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner);
3342 export function CResult_SecretKeyNoneZ_get_err(owner: bigint): void {
3343 if(!isWasmInitialized) {
3344 throw new Error("initializeWasm() must be awaited first!");
3346 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_get_err(owner);
3347 // debug statements here
3349 // struct LDKPublicKey CResult_PublicKeyNoneZ_get_ok(LDKCResult_PublicKeyNoneZ *NONNULL_PTR owner);
3351 export function CResult_PublicKeyNoneZ_get_ok(owner: bigint): number {
3352 if(!isWasmInitialized) {
3353 throw new Error("initializeWasm() must be awaited first!");
3355 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_get_ok(owner);
3356 return nativeResponseValue;
3358 // void CResult_PublicKeyNoneZ_get_err(LDKCResult_PublicKeyNoneZ *NONNULL_PTR owner);
3360 export function CResult_PublicKeyNoneZ_get_err(owner: bigint): void {
3361 if(!isWasmInitialized) {
3362 throw new Error("initializeWasm() must be awaited first!");
3364 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_get_err(owner);
3365 // debug statements here
3368 export class LDKCOption_ScalarZ {
3369 protected constructor() {}
3372 export function LDKCOption_ScalarZ_ty_from_ptr(ptr: bigint): number {
3373 if(!isWasmInitialized) {
3374 throw new Error("initializeWasm() must be awaited first!");
3376 const nativeResponseValue = wasm.TS_LDKCOption_ScalarZ_ty_from_ptr(ptr);
3377 return nativeResponseValue;
3380 export function LDKCOption_ScalarZ_Some_get_some(ptr: bigint): bigint {
3381 if(!isWasmInitialized) {
3382 throw new Error("initializeWasm() must be awaited first!");
3384 const nativeResponseValue = wasm.TS_LDKCOption_ScalarZ_Some_get_some(ptr);
3385 return nativeResponseValue;
3387 // struct LDKThirtyTwoBytes CResult_SharedSecretNoneZ_get_ok(LDKCResult_SharedSecretNoneZ *NONNULL_PTR owner);
3389 export function CResult_SharedSecretNoneZ_get_ok(owner: bigint): number {
3390 if(!isWasmInitialized) {
3391 throw new Error("initializeWasm() must be awaited first!");
3393 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_get_ok(owner);
3394 return nativeResponseValue;
3396 // void CResult_SharedSecretNoneZ_get_err(LDKCResult_SharedSecretNoneZ *NONNULL_PTR owner);
3398 export function CResult_SharedSecretNoneZ_get_err(owner: bigint): void {
3399 if(!isWasmInitialized) {
3400 throw new Error("initializeWasm() must be awaited first!");
3402 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_get_err(owner);
3403 // debug statements here
3406 export interface LDKBaseSign {
3407 get_per_commitment_point (idx: bigint): number;
3408 release_commitment_secret (idx: bigint): number;
3409 validate_holder_commitment (holder_tx: bigint, preimages: number): bigint;
3410 channel_keys_id (): number;
3411 sign_counterparty_commitment (commitment_tx: bigint, preimages: number): bigint;
3412 validate_counterparty_revocation (idx: bigint, secret: number): bigint;
3413 sign_holder_commitment_and_htlcs (commitment_tx: bigint): bigint;
3414 sign_justice_revoked_output (justice_tx: number, input: number, amount: bigint, per_commitment_key: number): bigint;
3415 sign_justice_revoked_htlc (justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: bigint): bigint;
3416 sign_counterparty_htlc_transaction (htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: bigint): bigint;
3417 sign_closing_transaction (closing_tx: bigint): bigint;
3418 sign_holder_anchor_input (anchor_tx: number, input: number): bigint;
3419 sign_channel_announcement (msg: bigint): bigint;
3420 ready_channel (channel_parameters: bigint): void;
3424 export function LDKBaseSign_new(impl: LDKBaseSign, pubkeys: bigint): [bigint, number] {
3425 if(!isWasmInitialized) {
3426 throw new Error("initializeWasm() must be awaited first!");
3428 var new_obj_idx = js_objs.length;
3429 for (var i = 0; i < js_objs.length; i++) {
3430 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3432 js_objs[i] = new WeakRef(impl);
3433 return [wasm.TS_LDKBaseSign_new(i, pubkeys), i];
3435 // LDKPublicKey BaseSign_get_per_commitment_point LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
3437 export function BaseSign_get_per_commitment_point(this_arg: bigint, idx: bigint): number {
3438 if(!isWasmInitialized) {
3439 throw new Error("initializeWasm() must be awaited first!");
3441 const nativeResponseValue = wasm.TS_BaseSign_get_per_commitment_point(this_arg, idx);
3442 return nativeResponseValue;
3444 // LDKThirtyTwoBytes BaseSign_release_commitment_secret LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
3446 export function BaseSign_release_commitment_secret(this_arg: bigint, idx: bigint): number {
3447 if(!isWasmInitialized) {
3448 throw new Error("initializeWasm() must be awaited first!");
3450 const nativeResponseValue = wasm.TS_BaseSign_release_commitment_secret(this_arg, idx);
3451 return nativeResponseValue;
3453 // LDKCResult_NoneNoneZ BaseSign_validate_holder_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_PaymentPreimageZ preimages
3455 export function BaseSign_validate_holder_commitment(this_arg: bigint, holder_tx: bigint, preimages: number): bigint {
3456 if(!isWasmInitialized) {
3457 throw new Error("initializeWasm() must be awaited first!");
3459 const nativeResponseValue = wasm.TS_BaseSign_validate_holder_commitment(this_arg, holder_tx, preimages);
3460 return nativeResponseValue;
3462 // LDKThirtyTwoBytes BaseSign_channel_keys_id LDKBaseSign *NONNULL_PTR this_arg
3464 export function BaseSign_channel_keys_id(this_arg: bigint): number {
3465 if(!isWasmInitialized) {
3466 throw new Error("initializeWasm() must be awaited first!");
3468 const nativeResponseValue = wasm.TS_BaseSign_channel_keys_id(this_arg);
3469 return nativeResponseValue;
3471 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_counterparty_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_PaymentPreimageZ preimages
3473 export function BaseSign_sign_counterparty_commitment(this_arg: bigint, commitment_tx: bigint, preimages: number): bigint {
3474 if(!isWasmInitialized) {
3475 throw new Error("initializeWasm() must be awaited first!");
3477 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_commitment(this_arg, commitment_tx, preimages);
3478 return nativeResponseValue;
3480 // LDKCResult_NoneNoneZ BaseSign_validate_counterparty_revocation LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx, const uint8_t (*secret)[32]
3482 export function BaseSign_validate_counterparty_revocation(this_arg: bigint, idx: bigint, secret: number): bigint {
3483 if(!isWasmInitialized) {
3484 throw new Error("initializeWasm() must be awaited first!");
3486 const nativeResponseValue = wasm.TS_BaseSign_validate_counterparty_revocation(this_arg, idx, secret);
3487 return nativeResponseValue;
3489 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_holder_commitment_and_htlcs LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx
3491 export function BaseSign_sign_holder_commitment_and_htlcs(this_arg: bigint, commitment_tx: bigint): bigint {
3492 if(!isWasmInitialized) {
3493 throw new Error("initializeWasm() must be awaited first!");
3495 const nativeResponseValue = wasm.TS_BaseSign_sign_holder_commitment_and_htlcs(this_arg, commitment_tx);
3496 return nativeResponseValue;
3498 // 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]
3500 export function BaseSign_sign_justice_revoked_output(this_arg: bigint, justice_tx: number, input: number, amount: bigint, per_commitment_key: number): bigint {
3501 if(!isWasmInitialized) {
3502 throw new Error("initializeWasm() must be awaited first!");
3504 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_output(this_arg, justice_tx, input, amount, per_commitment_key);
3505 return nativeResponseValue;
3507 // 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
3509 export function BaseSign_sign_justice_revoked_htlc(this_arg: bigint, justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: bigint): bigint {
3510 if(!isWasmInitialized) {
3511 throw new Error("initializeWasm() must be awaited first!");
3513 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_htlc(this_arg, justice_tx, input, amount, per_commitment_key, htlc);
3514 return nativeResponseValue;
3516 // 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
3518 export function BaseSign_sign_counterparty_htlc_transaction(this_arg: bigint, htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: bigint): bigint {
3519 if(!isWasmInitialized) {
3520 throw new Error("initializeWasm() must be awaited first!");
3522 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_htlc_transaction(this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
3523 return nativeResponseValue;
3525 // LDKCResult_SignatureNoneZ BaseSign_sign_closing_transaction LDKBaseSign *NONNULL_PTR this_arg, const struct LDKClosingTransaction *NONNULL_PTR closing_tx
3527 export function BaseSign_sign_closing_transaction(this_arg: bigint, closing_tx: bigint): bigint {
3528 if(!isWasmInitialized) {
3529 throw new Error("initializeWasm() must be awaited first!");
3531 const nativeResponseValue = wasm.TS_BaseSign_sign_closing_transaction(this_arg, closing_tx);
3532 return nativeResponseValue;
3534 // LDKCResult_SignatureNoneZ BaseSign_sign_holder_anchor_input LDKBaseSign *NONNULL_PTR this_arg, struct LDKTransaction anchor_tx, uintptr_t input
3536 export function BaseSign_sign_holder_anchor_input(this_arg: bigint, anchor_tx: number, input: number): bigint {
3537 if(!isWasmInitialized) {
3538 throw new Error("initializeWasm() must be awaited first!");
3540 const nativeResponseValue = wasm.TS_BaseSign_sign_holder_anchor_input(this_arg, anchor_tx, input);
3541 return nativeResponseValue;
3543 // LDKCResult_C2Tuple_SignatureSignatureZNoneZ BaseSign_sign_channel_announcement LDKBaseSign *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg
3545 export function BaseSign_sign_channel_announcement(this_arg: bigint, msg: bigint): bigint {
3546 if(!isWasmInitialized) {
3547 throw new Error("initializeWasm() must be awaited first!");
3549 const nativeResponseValue = wasm.TS_BaseSign_sign_channel_announcement(this_arg, msg);
3550 return nativeResponseValue;
3552 // void BaseSign_ready_channel LDKBaseSign *NONNULL_PTR this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters
3554 export function BaseSign_ready_channel(this_arg: bigint, channel_parameters: bigint): void {
3555 if(!isWasmInitialized) {
3556 throw new Error("initializeWasm() must be awaited first!");
3558 const nativeResponseValue = wasm.TS_BaseSign_ready_channel(this_arg, channel_parameters);
3559 // debug statements here
3561 // LDKChannelPublicKeys BaseSign_get_pubkeys LDKBaseSign *NONNULL_PTR this_arg
3563 export function BaseSign_get_pubkeys(this_arg: bigint): bigint {
3564 if(!isWasmInitialized) {
3565 throw new Error("initializeWasm() must be awaited first!");
3567 const nativeResponseValue = wasm.TS_BaseSign_get_pubkeys(this_arg);
3568 return nativeResponseValue;
3571 export interface LDKSign {
3576 export function LDKSign_new(impl: LDKSign, BaseSign: number, pubkeys: bigint): [bigint, number] {
3577 if(!isWasmInitialized) {
3578 throw new Error("initializeWasm() must be awaited first!");
3580 var new_obj_idx = js_objs.length;
3581 for (var i = 0; i < js_objs.length; i++) {
3582 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3584 js_objs[i] = new WeakRef(impl);
3585 return [wasm.TS_LDKSign_new(i, BaseSign, pubkeys), i];
3587 // LDKCVec_u8Z Sign_write LDKSign *NONNULL_PTR this_arg
3589 export function Sign_write(this_arg: bigint): number {
3590 if(!isWasmInitialized) {
3591 throw new Error("initializeWasm() must be awaited first!");
3593 const nativeResponseValue = wasm.TS_Sign_write(this_arg);
3594 return nativeResponseValue;
3596 // struct LDKSign CResult_SignDecodeErrorZ_get_ok(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
3598 export function CResult_SignDecodeErrorZ_get_ok(owner: bigint): bigint {
3599 if(!isWasmInitialized) {
3600 throw new Error("initializeWasm() must be awaited first!");
3602 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_ok(owner);
3603 return nativeResponseValue;
3605 // struct LDKDecodeError CResult_SignDecodeErrorZ_get_err(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
3607 export function CResult_SignDecodeErrorZ_get_err(owner: bigint): bigint {
3608 if(!isWasmInitialized) {
3609 throw new Error("initializeWasm() must be awaited first!");
3611 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_err(owner);
3612 return nativeResponseValue;
3614 // struct LDKRecoverableSignature CResult_RecoverableSignatureNoneZ_get_ok(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
3616 export function CResult_RecoverableSignatureNoneZ_get_ok(owner: bigint): number {
3617 if(!isWasmInitialized) {
3618 throw new Error("initializeWasm() must be awaited first!");
3620 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_ok(owner);
3621 return nativeResponseValue;
3623 // void CResult_RecoverableSignatureNoneZ_get_err(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
3625 export function CResult_RecoverableSignatureNoneZ_get_err(owner: bigint): void {
3626 if(!isWasmInitialized) {
3627 throw new Error("initializeWasm() must be awaited first!");
3629 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_err(owner);
3630 // debug statements here
3632 // struct LDKCVec_CVec_u8ZZ CResult_CVec_CVec_u8ZZNoneZ_get_ok(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
3634 export function CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner: bigint): number {
3635 if(!isWasmInitialized) {
3636 throw new Error("initializeWasm() must be awaited first!");
3638 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner);
3639 return nativeResponseValue;
3641 // void CResult_CVec_CVec_u8ZZNoneZ_get_err(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
3643 export function CResult_CVec_CVec_u8ZZNoneZ_get_err(owner: bigint): void {
3644 if(!isWasmInitialized) {
3645 throw new Error("initializeWasm() must be awaited first!");
3647 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_err(owner);
3648 // debug statements here
3650 // struct LDKInMemorySigner CResult_InMemorySignerDecodeErrorZ_get_ok(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
3652 export function CResult_InMemorySignerDecodeErrorZ_get_ok(owner: bigint): bigint {
3653 if(!isWasmInitialized) {
3654 throw new Error("initializeWasm() must be awaited first!");
3656 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_ok(owner);
3657 return nativeResponseValue;
3659 // struct LDKDecodeError CResult_InMemorySignerDecodeErrorZ_get_err(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
3661 export function CResult_InMemorySignerDecodeErrorZ_get_err(owner: bigint): bigint {
3662 if(!isWasmInitialized) {
3663 throw new Error("initializeWasm() must be awaited first!");
3665 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_err(owner);
3666 return nativeResponseValue;
3668 // struct LDKTransaction CResult_TransactionNoneZ_get_ok(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
3670 export function CResult_TransactionNoneZ_get_ok(owner: bigint): number {
3671 if(!isWasmInitialized) {
3672 throw new Error("initializeWasm() must be awaited first!");
3674 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_ok(owner);
3675 return nativeResponseValue;
3677 // void CResult_TransactionNoneZ_get_err(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
3679 export function CResult_TransactionNoneZ_get_err(owner: bigint): void {
3680 if(!isWasmInitialized) {
3681 throw new Error("initializeWasm() must be awaited first!");
3683 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_err(owner);
3684 // debug statements here
3687 export class LDKCOption_u16Z {
3688 protected constructor() {}
3691 export function LDKCOption_u16Z_ty_from_ptr(ptr: bigint): number {
3692 if(!isWasmInitialized) {
3693 throw new Error("initializeWasm() must be awaited first!");
3695 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_ty_from_ptr(ptr);
3696 return nativeResponseValue;
3699 export function LDKCOption_u16Z_Some_get_some(ptr: bigint): number {
3700 if(!isWasmInitialized) {
3701 throw new Error("initializeWasm() must be awaited first!");
3703 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_Some_get_some(ptr);
3704 return nativeResponseValue;
3707 export class LDKAPIError {
3708 protected constructor() {}
3711 export function LDKAPIError_ty_from_ptr(ptr: bigint): number {
3712 if(!isWasmInitialized) {
3713 throw new Error("initializeWasm() must be awaited first!");
3715 const nativeResponseValue = wasm.TS_LDKAPIError_ty_from_ptr(ptr);
3716 return nativeResponseValue;
3719 export function LDKAPIError_APIMisuseError_get_err(ptr: bigint): number {
3720 if(!isWasmInitialized) {
3721 throw new Error("initializeWasm() must be awaited first!");
3723 const nativeResponseValue = wasm.TS_LDKAPIError_APIMisuseError_get_err(ptr);
3724 return nativeResponseValue;
3727 export function LDKAPIError_FeeRateTooHigh_get_err(ptr: bigint): number {
3728 if(!isWasmInitialized) {
3729 throw new Error("initializeWasm() must be awaited first!");
3731 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_err(ptr);
3732 return nativeResponseValue;
3735 export function LDKAPIError_FeeRateTooHigh_get_feerate(ptr: bigint): number {
3736 if(!isWasmInitialized) {
3737 throw new Error("initializeWasm() must be awaited first!");
3739 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_feerate(ptr);
3740 return nativeResponseValue;
3743 export function LDKAPIError_RouteError_get_err(ptr: bigint): number {
3744 if(!isWasmInitialized) {
3745 throw new Error("initializeWasm() must be awaited first!");
3747 const nativeResponseValue = wasm.TS_LDKAPIError_RouteError_get_err(ptr);
3748 return nativeResponseValue;
3751 export function LDKAPIError_ChannelUnavailable_get_err(ptr: bigint): number {
3752 if(!isWasmInitialized) {
3753 throw new Error("initializeWasm() must be awaited first!");
3755 const nativeResponseValue = wasm.TS_LDKAPIError_ChannelUnavailable_get_err(ptr);
3756 return nativeResponseValue;
3759 export function LDKAPIError_IncompatibleShutdownScript_get_script(ptr: bigint): bigint {
3760 if(!isWasmInitialized) {
3761 throw new Error("initializeWasm() must be awaited first!");
3763 const nativeResponseValue = wasm.TS_LDKAPIError_IncompatibleShutdownScript_get_script(ptr);
3764 return nativeResponseValue;
3766 // void CResult_NoneAPIErrorZ_get_ok(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
3768 export function CResult_NoneAPIErrorZ_get_ok(owner: bigint): void {
3769 if(!isWasmInitialized) {
3770 throw new Error("initializeWasm() must be awaited first!");
3772 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_ok(owner);
3773 // debug statements here
3775 // struct LDKAPIError CResult_NoneAPIErrorZ_get_err(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
3777 export function CResult_NoneAPIErrorZ_get_err(owner: bigint): bigint {
3778 if(!isWasmInitialized) {
3779 throw new Error("initializeWasm() must be awaited first!");
3781 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_err(owner);
3782 return nativeResponseValue;
3784 // struct LDKThirtyTwoBytes CResult__u832APIErrorZ_get_ok(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
3786 export function CResult__u832APIErrorZ_get_ok(owner: bigint): number {
3787 if(!isWasmInitialized) {
3788 throw new Error("initializeWasm() must be awaited first!");
3790 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_ok(owner);
3791 return nativeResponseValue;
3793 // struct LDKAPIError CResult__u832APIErrorZ_get_err(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
3795 export function CResult__u832APIErrorZ_get_err(owner: bigint): bigint {
3796 if(!isWasmInitialized) {
3797 throw new Error("initializeWasm() must be awaited first!");
3799 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_err(owner);
3800 return nativeResponseValue;
3803 export class LDKPaymentSendFailure {
3804 protected constructor() {}
3807 export function LDKPaymentSendFailure_ty_from_ptr(ptr: bigint): number {
3808 if(!isWasmInitialized) {
3809 throw new Error("initializeWasm() must be awaited first!");
3811 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ty_from_ptr(ptr);
3812 return nativeResponseValue;
3815 export function LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr: bigint): bigint {
3816 if(!isWasmInitialized) {
3817 throw new Error("initializeWasm() must be awaited first!");
3819 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr);
3820 return nativeResponseValue;
3823 export function LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr: bigint): number {
3824 if(!isWasmInitialized) {
3825 throw new Error("initializeWasm() must be awaited first!");
3827 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr);
3828 return nativeResponseValue;
3831 export function LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr: bigint): number {
3832 if(!isWasmInitialized) {
3833 throw new Error("initializeWasm() must be awaited first!");
3835 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr);
3836 return nativeResponseValue;
3839 export function LDKPaymentSendFailure_PartialFailure_get_results(ptr: bigint): number {
3840 if(!isWasmInitialized) {
3841 throw new Error("initializeWasm() must be awaited first!");
3843 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_results(ptr);
3844 return nativeResponseValue;
3847 export function LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr: bigint): bigint {
3848 if(!isWasmInitialized) {
3849 throw new Error("initializeWasm() must be awaited first!");
3851 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr);
3852 return nativeResponseValue;
3855 export function LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr: bigint): number {
3856 if(!isWasmInitialized) {
3857 throw new Error("initializeWasm() must be awaited first!");
3859 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr);
3860 return nativeResponseValue;
3862 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentSendFailureZ_get_ok(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
3864 export function CResult_PaymentIdPaymentSendFailureZ_get_ok(owner: bigint): number {
3865 if(!isWasmInitialized) {
3866 throw new Error("initializeWasm() must be awaited first!");
3868 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_ok(owner);
3869 return nativeResponseValue;
3871 // struct LDKPaymentSendFailure CResult_PaymentIdPaymentSendFailureZ_get_err(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
3873 export function CResult_PaymentIdPaymentSendFailureZ_get_err(owner: bigint): bigint {
3874 if(!isWasmInitialized) {
3875 throw new Error("initializeWasm() must be awaited first!");
3877 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_err(owner);
3878 return nativeResponseValue;
3880 // void CResult_NonePaymentSendFailureZ_get_ok(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
3882 export function CResult_NonePaymentSendFailureZ_get_ok(owner: bigint): void {
3883 if(!isWasmInitialized) {
3884 throw new Error("initializeWasm() must be awaited first!");
3886 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_ok(owner);
3887 // debug statements here
3889 // struct LDKPaymentSendFailure CResult_NonePaymentSendFailureZ_get_err(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
3891 export function CResult_NonePaymentSendFailureZ_get_err(owner: bigint): bigint {
3892 if(!isWasmInitialized) {
3893 throw new Error("initializeWasm() must be awaited first!");
3895 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_err(owner);
3896 return nativeResponseValue;
3898 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_a(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
3900 export function C2Tuple_PaymentHashPaymentIdZ_get_a(owner: bigint): number {
3901 if(!isWasmInitialized) {
3902 throw new Error("initializeWasm() must be awaited first!");
3904 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_a(owner);
3905 return nativeResponseValue;
3907 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_b(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
3909 export function C2Tuple_PaymentHashPaymentIdZ_get_b(owner: bigint): number {
3910 if(!isWasmInitialized) {
3911 throw new Error("initializeWasm() must be awaited first!");
3913 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_b(owner);
3914 return nativeResponseValue;
3916 // struct LDKC2Tuple_PaymentHashPaymentIdZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
3918 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner: bigint): bigint {
3919 if(!isWasmInitialized) {
3920 throw new Error("initializeWasm() must be awaited first!");
3922 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner);
3923 return nativeResponseValue;
3925 // struct LDKPaymentSendFailure CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
3927 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner: bigint): bigint {
3928 if(!isWasmInitialized) {
3929 throw new Error("initializeWasm() must be awaited first!");
3931 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner);
3932 return nativeResponseValue;
3934 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_a(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
3936 export function C2Tuple_PaymentHashPaymentSecretZ_get_a(owner: bigint): number {
3937 if(!isWasmInitialized) {
3938 throw new Error("initializeWasm() must be awaited first!");
3940 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_a(owner);
3941 return nativeResponseValue;
3943 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_b(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
3945 export function C2Tuple_PaymentHashPaymentSecretZ_get_b(owner: bigint): number {
3946 if(!isWasmInitialized) {
3947 throw new Error("initializeWasm() must be awaited first!");
3949 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_b(owner);
3950 return nativeResponseValue;
3952 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
3954 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner: bigint): bigint {
3955 if(!isWasmInitialized) {
3956 throw new Error("initializeWasm() must be awaited first!");
3958 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner);
3959 return nativeResponseValue;
3961 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
3963 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner: bigint): void {
3964 if(!isWasmInitialized) {
3965 throw new Error("initializeWasm() must be awaited first!");
3967 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner);
3968 // debug statements here
3970 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
3972 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner: bigint): bigint {
3973 if(!isWasmInitialized) {
3974 throw new Error("initializeWasm() must be awaited first!");
3976 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner);
3977 return nativeResponseValue;
3979 // struct LDKAPIError CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
3981 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner: bigint): bigint {
3982 if(!isWasmInitialized) {
3983 throw new Error("initializeWasm() must be awaited first!");
3985 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner);
3986 return nativeResponseValue;
3988 // struct LDKThirtyTwoBytes CResult_PaymentSecretNoneZ_get_ok(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
3990 export function CResult_PaymentSecretNoneZ_get_ok(owner: bigint): number {
3991 if(!isWasmInitialized) {
3992 throw new Error("initializeWasm() must be awaited first!");
3994 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_ok(owner);
3995 return nativeResponseValue;
3997 // void CResult_PaymentSecretNoneZ_get_err(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
3999 export function CResult_PaymentSecretNoneZ_get_err(owner: bigint): void {
4000 if(!isWasmInitialized) {
4001 throw new Error("initializeWasm() must be awaited first!");
4003 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_err(owner);
4004 // debug statements here
4006 // struct LDKThirtyTwoBytes CResult_PaymentSecretAPIErrorZ_get_ok(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
4008 export function CResult_PaymentSecretAPIErrorZ_get_ok(owner: bigint): number {
4009 if(!isWasmInitialized) {
4010 throw new Error("initializeWasm() must be awaited first!");
4012 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_ok(owner);
4013 return nativeResponseValue;
4015 // struct LDKAPIError CResult_PaymentSecretAPIErrorZ_get_err(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
4017 export function CResult_PaymentSecretAPIErrorZ_get_err(owner: bigint): bigint {
4018 if(!isWasmInitialized) {
4019 throw new Error("initializeWasm() must be awaited first!");
4021 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_err(owner);
4022 return nativeResponseValue;
4024 // struct LDKThirtyTwoBytes CResult_PaymentPreimageAPIErrorZ_get_ok(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
4026 export function CResult_PaymentPreimageAPIErrorZ_get_ok(owner: bigint): number {
4027 if(!isWasmInitialized) {
4028 throw new Error("initializeWasm() must be awaited first!");
4030 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_ok(owner);
4031 return nativeResponseValue;
4033 // struct LDKAPIError CResult_PaymentPreimageAPIErrorZ_get_err(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
4035 export function CResult_PaymentPreimageAPIErrorZ_get_err(owner: bigint): bigint {
4036 if(!isWasmInitialized) {
4037 throw new Error("initializeWasm() must be awaited first!");
4039 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_err(owner);
4040 return nativeResponseValue;
4042 // struct LDKCounterpartyForwardingInfo CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
4044 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
4045 if(!isWasmInitialized) {
4046 throw new Error("initializeWasm() must be awaited first!");
4048 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner);
4049 return nativeResponseValue;
4051 // struct LDKDecodeError CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
4053 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner: bigint): bigint {
4054 if(!isWasmInitialized) {
4055 throw new Error("initializeWasm() must be awaited first!");
4057 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner);
4058 return nativeResponseValue;
4060 // struct LDKChannelCounterparty CResult_ChannelCounterpartyDecodeErrorZ_get_ok(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
4062 export function CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner: bigint): bigint {
4063 if(!isWasmInitialized) {
4064 throw new Error("initializeWasm() must be awaited first!");
4066 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner);
4067 return nativeResponseValue;
4069 // struct LDKDecodeError CResult_ChannelCounterpartyDecodeErrorZ_get_err(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
4071 export function CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner: bigint): bigint {
4072 if(!isWasmInitialized) {
4073 throw new Error("initializeWasm() must be awaited first!");
4075 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner);
4076 return nativeResponseValue;
4078 // struct LDKChannelDetails CResult_ChannelDetailsDecodeErrorZ_get_ok(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
4080 export function CResult_ChannelDetailsDecodeErrorZ_get_ok(owner: bigint): bigint {
4081 if(!isWasmInitialized) {
4082 throw new Error("initializeWasm() must be awaited first!");
4084 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_ok(owner);
4085 return nativeResponseValue;
4087 // struct LDKDecodeError CResult_ChannelDetailsDecodeErrorZ_get_err(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
4089 export function CResult_ChannelDetailsDecodeErrorZ_get_err(owner: bigint): bigint {
4090 if(!isWasmInitialized) {
4091 throw new Error("initializeWasm() must be awaited first!");
4093 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_err(owner);
4094 return nativeResponseValue;
4096 // struct LDKPhantomRouteHints CResult_PhantomRouteHintsDecodeErrorZ_get_ok(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
4098 export function CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner: bigint): bigint {
4099 if(!isWasmInitialized) {
4100 throw new Error("initializeWasm() must be awaited first!");
4102 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner);
4103 return nativeResponseValue;
4105 // struct LDKDecodeError CResult_PhantomRouteHintsDecodeErrorZ_get_err(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
4107 export function CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner: bigint): bigint {
4108 if(!isWasmInitialized) {
4109 throw new Error("initializeWasm() must be awaited first!");
4111 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner);
4112 return nativeResponseValue;
4115 export interface LDKWatch {
4116 watch_channel (funding_txo: bigint, monitor: bigint): ChannelMonitorUpdateStatus;
4117 update_channel (funding_txo: bigint, update: bigint): ChannelMonitorUpdateStatus;
4118 release_pending_monitor_events (): number;
4122 export function LDKWatch_new(impl: LDKWatch): [bigint, number] {
4123 if(!isWasmInitialized) {
4124 throw new Error("initializeWasm() must be awaited first!");
4126 var new_obj_idx = js_objs.length;
4127 for (var i = 0; i < js_objs.length; i++) {
4128 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4130 js_objs[i] = new WeakRef(impl);
4131 return [wasm.TS_LDKWatch_new(i), i];
4133 // LDKChannelMonitorUpdateStatus Watch_watch_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor
4135 export function Watch_watch_channel(this_arg: bigint, funding_txo: bigint, monitor: bigint): ChannelMonitorUpdateStatus {
4136 if(!isWasmInitialized) {
4137 throw new Error("initializeWasm() must be awaited first!");
4139 const nativeResponseValue = wasm.TS_Watch_watch_channel(this_arg, funding_txo, monitor);
4140 return nativeResponseValue;
4142 // LDKChannelMonitorUpdateStatus Watch_update_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update
4144 export function Watch_update_channel(this_arg: bigint, funding_txo: bigint, update: bigint): ChannelMonitorUpdateStatus {
4145 if(!isWasmInitialized) {
4146 throw new Error("initializeWasm() must be awaited first!");
4148 const nativeResponseValue = wasm.TS_Watch_update_channel(this_arg, funding_txo, update);
4149 return nativeResponseValue;
4151 // LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Watch_release_pending_monitor_events LDKWatch *NONNULL_PTR this_arg
4153 export function Watch_release_pending_monitor_events(this_arg: bigint): number {
4154 if(!isWasmInitialized) {
4155 throw new Error("initializeWasm() must be awaited first!");
4157 const nativeResponseValue = wasm.TS_Watch_release_pending_monitor_events(this_arg);
4158 return nativeResponseValue;
4161 export interface LDKBroadcasterInterface {
4162 broadcast_transaction (tx: number): void;
4166 export function LDKBroadcasterInterface_new(impl: LDKBroadcasterInterface): [bigint, number] {
4167 if(!isWasmInitialized) {
4168 throw new Error("initializeWasm() must be awaited first!");
4170 var new_obj_idx = js_objs.length;
4171 for (var i = 0; i < js_objs.length; i++) {
4172 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4174 js_objs[i] = new WeakRef(impl);
4175 return [wasm.TS_LDKBroadcasterInterface_new(i), i];
4177 // void BroadcasterInterface_broadcast_transaction LDKBroadcasterInterface *NONNULL_PTR this_arg, struct LDKTransaction tx
4179 export function BroadcasterInterface_broadcast_transaction(this_arg: bigint, tx: number): void {
4180 if(!isWasmInitialized) {
4181 throw new Error("initializeWasm() must be awaited first!");
4183 const nativeResponseValue = wasm.TS_BroadcasterInterface_broadcast_transaction(this_arg, tx);
4184 // debug statements here
4187 export interface LDKKeysInterface {
4188 get_node_secret (recipient: Recipient): bigint;
4189 get_node_id (recipient: Recipient): bigint;
4190 ecdh (recipient: Recipient, other_key: number, tweak: bigint): bigint;
4191 get_destination_script (): number;
4192 get_shutdown_scriptpubkey (): bigint;
4193 get_channel_signer (inbound: boolean, channel_value_satoshis: bigint): bigint;
4194 get_secure_random_bytes (): number;
4195 read_chan_signer (reader: number): bigint;
4196 sign_invoice (hrp_bytes: number, invoice_data: number, receipient: Recipient): bigint;
4197 get_inbound_payment_key_material (): number;
4201 export function LDKKeysInterface_new(impl: LDKKeysInterface): [bigint, number] {
4202 if(!isWasmInitialized) {
4203 throw new Error("initializeWasm() must be awaited first!");
4205 var new_obj_idx = js_objs.length;
4206 for (var i = 0; i < js_objs.length; i++) {
4207 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4209 js_objs[i] = new WeakRef(impl);
4210 return [wasm.TS_LDKKeysInterface_new(i), i];
4212 // LDKCResult_SecretKeyNoneZ KeysInterface_get_node_secret LDKKeysInterface *NONNULL_PTR this_arg, enum LDKRecipient recipient
4214 export function KeysInterface_get_node_secret(this_arg: bigint, recipient: Recipient): bigint {
4215 if(!isWasmInitialized) {
4216 throw new Error("initializeWasm() must be awaited first!");
4218 const nativeResponseValue = wasm.TS_KeysInterface_get_node_secret(this_arg, recipient);
4219 return nativeResponseValue;
4221 // LDKCResult_PublicKeyNoneZ KeysInterface_get_node_id LDKKeysInterface *NONNULL_PTR this_arg, enum LDKRecipient recipient
4223 export function KeysInterface_get_node_id(this_arg: bigint, recipient: Recipient): bigint {
4224 if(!isWasmInitialized) {
4225 throw new Error("initializeWasm() must be awaited first!");
4227 const nativeResponseValue = wasm.TS_KeysInterface_get_node_id(this_arg, recipient);
4228 return nativeResponseValue;
4230 // LDKCResult_SharedSecretNoneZ KeysInterface_ecdh LDKKeysInterface *NONNULL_PTR this_arg, enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_ScalarZ tweak
4232 export function KeysInterface_ecdh(this_arg: bigint, recipient: Recipient, other_key: number, tweak: bigint): bigint {
4233 if(!isWasmInitialized) {
4234 throw new Error("initializeWasm() must be awaited first!");
4236 const nativeResponseValue = wasm.TS_KeysInterface_ecdh(this_arg, recipient, other_key, tweak);
4237 return nativeResponseValue;
4239 // LDKCVec_u8Z KeysInterface_get_destination_script LDKKeysInterface *NONNULL_PTR this_arg
4241 export function KeysInterface_get_destination_script(this_arg: bigint): number {
4242 if(!isWasmInitialized) {
4243 throw new Error("initializeWasm() must be awaited first!");
4245 const nativeResponseValue = wasm.TS_KeysInterface_get_destination_script(this_arg);
4246 return nativeResponseValue;
4248 // LDKShutdownScript KeysInterface_get_shutdown_scriptpubkey LDKKeysInterface *NONNULL_PTR this_arg
4250 export function KeysInterface_get_shutdown_scriptpubkey(this_arg: bigint): bigint {
4251 if(!isWasmInitialized) {
4252 throw new Error("initializeWasm() must be awaited first!");
4254 const nativeResponseValue = wasm.TS_KeysInterface_get_shutdown_scriptpubkey(this_arg);
4255 return nativeResponseValue;
4257 // LDKSign KeysInterface_get_channel_signer LDKKeysInterface *NONNULL_PTR this_arg, bool inbound, uint64_t channel_value_satoshis
4259 export function KeysInterface_get_channel_signer(this_arg: bigint, inbound: boolean, channel_value_satoshis: bigint): bigint {
4260 if(!isWasmInitialized) {
4261 throw new Error("initializeWasm() must be awaited first!");
4263 const nativeResponseValue = wasm.TS_KeysInterface_get_channel_signer(this_arg, inbound, channel_value_satoshis);
4264 return nativeResponseValue;
4266 // LDKThirtyTwoBytes KeysInterface_get_secure_random_bytes LDKKeysInterface *NONNULL_PTR this_arg
4268 export function KeysInterface_get_secure_random_bytes(this_arg: bigint): number {
4269 if(!isWasmInitialized) {
4270 throw new Error("initializeWasm() must be awaited first!");
4272 const nativeResponseValue = wasm.TS_KeysInterface_get_secure_random_bytes(this_arg);
4273 return nativeResponseValue;
4275 // LDKCResult_SignDecodeErrorZ KeysInterface_read_chan_signer LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice reader
4277 export function KeysInterface_read_chan_signer(this_arg: bigint, reader: number): bigint {
4278 if(!isWasmInitialized) {
4279 throw new Error("initializeWasm() must be awaited first!");
4281 const nativeResponseValue = wasm.TS_KeysInterface_read_chan_signer(this_arg, reader);
4282 return nativeResponseValue;
4284 // LDKCResult_RecoverableSignatureNoneZ KeysInterface_sign_invoice LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z invoice_data, enum LDKRecipient receipient
4286 export function KeysInterface_sign_invoice(this_arg: bigint, hrp_bytes: number, invoice_data: number, receipient: Recipient): bigint {
4287 if(!isWasmInitialized) {
4288 throw new Error("initializeWasm() must be awaited first!");
4290 const nativeResponseValue = wasm.TS_KeysInterface_sign_invoice(this_arg, hrp_bytes, invoice_data, receipient);
4291 return nativeResponseValue;
4293 // LDKThirtyTwoBytes KeysInterface_get_inbound_payment_key_material LDKKeysInterface *NONNULL_PTR this_arg
4295 export function KeysInterface_get_inbound_payment_key_material(this_arg: bigint): number {
4296 if(!isWasmInitialized) {
4297 throw new Error("initializeWasm() must be awaited first!");
4299 const nativeResponseValue = wasm.TS_KeysInterface_get_inbound_payment_key_material(this_arg);
4300 return nativeResponseValue;
4303 export interface LDKFeeEstimator {
4304 get_est_sat_per_1000_weight (confirmation_target: ConfirmationTarget): number;
4308 export function LDKFeeEstimator_new(impl: LDKFeeEstimator): [bigint, number] {
4309 if(!isWasmInitialized) {
4310 throw new Error("initializeWasm() must be awaited first!");
4312 var new_obj_idx = js_objs.length;
4313 for (var i = 0; i < js_objs.length; i++) {
4314 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4316 js_objs[i] = new WeakRef(impl);
4317 return [wasm.TS_LDKFeeEstimator_new(i), i];
4319 // uint32_t FeeEstimator_get_est_sat_per_1000_weight LDKFeeEstimator *NONNULL_PTR this_arg, enum LDKConfirmationTarget confirmation_target
4321 export function FeeEstimator_get_est_sat_per_1000_weight(this_arg: bigint, confirmation_target: ConfirmationTarget): number {
4322 if(!isWasmInitialized) {
4323 throw new Error("initializeWasm() must be awaited first!");
4325 const nativeResponseValue = wasm.TS_FeeEstimator_get_est_sat_per_1000_weight(this_arg, confirmation_target);
4326 return nativeResponseValue;
4328 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelManagerZ_get_a(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
4330 export function C2Tuple_BlockHashChannelManagerZ_get_a(owner: bigint): number {
4331 if(!isWasmInitialized) {
4332 throw new Error("initializeWasm() must be awaited first!");
4334 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_a(owner);
4335 return nativeResponseValue;
4337 // struct LDKChannelManager C2Tuple_BlockHashChannelManagerZ_get_b(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
4339 export function C2Tuple_BlockHashChannelManagerZ_get_b(owner: bigint): bigint {
4340 if(!isWasmInitialized) {
4341 throw new Error("initializeWasm() must be awaited first!");
4343 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_b(owner);
4344 return nativeResponseValue;
4346 // struct LDKC2Tuple_BlockHashChannelManagerZ *CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
4348 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner: bigint): bigint {
4349 if(!isWasmInitialized) {
4350 throw new Error("initializeWasm() must be awaited first!");
4352 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner);
4353 return nativeResponseValue;
4355 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
4357 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner: bigint): bigint {
4358 if(!isWasmInitialized) {
4359 throw new Error("initializeWasm() must be awaited first!");
4361 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner);
4362 return nativeResponseValue;
4364 // struct LDKChannelConfig CResult_ChannelConfigDecodeErrorZ_get_ok(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
4366 export function CResult_ChannelConfigDecodeErrorZ_get_ok(owner: bigint): bigint {
4367 if(!isWasmInitialized) {
4368 throw new Error("initializeWasm() must be awaited first!");
4370 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_ok(owner);
4371 return nativeResponseValue;
4373 // struct LDKDecodeError CResult_ChannelConfigDecodeErrorZ_get_err(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
4375 export function CResult_ChannelConfigDecodeErrorZ_get_err(owner: bigint): bigint {
4376 if(!isWasmInitialized) {
4377 throw new Error("initializeWasm() must be awaited first!");
4379 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_err(owner);
4380 return nativeResponseValue;
4382 // struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
4384 export function CResult_OutPointDecodeErrorZ_get_ok(owner: bigint): bigint {
4385 if(!isWasmInitialized) {
4386 throw new Error("initializeWasm() must be awaited first!");
4388 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_ok(owner);
4389 return nativeResponseValue;
4391 // struct LDKDecodeError CResult_OutPointDecodeErrorZ_get_err(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
4393 export function CResult_OutPointDecodeErrorZ_get_err(owner: bigint): bigint {
4394 if(!isWasmInitialized) {
4395 throw new Error("initializeWasm() must be awaited first!");
4397 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_err(owner);
4398 return nativeResponseValue;
4401 export interface LDKType {
4403 debug_str (): number;
4408 export function LDKType_new(impl: LDKType): [bigint, number] {
4409 if(!isWasmInitialized) {
4410 throw new Error("initializeWasm() must be awaited first!");
4412 var new_obj_idx = js_objs.length;
4413 for (var i = 0; i < js_objs.length; i++) {
4414 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4416 js_objs[i] = new WeakRef(impl);
4417 return [wasm.TS_LDKType_new(i), i];
4419 // uint16_t Type_type_id LDKType *NONNULL_PTR this_arg
4421 export function Type_type_id(this_arg: bigint): number {
4422 if(!isWasmInitialized) {
4423 throw new Error("initializeWasm() must be awaited first!");
4425 const nativeResponseValue = wasm.TS_Type_type_id(this_arg);
4426 return nativeResponseValue;
4428 // LDKStr Type_debug_str LDKType *NONNULL_PTR this_arg
4430 export function Type_debug_str(this_arg: bigint): number {
4431 if(!isWasmInitialized) {
4432 throw new Error("initializeWasm() must be awaited first!");
4434 const nativeResponseValue = wasm.TS_Type_debug_str(this_arg);
4435 return nativeResponseValue;
4437 // LDKCVec_u8Z Type_write LDKType *NONNULL_PTR this_arg
4439 export function Type_write(this_arg: bigint): number {
4440 if(!isWasmInitialized) {
4441 throw new Error("initializeWasm() must be awaited first!");
4443 const nativeResponseValue = wasm.TS_Type_write(this_arg);
4444 return nativeResponseValue;
4447 export class LDKCOption_TypeZ {
4448 protected constructor() {}
4451 export function LDKCOption_TypeZ_ty_from_ptr(ptr: bigint): number {
4452 if(!isWasmInitialized) {
4453 throw new Error("initializeWasm() must be awaited first!");
4455 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_ty_from_ptr(ptr);
4456 return nativeResponseValue;
4459 export function LDKCOption_TypeZ_Some_get_some(ptr: bigint): bigint {
4460 if(!isWasmInitialized) {
4461 throw new Error("initializeWasm() must be awaited first!");
4463 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_Some_get_some(ptr);
4464 return nativeResponseValue;
4466 // struct LDKCOption_TypeZ CResult_COption_TypeZDecodeErrorZ_get_ok(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
4468 export function CResult_COption_TypeZDecodeErrorZ_get_ok(owner: bigint): bigint {
4469 if(!isWasmInitialized) {
4470 throw new Error("initializeWasm() must be awaited first!");
4472 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_ok(owner);
4473 return nativeResponseValue;
4475 // struct LDKDecodeError CResult_COption_TypeZDecodeErrorZ_get_err(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
4477 export function CResult_COption_TypeZDecodeErrorZ_get_err(owner: bigint): bigint {
4478 if(!isWasmInitialized) {
4479 throw new Error("initializeWasm() must be awaited first!");
4481 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_err(owner);
4482 return nativeResponseValue;
4485 export class LDKPaymentError {
4486 protected constructor() {}
4489 export function LDKPaymentError_ty_from_ptr(ptr: bigint): number {
4490 if(!isWasmInitialized) {
4491 throw new Error("initializeWasm() must be awaited first!");
4493 const nativeResponseValue = wasm.TS_LDKPaymentError_ty_from_ptr(ptr);
4494 return nativeResponseValue;
4497 export function LDKPaymentError_Invoice_get_invoice(ptr: bigint): number {
4498 if(!isWasmInitialized) {
4499 throw new Error("initializeWasm() must be awaited first!");
4501 const nativeResponseValue = wasm.TS_LDKPaymentError_Invoice_get_invoice(ptr);
4502 return nativeResponseValue;
4505 export function LDKPaymentError_Routing_get_routing(ptr: bigint): bigint {
4506 if(!isWasmInitialized) {
4507 throw new Error("initializeWasm() must be awaited first!");
4509 const nativeResponseValue = wasm.TS_LDKPaymentError_Routing_get_routing(ptr);
4510 return nativeResponseValue;
4513 export function LDKPaymentError_Sending_get_sending(ptr: bigint): bigint {
4514 if(!isWasmInitialized) {
4515 throw new Error("initializeWasm() must be awaited first!");
4517 const nativeResponseValue = wasm.TS_LDKPaymentError_Sending_get_sending(ptr);
4518 return nativeResponseValue;
4520 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentErrorZ_get_ok(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
4522 export function CResult_PaymentIdPaymentErrorZ_get_ok(owner: bigint): number {
4523 if(!isWasmInitialized) {
4524 throw new Error("initializeWasm() must be awaited first!");
4526 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_ok(owner);
4527 return nativeResponseValue;
4529 // struct LDKPaymentError CResult_PaymentIdPaymentErrorZ_get_err(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
4531 export function CResult_PaymentIdPaymentErrorZ_get_err(owner: bigint): bigint {
4532 if(!isWasmInitialized) {
4533 throw new Error("initializeWasm() must be awaited first!");
4535 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_err(owner);
4536 return nativeResponseValue;
4538 // struct LDKInFlightHtlcs CResult_InFlightHtlcsDecodeErrorZ_get_ok(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner);
4540 export function CResult_InFlightHtlcsDecodeErrorZ_get_ok(owner: bigint): bigint {
4541 if(!isWasmInitialized) {
4542 throw new Error("initializeWasm() must be awaited first!");
4544 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_get_ok(owner);
4545 return nativeResponseValue;
4547 // struct LDKDecodeError CResult_InFlightHtlcsDecodeErrorZ_get_err(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner);
4549 export function CResult_InFlightHtlcsDecodeErrorZ_get_err(owner: bigint): bigint {
4550 if(!isWasmInitialized) {
4551 throw new Error("initializeWasm() must be awaited first!");
4553 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_get_err(owner);
4554 return nativeResponseValue;
4557 export class LDKParseError {
4558 protected constructor() {}
4561 export function LDKParseError_ty_from_ptr(ptr: bigint): number {
4562 if(!isWasmInitialized) {
4563 throw new Error("initializeWasm() must be awaited first!");
4565 const nativeResponseValue = wasm.TS_LDKParseError_ty_from_ptr(ptr);
4566 return nativeResponseValue;
4569 export function LDKParseError_Bech32Error_get_bech32_error(ptr: bigint): bigint {
4570 if(!isWasmInitialized) {
4571 throw new Error("initializeWasm() must be awaited first!");
4573 const nativeResponseValue = wasm.TS_LDKParseError_Bech32Error_get_bech32_error(ptr);
4574 return nativeResponseValue;
4577 export function LDKParseError_ParseAmountError_get_parse_amount_error(ptr: bigint): number {
4578 if(!isWasmInitialized) {
4579 throw new Error("initializeWasm() must be awaited first!");
4581 const nativeResponseValue = wasm.TS_LDKParseError_ParseAmountError_get_parse_amount_error(ptr);
4582 return nativeResponseValue;
4585 export function LDKParseError_MalformedSignature_get_malformed_signature(ptr: bigint): Secp256k1Error {
4586 if(!isWasmInitialized) {
4587 throw new Error("initializeWasm() must be awaited first!");
4589 const nativeResponseValue = wasm.TS_LDKParseError_MalformedSignature_get_malformed_signature(ptr);
4590 return nativeResponseValue;
4593 export function LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr: bigint): number {
4594 if(!isWasmInitialized) {
4595 throw new Error("initializeWasm() must be awaited first!");
4597 const nativeResponseValue = wasm.TS_LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr);
4598 return nativeResponseValue;
4601 export function LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr: bigint): number {
4602 if(!isWasmInitialized) {
4603 throw new Error("initializeWasm() must be awaited first!");
4605 const nativeResponseValue = wasm.TS_LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr);
4606 return nativeResponseValue;
4608 // enum LDKSiPrefix CResult_SiPrefixParseErrorZ_get_ok(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
4610 export function CResult_SiPrefixParseErrorZ_get_ok(owner: bigint): SiPrefix {
4611 if(!isWasmInitialized) {
4612 throw new Error("initializeWasm() must be awaited first!");
4614 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_ok(owner);
4615 return nativeResponseValue;
4617 // struct LDKParseError CResult_SiPrefixParseErrorZ_get_err(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
4619 export function CResult_SiPrefixParseErrorZ_get_err(owner: bigint): bigint {
4620 if(!isWasmInitialized) {
4621 throw new Error("initializeWasm() must be awaited first!");
4623 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_err(owner);
4624 return nativeResponseValue;
4627 export class LDKParseOrSemanticError {
4628 protected constructor() {}
4631 export function LDKParseOrSemanticError_ty_from_ptr(ptr: bigint): number {
4632 if(!isWasmInitialized) {
4633 throw new Error("initializeWasm() must be awaited first!");
4635 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ty_from_ptr(ptr);
4636 return nativeResponseValue;
4639 export function LDKParseOrSemanticError_ParseError_get_parse_error(ptr: bigint): bigint {
4640 if(!isWasmInitialized) {
4641 throw new Error("initializeWasm() must be awaited first!");
4643 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ParseError_get_parse_error(ptr);
4644 return nativeResponseValue;
4647 export function LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr: bigint): SemanticError {
4648 if(!isWasmInitialized) {
4649 throw new Error("initializeWasm() must be awaited first!");
4651 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr);
4652 return nativeResponseValue;
4654 // struct LDKInvoice CResult_InvoiceParseOrSemanticErrorZ_get_ok(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
4656 export function CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner: bigint): bigint {
4657 if(!isWasmInitialized) {
4658 throw new Error("initializeWasm() must be awaited first!");
4660 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner);
4661 return nativeResponseValue;
4663 // struct LDKParseOrSemanticError CResult_InvoiceParseOrSemanticErrorZ_get_err(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
4665 export function CResult_InvoiceParseOrSemanticErrorZ_get_err(owner: bigint): bigint {
4666 if(!isWasmInitialized) {
4667 throw new Error("initializeWasm() must be awaited first!");
4669 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_err(owner);
4670 return nativeResponseValue;
4672 // struct LDKSignedRawInvoice CResult_SignedRawInvoiceParseErrorZ_get_ok(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
4674 export function CResult_SignedRawInvoiceParseErrorZ_get_ok(owner: bigint): bigint {
4675 if(!isWasmInitialized) {
4676 throw new Error("initializeWasm() must be awaited first!");
4678 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_ok(owner);
4679 return nativeResponseValue;
4681 // struct LDKParseError CResult_SignedRawInvoiceParseErrorZ_get_err(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
4683 export function CResult_SignedRawInvoiceParseErrorZ_get_err(owner: bigint): bigint {
4684 if(!isWasmInitialized) {
4685 throw new Error("initializeWasm() must be awaited first!");
4687 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_err(owner);
4688 return nativeResponseValue;
4690 // struct LDKRawInvoice C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
4692 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner: bigint): bigint {
4693 if(!isWasmInitialized) {
4694 throw new Error("initializeWasm() must be awaited first!");
4696 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner);
4697 return nativeResponseValue;
4699 // struct LDKThirtyTwoBytes C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
4701 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner: bigint): number {
4702 if(!isWasmInitialized) {
4703 throw new Error("initializeWasm() must be awaited first!");
4705 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner);
4706 return nativeResponseValue;
4708 // struct LDKInvoiceSignature C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
4710 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner: bigint): bigint {
4711 if(!isWasmInitialized) {
4712 throw new Error("initializeWasm() must be awaited first!");
4714 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner);
4715 return nativeResponseValue;
4717 // struct LDKPayeePubKey CResult_PayeePubKeyErrorZ_get_ok(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
4719 export function CResult_PayeePubKeyErrorZ_get_ok(owner: bigint): bigint {
4720 if(!isWasmInitialized) {
4721 throw new Error("initializeWasm() must be awaited first!");
4723 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_ok(owner);
4724 return nativeResponseValue;
4726 // enum LDKSecp256k1Error CResult_PayeePubKeyErrorZ_get_err(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
4728 export function CResult_PayeePubKeyErrorZ_get_err(owner: bigint): Secp256k1Error {
4729 if(!isWasmInitialized) {
4730 throw new Error("initializeWasm() must be awaited first!");
4732 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_err(owner);
4733 return nativeResponseValue;
4735 // struct LDKPositiveTimestamp CResult_PositiveTimestampCreationErrorZ_get_ok(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
4737 export function CResult_PositiveTimestampCreationErrorZ_get_ok(owner: bigint): bigint {
4738 if(!isWasmInitialized) {
4739 throw new Error("initializeWasm() must be awaited first!");
4741 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_ok(owner);
4742 return nativeResponseValue;
4744 // enum LDKCreationError CResult_PositiveTimestampCreationErrorZ_get_err(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
4746 export function CResult_PositiveTimestampCreationErrorZ_get_err(owner: bigint): CreationError {
4747 if(!isWasmInitialized) {
4748 throw new Error("initializeWasm() must be awaited first!");
4750 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_err(owner);
4751 return nativeResponseValue;
4753 // void CResult_NoneSemanticErrorZ_get_ok(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
4755 export function CResult_NoneSemanticErrorZ_get_ok(owner: bigint): void {
4756 if(!isWasmInitialized) {
4757 throw new Error("initializeWasm() must be awaited first!");
4759 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_ok(owner);
4760 // debug statements here
4762 // enum LDKSemanticError CResult_NoneSemanticErrorZ_get_err(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
4764 export function CResult_NoneSemanticErrorZ_get_err(owner: bigint): SemanticError {
4765 if(!isWasmInitialized) {
4766 throw new Error("initializeWasm() must be awaited first!");
4768 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_err(owner);
4769 return nativeResponseValue;
4771 // struct LDKInvoice CResult_InvoiceSemanticErrorZ_get_ok(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
4773 export function CResult_InvoiceSemanticErrorZ_get_ok(owner: bigint): bigint {
4774 if(!isWasmInitialized) {
4775 throw new Error("initializeWasm() must be awaited first!");
4777 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_ok(owner);
4778 return nativeResponseValue;
4780 // enum LDKSemanticError CResult_InvoiceSemanticErrorZ_get_err(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
4782 export function CResult_InvoiceSemanticErrorZ_get_err(owner: bigint): SemanticError {
4783 if(!isWasmInitialized) {
4784 throw new Error("initializeWasm() must be awaited first!");
4786 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_err(owner);
4787 return nativeResponseValue;
4789 // struct LDKDescription CResult_DescriptionCreationErrorZ_get_ok(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
4791 export function CResult_DescriptionCreationErrorZ_get_ok(owner: bigint): bigint {
4792 if(!isWasmInitialized) {
4793 throw new Error("initializeWasm() must be awaited first!");
4795 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_ok(owner);
4796 return nativeResponseValue;
4798 // enum LDKCreationError CResult_DescriptionCreationErrorZ_get_err(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
4800 export function CResult_DescriptionCreationErrorZ_get_err(owner: bigint): CreationError {
4801 if(!isWasmInitialized) {
4802 throw new Error("initializeWasm() must be awaited first!");
4804 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_err(owner);
4805 return nativeResponseValue;
4807 // struct LDKPrivateRoute CResult_PrivateRouteCreationErrorZ_get_ok(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
4809 export function CResult_PrivateRouteCreationErrorZ_get_ok(owner: bigint): bigint {
4810 if(!isWasmInitialized) {
4811 throw new Error("initializeWasm() must be awaited first!");
4813 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_ok(owner);
4814 return nativeResponseValue;
4816 // enum LDKCreationError CResult_PrivateRouteCreationErrorZ_get_err(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
4818 export function CResult_PrivateRouteCreationErrorZ_get_err(owner: bigint): CreationError {
4819 if(!isWasmInitialized) {
4820 throw new Error("initializeWasm() must be awaited first!");
4822 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_err(owner);
4823 return nativeResponseValue;
4825 // struct LDKStr CResult_StringErrorZ_get_ok(LDKCResult_StringErrorZ *NONNULL_PTR owner);
4827 export function CResult_StringErrorZ_get_ok(owner: bigint): number {
4828 if(!isWasmInitialized) {
4829 throw new Error("initializeWasm() must be awaited first!");
4831 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_ok(owner);
4832 return nativeResponseValue;
4834 // enum LDKSecp256k1Error CResult_StringErrorZ_get_err(LDKCResult_StringErrorZ *NONNULL_PTR owner);
4836 export function CResult_StringErrorZ_get_err(owner: bigint): Secp256k1Error {
4837 if(!isWasmInitialized) {
4838 throw new Error("initializeWasm() must be awaited first!");
4840 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_err(owner);
4841 return nativeResponseValue;
4843 // struct LDKChannelMonitorUpdate CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
4845 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
4846 if(!isWasmInitialized) {
4847 throw new Error("initializeWasm() must be awaited first!");
4849 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner);
4850 return nativeResponseValue;
4852 // struct LDKDecodeError CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
4854 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
4855 if(!isWasmInitialized) {
4856 throw new Error("initializeWasm() must be awaited first!");
4858 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner);
4859 return nativeResponseValue;
4862 export class LDKCOption_MonitorEventZ {
4863 protected constructor() {}
4866 export function LDKCOption_MonitorEventZ_ty_from_ptr(ptr: bigint): number {
4867 if(!isWasmInitialized) {
4868 throw new Error("initializeWasm() must be awaited first!");
4870 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_ty_from_ptr(ptr);
4871 return nativeResponseValue;
4874 export function LDKCOption_MonitorEventZ_Some_get_some(ptr: bigint): bigint {
4875 if(!isWasmInitialized) {
4876 throw new Error("initializeWasm() must be awaited first!");
4878 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_Some_get_some(ptr);
4879 return nativeResponseValue;
4881 // struct LDKCOption_MonitorEventZ CResult_COption_MonitorEventZDecodeErrorZ_get_ok(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
4883 export function CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner: bigint): bigint {
4884 if(!isWasmInitialized) {
4885 throw new Error("initializeWasm() must be awaited first!");
4887 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner);
4888 return nativeResponseValue;
4890 // struct LDKDecodeError CResult_COption_MonitorEventZDecodeErrorZ_get_err(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
4892 export function CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner: bigint): bigint {
4893 if(!isWasmInitialized) {
4894 throw new Error("initializeWasm() must be awaited first!");
4896 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner);
4897 return nativeResponseValue;
4899 // struct LDKHTLCUpdate CResult_HTLCUpdateDecodeErrorZ_get_ok(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
4901 export function CResult_HTLCUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
4902 if(!isWasmInitialized) {
4903 throw new Error("initializeWasm() must be awaited first!");
4905 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_ok(owner);
4906 return nativeResponseValue;
4908 // struct LDKDecodeError CResult_HTLCUpdateDecodeErrorZ_get_err(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
4910 export function CResult_HTLCUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
4911 if(!isWasmInitialized) {
4912 throw new Error("initializeWasm() must be awaited first!");
4914 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_err(owner);
4915 return nativeResponseValue;
4917 // struct LDKOutPoint C2Tuple_OutPointScriptZ_get_a(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
4919 export function C2Tuple_OutPointScriptZ_get_a(owner: bigint): bigint {
4920 if(!isWasmInitialized) {
4921 throw new Error("initializeWasm() must be awaited first!");
4923 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_a(owner);
4924 return nativeResponseValue;
4926 // struct LDKCVec_u8Z C2Tuple_OutPointScriptZ_get_b(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
4928 export function C2Tuple_OutPointScriptZ_get_b(owner: bigint): number {
4929 if(!isWasmInitialized) {
4930 throw new Error("initializeWasm() must be awaited first!");
4932 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_b(owner);
4933 return nativeResponseValue;
4935 // uint32_t C2Tuple_u32ScriptZ_get_a(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
4937 export function C2Tuple_u32ScriptZ_get_a(owner: bigint): number {
4938 if(!isWasmInitialized) {
4939 throw new Error("initializeWasm() must be awaited first!");
4941 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_a(owner);
4942 return nativeResponseValue;
4944 // struct LDKCVec_u8Z C2Tuple_u32ScriptZ_get_b(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
4946 export function C2Tuple_u32ScriptZ_get_b(owner: bigint): number {
4947 if(!isWasmInitialized) {
4948 throw new Error("initializeWasm() must be awaited first!");
4950 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_b(owner);
4951 return nativeResponseValue;
4953 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
4955 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner: bigint): number {
4956 if(!isWasmInitialized) {
4957 throw new Error("initializeWasm() must be awaited first!");
4959 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner);
4960 return nativeResponseValue;
4962 // struct LDKCVec_C2Tuple_u32ScriptZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
4964 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner: bigint): number {
4965 if(!isWasmInitialized) {
4966 throw new Error("initializeWasm() must be awaited first!");
4968 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner);
4969 return nativeResponseValue;
4971 // uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
4973 export function C2Tuple_u32TxOutZ_get_a(owner: bigint): number {
4974 if(!isWasmInitialized) {
4975 throw new Error("initializeWasm() must be awaited first!");
4977 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_a(owner);
4978 return nativeResponseValue;
4980 // struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
4982 export function C2Tuple_u32TxOutZ_get_b(owner: bigint): bigint {
4983 if(!isWasmInitialized) {
4984 throw new Error("initializeWasm() must be awaited first!");
4986 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_b(owner);
4987 return nativeResponseValue;
4989 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
4991 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner: bigint): number {
4992 if(!isWasmInitialized) {
4993 throw new Error("initializeWasm() must be awaited first!");
4995 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner);
4996 return nativeResponseValue;
4998 // struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
5000 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner: bigint): number {
5001 if(!isWasmInitialized) {
5002 throw new Error("initializeWasm() must be awaited first!");
5004 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner);
5005 return nativeResponseValue;
5008 export class LDKBalance {
5009 protected constructor() {}
5012 export function LDKBalance_ty_from_ptr(ptr: bigint): number {
5013 if(!isWasmInitialized) {
5014 throw new Error("initializeWasm() must be awaited first!");
5016 const nativeResponseValue = wasm.TS_LDKBalance_ty_from_ptr(ptr);
5017 return nativeResponseValue;
5020 export function LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr: bigint): bigint {
5021 if(!isWasmInitialized) {
5022 throw new Error("initializeWasm() must be awaited first!");
5024 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr);
5025 return nativeResponseValue;
5028 export function LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr: bigint): bigint {
5029 if(!isWasmInitialized) {
5030 throw new Error("initializeWasm() must be awaited first!");
5032 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr);
5033 return nativeResponseValue;
5036 export function LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr: bigint): number {
5037 if(!isWasmInitialized) {
5038 throw new Error("initializeWasm() must be awaited first!");
5040 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr);
5041 return nativeResponseValue;
5044 export function LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr: bigint): bigint {
5045 if(!isWasmInitialized) {
5046 throw new Error("initializeWasm() must be awaited first!");
5048 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr);
5049 return nativeResponseValue;
5052 export function LDKBalance_ContentiousClaimable_get_timeout_height(ptr: bigint): number {
5053 if(!isWasmInitialized) {
5054 throw new Error("initializeWasm() must be awaited first!");
5056 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_timeout_height(ptr);
5057 return nativeResponseValue;
5060 export function LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_amount_satoshis(ptr: bigint): bigint {
5061 if(!isWasmInitialized) {
5062 throw new Error("initializeWasm() must be awaited first!");
5064 const nativeResponseValue = wasm.TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_amount_satoshis(ptr);
5065 return nativeResponseValue;
5068 export function LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_height(ptr: bigint): number {
5069 if(!isWasmInitialized) {
5070 throw new Error("initializeWasm() must be awaited first!");
5072 const nativeResponseValue = wasm.TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_height(ptr);
5073 return nativeResponseValue;
5076 export function LDKBalance_MaybePreimageClaimableHTLC_get_claimable_amount_satoshis(ptr: bigint): bigint {
5077 if(!isWasmInitialized) {
5078 throw new Error("initializeWasm() must be awaited first!");
5080 const nativeResponseValue = wasm.TS_LDKBalance_MaybePreimageClaimableHTLC_get_claimable_amount_satoshis(ptr);
5081 return nativeResponseValue;
5084 export function LDKBalance_MaybePreimageClaimableHTLC_get_expiry_height(ptr: bigint): number {
5085 if(!isWasmInitialized) {
5086 throw new Error("initializeWasm() must be awaited first!");
5088 const nativeResponseValue = wasm.TS_LDKBalance_MaybePreimageClaimableHTLC_get_expiry_height(ptr);
5089 return nativeResponseValue;
5092 export function LDKBalance_CounterpartyRevokedOutputClaimable_get_claimable_amount_satoshis(ptr: bigint): bigint {
5093 if(!isWasmInitialized) {
5094 throw new Error("initializeWasm() must be awaited first!");
5096 const nativeResponseValue = wasm.TS_LDKBalance_CounterpartyRevokedOutputClaimable_get_claimable_amount_satoshis(ptr);
5097 return nativeResponseValue;
5099 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelMonitorZ_get_a(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
5101 export function C2Tuple_BlockHashChannelMonitorZ_get_a(owner: bigint): number {
5102 if(!isWasmInitialized) {
5103 throw new Error("initializeWasm() must be awaited first!");
5105 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_a(owner);
5106 return nativeResponseValue;
5108 // struct LDKChannelMonitor C2Tuple_BlockHashChannelMonitorZ_get_b(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
5110 export function C2Tuple_BlockHashChannelMonitorZ_get_b(owner: bigint): bigint {
5111 if(!isWasmInitialized) {
5112 throw new Error("initializeWasm() must be awaited first!");
5114 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_b(owner);
5115 return nativeResponseValue;
5117 // struct LDKC2Tuple_BlockHashChannelMonitorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
5119 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner: bigint): bigint {
5120 if(!isWasmInitialized) {
5121 throw new Error("initializeWasm() must be awaited first!");
5123 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner);
5124 return nativeResponseValue;
5126 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
5128 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner: bigint): bigint {
5129 if(!isWasmInitialized) {
5130 throw new Error("initializeWasm() must be awaited first!");
5132 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner);
5133 return nativeResponseValue;
5135 // struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
5137 export function C2Tuple_PublicKeyTypeZ_get_a(owner: bigint): number {
5138 if(!isWasmInitialized) {
5139 throw new Error("initializeWasm() must be awaited first!");
5141 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_a(owner);
5142 return nativeResponseValue;
5144 // struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
5146 export function C2Tuple_PublicKeyTypeZ_get_b(owner: bigint): bigint {
5147 if(!isWasmInitialized) {
5148 throw new Error("initializeWasm() must be awaited first!");
5150 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_b(owner);
5151 return nativeResponseValue;
5154 export interface LDKCustomOnionMessageContents {
5155 tlv_type (): bigint;
5160 export function LDKCustomOnionMessageContents_new(impl: LDKCustomOnionMessageContents): [bigint, number] {
5161 if(!isWasmInitialized) {
5162 throw new Error("initializeWasm() must be awaited first!");
5164 var new_obj_idx = js_objs.length;
5165 for (var i = 0; i < js_objs.length; i++) {
5166 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5168 js_objs[i] = new WeakRef(impl);
5169 return [wasm.TS_LDKCustomOnionMessageContents_new(i), i];
5171 // uint64_t CustomOnionMessageContents_tlv_type LDKCustomOnionMessageContents *NONNULL_PTR this_arg
5173 export function CustomOnionMessageContents_tlv_type(this_arg: bigint): bigint {
5174 if(!isWasmInitialized) {
5175 throw new Error("initializeWasm() must be awaited first!");
5177 const nativeResponseValue = wasm.TS_CustomOnionMessageContents_tlv_type(this_arg);
5178 return nativeResponseValue;
5180 // LDKCVec_u8Z CustomOnionMessageContents_write LDKCustomOnionMessageContents *NONNULL_PTR this_arg
5182 export function CustomOnionMessageContents_write(this_arg: bigint): number {
5183 if(!isWasmInitialized) {
5184 throw new Error("initializeWasm() must be awaited first!");
5186 const nativeResponseValue = wasm.TS_CustomOnionMessageContents_write(this_arg);
5187 return nativeResponseValue;
5190 export class LDKCOption_CustomOnionMessageContentsZ {
5191 protected constructor() {}
5194 export function LDKCOption_CustomOnionMessageContentsZ_ty_from_ptr(ptr: bigint): number {
5195 if(!isWasmInitialized) {
5196 throw new Error("initializeWasm() must be awaited first!");
5198 const nativeResponseValue = wasm.TS_LDKCOption_CustomOnionMessageContentsZ_ty_from_ptr(ptr);
5199 return nativeResponseValue;
5202 export function LDKCOption_CustomOnionMessageContentsZ_Some_get_some(ptr: bigint): bigint {
5203 if(!isWasmInitialized) {
5204 throw new Error("initializeWasm() must be awaited first!");
5206 const nativeResponseValue = wasm.TS_LDKCOption_CustomOnionMessageContentsZ_Some_get_some(ptr);
5207 return nativeResponseValue;
5209 // struct LDKCOption_CustomOnionMessageContentsZ CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR owner);
5211 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok(owner: bigint): bigint {
5212 if(!isWasmInitialized) {
5213 throw new Error("initializeWasm() must be awaited first!");
5215 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok(owner);
5216 return nativeResponseValue;
5218 // struct LDKDecodeError CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR owner);
5220 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err(owner: bigint): bigint {
5221 if(!isWasmInitialized) {
5222 throw new Error("initializeWasm() must be awaited first!");
5224 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err(owner);
5225 return nativeResponseValue;
5228 export class LDKCOption_NetAddressZ {
5229 protected constructor() {}
5232 export function LDKCOption_NetAddressZ_ty_from_ptr(ptr: bigint): number {
5233 if(!isWasmInitialized) {
5234 throw new Error("initializeWasm() must be awaited first!");
5236 const nativeResponseValue = wasm.TS_LDKCOption_NetAddressZ_ty_from_ptr(ptr);
5237 return nativeResponseValue;
5240 export function LDKCOption_NetAddressZ_Some_get_some(ptr: bigint): bigint {
5241 if(!isWasmInitialized) {
5242 throw new Error("initializeWasm() must be awaited first!");
5244 const nativeResponseValue = wasm.TS_LDKCOption_NetAddressZ_Some_get_some(ptr);
5245 return nativeResponseValue;
5247 // struct LDKCVec_u8Z CResult_CVec_u8ZPeerHandleErrorZ_get_ok(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
5249 export function CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner: bigint): number {
5250 if(!isWasmInitialized) {
5251 throw new Error("initializeWasm() must be awaited first!");
5253 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner);
5254 return nativeResponseValue;
5256 // struct LDKPeerHandleError CResult_CVec_u8ZPeerHandleErrorZ_get_err(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
5258 export function CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner: bigint): bigint {
5259 if(!isWasmInitialized) {
5260 throw new Error("initializeWasm() must be awaited first!");
5262 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner);
5263 return nativeResponseValue;
5265 // void CResult_NonePeerHandleErrorZ_get_ok(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
5267 export function CResult_NonePeerHandleErrorZ_get_ok(owner: bigint): void {
5268 if(!isWasmInitialized) {
5269 throw new Error("initializeWasm() must be awaited first!");
5271 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_ok(owner);
5272 // debug statements here
5274 // struct LDKPeerHandleError CResult_NonePeerHandleErrorZ_get_err(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
5276 export function CResult_NonePeerHandleErrorZ_get_err(owner: bigint): bigint {
5277 if(!isWasmInitialized) {
5278 throw new Error("initializeWasm() must be awaited first!");
5280 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_err(owner);
5281 return nativeResponseValue;
5283 // bool CResult_boolPeerHandleErrorZ_get_ok(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
5285 export function CResult_boolPeerHandleErrorZ_get_ok(owner: bigint): boolean {
5286 if(!isWasmInitialized) {
5287 throw new Error("initializeWasm() must be awaited first!");
5289 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_ok(owner);
5290 return nativeResponseValue;
5292 // struct LDKPeerHandleError CResult_boolPeerHandleErrorZ_get_err(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
5294 export function CResult_boolPeerHandleErrorZ_get_err(owner: bigint): bigint {
5295 if(!isWasmInitialized) {
5296 throw new Error("initializeWasm() must be awaited first!");
5298 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_err(owner);
5299 return nativeResponseValue;
5302 export class LDKSendError {
5303 protected constructor() {}
5306 export function LDKSendError_ty_from_ptr(ptr: bigint): number {
5307 if(!isWasmInitialized) {
5308 throw new Error("initializeWasm() must be awaited first!");
5310 const nativeResponseValue = wasm.TS_LDKSendError_ty_from_ptr(ptr);
5311 return nativeResponseValue;
5314 export function LDKSendError_Secp256k1_get_secp256k1(ptr: bigint): Secp256k1Error {
5315 if(!isWasmInitialized) {
5316 throw new Error("initializeWasm() must be awaited first!");
5318 const nativeResponseValue = wasm.TS_LDKSendError_Secp256k1_get_secp256k1(ptr);
5319 return nativeResponseValue;
5321 // void CResult_NoneSendErrorZ_get_ok(LDKCResult_NoneSendErrorZ *NONNULL_PTR owner);
5323 export function CResult_NoneSendErrorZ_get_ok(owner: bigint): void {
5324 if(!isWasmInitialized) {
5325 throw new Error("initializeWasm() must be awaited first!");
5327 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_get_ok(owner);
5328 // debug statements here
5330 // struct LDKSendError CResult_NoneSendErrorZ_get_err(LDKCResult_NoneSendErrorZ *NONNULL_PTR owner);
5332 export function CResult_NoneSendErrorZ_get_err(owner: bigint): bigint {
5333 if(!isWasmInitialized) {
5334 throw new Error("initializeWasm() must be awaited first!");
5336 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_get_err(owner);
5337 return nativeResponseValue;
5340 export class LDKGraphSyncError {
5341 protected constructor() {}
5344 export function LDKGraphSyncError_ty_from_ptr(ptr: bigint): number {
5345 if(!isWasmInitialized) {
5346 throw new Error("initializeWasm() must be awaited first!");
5348 const nativeResponseValue = wasm.TS_LDKGraphSyncError_ty_from_ptr(ptr);
5349 return nativeResponseValue;
5352 export function LDKGraphSyncError_DecodeError_get_decode_error(ptr: bigint): bigint {
5353 if(!isWasmInitialized) {
5354 throw new Error("initializeWasm() must be awaited first!");
5356 const nativeResponseValue = wasm.TS_LDKGraphSyncError_DecodeError_get_decode_error(ptr);
5357 return nativeResponseValue;
5360 export function LDKGraphSyncError_LightningError_get_lightning_error(ptr: bigint): bigint {
5361 if(!isWasmInitialized) {
5362 throw new Error("initializeWasm() must be awaited first!");
5364 const nativeResponseValue = wasm.TS_LDKGraphSyncError_LightningError_get_lightning_error(ptr);
5365 return nativeResponseValue;
5367 // uint32_t CResult_u32GraphSyncErrorZ_get_ok(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner);
5369 export function CResult_u32GraphSyncErrorZ_get_ok(owner: bigint): number {
5370 if(!isWasmInitialized) {
5371 throw new Error("initializeWasm() must be awaited first!");
5373 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_get_ok(owner);
5374 return nativeResponseValue;
5376 // struct LDKGraphSyncError CResult_u32GraphSyncErrorZ_get_err(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner);
5378 export function CResult_u32GraphSyncErrorZ_get_err(owner: bigint): bigint {
5379 if(!isWasmInitialized) {
5380 throw new Error("initializeWasm() must be awaited first!");
5382 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_get_err(owner);
5383 return nativeResponseValue;
5385 // void CResult_NoneErrorZ_get_ok(LDKCResult_NoneErrorZ *NONNULL_PTR owner);
5387 export function CResult_NoneErrorZ_get_ok(owner: bigint): void {
5388 if(!isWasmInitialized) {
5389 throw new Error("initializeWasm() must be awaited first!");
5391 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_get_ok(owner);
5392 // debug statements here
5394 // enum LDKIOError CResult_NoneErrorZ_get_err(LDKCResult_NoneErrorZ *NONNULL_PTR owner);
5396 export function CResult_NoneErrorZ_get_err(owner: bigint): IOError {
5397 if(!isWasmInitialized) {
5398 throw new Error("initializeWasm() must be awaited first!");
5400 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_get_err(owner);
5401 return nativeResponseValue;
5403 // struct LDKNetAddress CResult_NetAddressDecodeErrorZ_get_ok(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
5405 export function CResult_NetAddressDecodeErrorZ_get_ok(owner: bigint): bigint {
5406 if(!isWasmInitialized) {
5407 throw new Error("initializeWasm() must be awaited first!");
5409 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_ok(owner);
5410 return nativeResponseValue;
5412 // struct LDKDecodeError CResult_NetAddressDecodeErrorZ_get_err(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
5414 export function CResult_NetAddressDecodeErrorZ_get_err(owner: bigint): bigint {
5415 if(!isWasmInitialized) {
5416 throw new Error("initializeWasm() must be awaited first!");
5418 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_err(owner);
5419 return nativeResponseValue;
5421 // struct LDKAcceptChannel CResult_AcceptChannelDecodeErrorZ_get_ok(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
5423 export function CResult_AcceptChannelDecodeErrorZ_get_ok(owner: bigint): bigint {
5424 if(!isWasmInitialized) {
5425 throw new Error("initializeWasm() must be awaited first!");
5427 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_ok(owner);
5428 return nativeResponseValue;
5430 // struct LDKDecodeError CResult_AcceptChannelDecodeErrorZ_get_err(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
5432 export function CResult_AcceptChannelDecodeErrorZ_get_err(owner: bigint): bigint {
5433 if(!isWasmInitialized) {
5434 throw new Error("initializeWasm() must be awaited first!");
5436 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_err(owner);
5437 return nativeResponseValue;
5439 // struct LDKAnnouncementSignatures CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
5441 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
5442 if(!isWasmInitialized) {
5443 throw new Error("initializeWasm() must be awaited first!");
5445 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner);
5446 return nativeResponseValue;
5448 // struct LDKDecodeError CResult_AnnouncementSignaturesDecodeErrorZ_get_err(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
5450 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner: bigint): bigint {
5451 if(!isWasmInitialized) {
5452 throw new Error("initializeWasm() must be awaited first!");
5454 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner);
5455 return nativeResponseValue;
5457 // struct LDKChannelReestablish CResult_ChannelReestablishDecodeErrorZ_get_ok(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
5459 export function CResult_ChannelReestablishDecodeErrorZ_get_ok(owner: bigint): bigint {
5460 if(!isWasmInitialized) {
5461 throw new Error("initializeWasm() must be awaited first!");
5463 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_ok(owner);
5464 return nativeResponseValue;
5466 // struct LDKDecodeError CResult_ChannelReestablishDecodeErrorZ_get_err(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
5468 export function CResult_ChannelReestablishDecodeErrorZ_get_err(owner: bigint): bigint {
5469 if(!isWasmInitialized) {
5470 throw new Error("initializeWasm() must be awaited first!");
5472 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_err(owner);
5473 return nativeResponseValue;
5475 // struct LDKClosingSigned CResult_ClosingSignedDecodeErrorZ_get_ok(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
5477 export function CResult_ClosingSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
5478 if(!isWasmInitialized) {
5479 throw new Error("initializeWasm() must be awaited first!");
5481 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_ok(owner);
5482 return nativeResponseValue;
5484 // struct LDKDecodeError CResult_ClosingSignedDecodeErrorZ_get_err(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
5486 export function CResult_ClosingSignedDecodeErrorZ_get_err(owner: bigint): bigint {
5487 if(!isWasmInitialized) {
5488 throw new Error("initializeWasm() must be awaited first!");
5490 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_err(owner);
5491 return nativeResponseValue;
5493 // struct LDKClosingSignedFeeRange CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
5495 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
5496 if(!isWasmInitialized) {
5497 throw new Error("initializeWasm() must be awaited first!");
5499 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner);
5500 return nativeResponseValue;
5502 // struct LDKDecodeError CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
5504 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner: bigint): bigint {
5505 if(!isWasmInitialized) {
5506 throw new Error("initializeWasm() must be awaited first!");
5508 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner);
5509 return nativeResponseValue;
5511 // struct LDKCommitmentSigned CResult_CommitmentSignedDecodeErrorZ_get_ok(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
5513 export function CResult_CommitmentSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
5514 if(!isWasmInitialized) {
5515 throw new Error("initializeWasm() must be awaited first!");
5517 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_ok(owner);
5518 return nativeResponseValue;
5520 // struct LDKDecodeError CResult_CommitmentSignedDecodeErrorZ_get_err(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
5522 export function CResult_CommitmentSignedDecodeErrorZ_get_err(owner: bigint): bigint {
5523 if(!isWasmInitialized) {
5524 throw new Error("initializeWasm() must be awaited first!");
5526 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_err(owner);
5527 return nativeResponseValue;
5529 // struct LDKFundingCreated CResult_FundingCreatedDecodeErrorZ_get_ok(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
5531 export function CResult_FundingCreatedDecodeErrorZ_get_ok(owner: bigint): bigint {
5532 if(!isWasmInitialized) {
5533 throw new Error("initializeWasm() must be awaited first!");
5535 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_ok(owner);
5536 return nativeResponseValue;
5538 // struct LDKDecodeError CResult_FundingCreatedDecodeErrorZ_get_err(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
5540 export function CResult_FundingCreatedDecodeErrorZ_get_err(owner: bigint): bigint {
5541 if(!isWasmInitialized) {
5542 throw new Error("initializeWasm() must be awaited first!");
5544 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_err(owner);
5545 return nativeResponseValue;
5547 // struct LDKFundingSigned CResult_FundingSignedDecodeErrorZ_get_ok(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
5549 export function CResult_FundingSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
5550 if(!isWasmInitialized) {
5551 throw new Error("initializeWasm() must be awaited first!");
5553 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_ok(owner);
5554 return nativeResponseValue;
5556 // struct LDKDecodeError CResult_FundingSignedDecodeErrorZ_get_err(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
5558 export function CResult_FundingSignedDecodeErrorZ_get_err(owner: bigint): bigint {
5559 if(!isWasmInitialized) {
5560 throw new Error("initializeWasm() must be awaited first!");
5562 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_err(owner);
5563 return nativeResponseValue;
5565 // struct LDKChannelReady CResult_ChannelReadyDecodeErrorZ_get_ok(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
5567 export function CResult_ChannelReadyDecodeErrorZ_get_ok(owner: bigint): bigint {
5568 if(!isWasmInitialized) {
5569 throw new Error("initializeWasm() must be awaited first!");
5571 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_ok(owner);
5572 return nativeResponseValue;
5574 // struct LDKDecodeError CResult_ChannelReadyDecodeErrorZ_get_err(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
5576 export function CResult_ChannelReadyDecodeErrorZ_get_err(owner: bigint): bigint {
5577 if(!isWasmInitialized) {
5578 throw new Error("initializeWasm() must be awaited first!");
5580 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_err(owner);
5581 return nativeResponseValue;
5583 // struct LDKInit CResult_InitDecodeErrorZ_get_ok(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
5585 export function CResult_InitDecodeErrorZ_get_ok(owner: bigint): bigint {
5586 if(!isWasmInitialized) {
5587 throw new Error("initializeWasm() must be awaited first!");
5589 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_ok(owner);
5590 return nativeResponseValue;
5592 // struct LDKDecodeError CResult_InitDecodeErrorZ_get_err(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
5594 export function CResult_InitDecodeErrorZ_get_err(owner: bigint): bigint {
5595 if(!isWasmInitialized) {
5596 throw new Error("initializeWasm() must be awaited first!");
5598 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_err(owner);
5599 return nativeResponseValue;
5601 // struct LDKOpenChannel CResult_OpenChannelDecodeErrorZ_get_ok(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
5603 export function CResult_OpenChannelDecodeErrorZ_get_ok(owner: bigint): bigint {
5604 if(!isWasmInitialized) {
5605 throw new Error("initializeWasm() must be awaited first!");
5607 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_ok(owner);
5608 return nativeResponseValue;
5610 // struct LDKDecodeError CResult_OpenChannelDecodeErrorZ_get_err(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
5612 export function CResult_OpenChannelDecodeErrorZ_get_err(owner: bigint): bigint {
5613 if(!isWasmInitialized) {
5614 throw new Error("initializeWasm() must be awaited first!");
5616 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_err(owner);
5617 return nativeResponseValue;
5619 // struct LDKRevokeAndACK CResult_RevokeAndACKDecodeErrorZ_get_ok(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
5621 export function CResult_RevokeAndACKDecodeErrorZ_get_ok(owner: bigint): bigint {
5622 if(!isWasmInitialized) {
5623 throw new Error("initializeWasm() must be awaited first!");
5625 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_ok(owner);
5626 return nativeResponseValue;
5628 // struct LDKDecodeError CResult_RevokeAndACKDecodeErrorZ_get_err(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
5630 export function CResult_RevokeAndACKDecodeErrorZ_get_err(owner: bigint): bigint {
5631 if(!isWasmInitialized) {
5632 throw new Error("initializeWasm() must be awaited first!");
5634 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_err(owner);
5635 return nativeResponseValue;
5637 // struct LDKShutdown CResult_ShutdownDecodeErrorZ_get_ok(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
5639 export function CResult_ShutdownDecodeErrorZ_get_ok(owner: bigint): bigint {
5640 if(!isWasmInitialized) {
5641 throw new Error("initializeWasm() must be awaited first!");
5643 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_ok(owner);
5644 return nativeResponseValue;
5646 // struct LDKDecodeError CResult_ShutdownDecodeErrorZ_get_err(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
5648 export function CResult_ShutdownDecodeErrorZ_get_err(owner: bigint): bigint {
5649 if(!isWasmInitialized) {
5650 throw new Error("initializeWasm() must be awaited first!");
5652 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_err(owner);
5653 return nativeResponseValue;
5655 // struct LDKUpdateFailHTLC CResult_UpdateFailHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
5657 export function CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
5658 if(!isWasmInitialized) {
5659 throw new Error("initializeWasm() must be awaited first!");
5661 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner);
5662 return nativeResponseValue;
5664 // struct LDKDecodeError CResult_UpdateFailHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
5666 export function CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
5667 if(!isWasmInitialized) {
5668 throw new Error("initializeWasm() must be awaited first!");
5670 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner);
5671 return nativeResponseValue;
5673 // struct LDKUpdateFailMalformedHTLC CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
5675 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
5676 if(!isWasmInitialized) {
5677 throw new Error("initializeWasm() must be awaited first!");
5679 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner);
5680 return nativeResponseValue;
5682 // struct LDKDecodeError CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
5684 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
5685 if(!isWasmInitialized) {
5686 throw new Error("initializeWasm() must be awaited first!");
5688 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner);
5689 return nativeResponseValue;
5691 // struct LDKUpdateFee CResult_UpdateFeeDecodeErrorZ_get_ok(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
5693 export function CResult_UpdateFeeDecodeErrorZ_get_ok(owner: bigint): bigint {
5694 if(!isWasmInitialized) {
5695 throw new Error("initializeWasm() must be awaited first!");
5697 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_ok(owner);
5698 return nativeResponseValue;
5700 // struct LDKDecodeError CResult_UpdateFeeDecodeErrorZ_get_err(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
5702 export function CResult_UpdateFeeDecodeErrorZ_get_err(owner: bigint): bigint {
5703 if(!isWasmInitialized) {
5704 throw new Error("initializeWasm() must be awaited first!");
5706 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_err(owner);
5707 return nativeResponseValue;
5709 // struct LDKUpdateFulfillHTLC CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
5711 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
5712 if(!isWasmInitialized) {
5713 throw new Error("initializeWasm() must be awaited first!");
5715 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner);
5716 return nativeResponseValue;
5718 // struct LDKDecodeError CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
5720 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
5721 if(!isWasmInitialized) {
5722 throw new Error("initializeWasm() must be awaited first!");
5724 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner);
5725 return nativeResponseValue;
5727 // struct LDKUpdateAddHTLC CResult_UpdateAddHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
5729 export function CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
5730 if(!isWasmInitialized) {
5731 throw new Error("initializeWasm() must be awaited first!");
5733 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner);
5734 return nativeResponseValue;
5736 // struct LDKDecodeError CResult_UpdateAddHTLCDecodeErrorZ_get_err(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
5738 export function CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
5739 if(!isWasmInitialized) {
5740 throw new Error("initializeWasm() must be awaited first!");
5742 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner);
5743 return nativeResponseValue;
5745 // struct LDKOnionMessage CResult_OnionMessageDecodeErrorZ_get_ok(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner);
5747 export function CResult_OnionMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
5748 if(!isWasmInitialized) {
5749 throw new Error("initializeWasm() must be awaited first!");
5751 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_get_ok(owner);
5752 return nativeResponseValue;
5754 // struct LDKDecodeError CResult_OnionMessageDecodeErrorZ_get_err(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner);
5756 export function CResult_OnionMessageDecodeErrorZ_get_err(owner: bigint): bigint {
5757 if(!isWasmInitialized) {
5758 throw new Error("initializeWasm() must be awaited first!");
5760 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_get_err(owner);
5761 return nativeResponseValue;
5763 // struct LDKPing CResult_PingDecodeErrorZ_get_ok(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
5765 export function CResult_PingDecodeErrorZ_get_ok(owner: bigint): bigint {
5766 if(!isWasmInitialized) {
5767 throw new Error("initializeWasm() must be awaited first!");
5769 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_ok(owner);
5770 return nativeResponseValue;
5772 // struct LDKDecodeError CResult_PingDecodeErrorZ_get_err(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
5774 export function CResult_PingDecodeErrorZ_get_err(owner: bigint): bigint {
5775 if(!isWasmInitialized) {
5776 throw new Error("initializeWasm() must be awaited first!");
5778 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_err(owner);
5779 return nativeResponseValue;
5781 // struct LDKPong CResult_PongDecodeErrorZ_get_ok(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
5783 export function CResult_PongDecodeErrorZ_get_ok(owner: bigint): bigint {
5784 if(!isWasmInitialized) {
5785 throw new Error("initializeWasm() must be awaited first!");
5787 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_ok(owner);
5788 return nativeResponseValue;
5790 // struct LDKDecodeError CResult_PongDecodeErrorZ_get_err(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
5792 export function CResult_PongDecodeErrorZ_get_err(owner: bigint): bigint {
5793 if(!isWasmInitialized) {
5794 throw new Error("initializeWasm() must be awaited first!");
5796 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_err(owner);
5797 return nativeResponseValue;
5799 // struct LDKUnsignedChannelAnnouncement CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5801 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
5802 if(!isWasmInitialized) {
5803 throw new Error("initializeWasm() must be awaited first!");
5805 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner);
5806 return nativeResponseValue;
5808 // struct LDKDecodeError CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5810 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
5811 if(!isWasmInitialized) {
5812 throw new Error("initializeWasm() must be awaited first!");
5814 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner);
5815 return nativeResponseValue;
5817 // struct LDKChannelAnnouncement CResult_ChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5819 export function CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
5820 if(!isWasmInitialized) {
5821 throw new Error("initializeWasm() must be awaited first!");
5823 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner);
5824 return nativeResponseValue;
5826 // struct LDKDecodeError CResult_ChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5828 export function CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
5829 if(!isWasmInitialized) {
5830 throw new Error("initializeWasm() must be awaited first!");
5832 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner);
5833 return nativeResponseValue;
5835 // struct LDKUnsignedChannelUpdate CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5837 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
5838 if(!isWasmInitialized) {
5839 throw new Error("initializeWasm() must be awaited first!");
5841 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner);
5842 return nativeResponseValue;
5844 // struct LDKDecodeError CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5846 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
5847 if(!isWasmInitialized) {
5848 throw new Error("initializeWasm() must be awaited first!");
5850 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner);
5851 return nativeResponseValue;
5853 // struct LDKChannelUpdate CResult_ChannelUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5855 export function CResult_ChannelUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
5856 if(!isWasmInitialized) {
5857 throw new Error("initializeWasm() must be awaited first!");
5859 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_ok(owner);
5860 return nativeResponseValue;
5862 // struct LDKDecodeError CResult_ChannelUpdateDecodeErrorZ_get_err(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5864 export function CResult_ChannelUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
5865 if(!isWasmInitialized) {
5866 throw new Error("initializeWasm() must be awaited first!");
5868 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_err(owner);
5869 return nativeResponseValue;
5871 // struct LDKErrorMessage CResult_ErrorMessageDecodeErrorZ_get_ok(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
5873 export function CResult_ErrorMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
5874 if(!isWasmInitialized) {
5875 throw new Error("initializeWasm() must be awaited first!");
5877 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_ok(owner);
5878 return nativeResponseValue;
5880 // struct LDKDecodeError CResult_ErrorMessageDecodeErrorZ_get_err(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
5882 export function CResult_ErrorMessageDecodeErrorZ_get_err(owner: bigint): bigint {
5883 if(!isWasmInitialized) {
5884 throw new Error("initializeWasm() must be awaited first!");
5886 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_err(owner);
5887 return nativeResponseValue;
5889 // struct LDKWarningMessage CResult_WarningMessageDecodeErrorZ_get_ok(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
5891 export function CResult_WarningMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
5892 if(!isWasmInitialized) {
5893 throw new Error("initializeWasm() must be awaited first!");
5895 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_ok(owner);
5896 return nativeResponseValue;
5898 // struct LDKDecodeError CResult_WarningMessageDecodeErrorZ_get_err(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
5900 export function CResult_WarningMessageDecodeErrorZ_get_err(owner: bigint): bigint {
5901 if(!isWasmInitialized) {
5902 throw new Error("initializeWasm() must be awaited first!");
5904 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_err(owner);
5905 return nativeResponseValue;
5907 // struct LDKUnsignedNodeAnnouncement CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5909 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
5910 if(!isWasmInitialized) {
5911 throw new Error("initializeWasm() must be awaited first!");
5913 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner);
5914 return nativeResponseValue;
5916 // struct LDKDecodeError CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5918 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
5919 if(!isWasmInitialized) {
5920 throw new Error("initializeWasm() must be awaited first!");
5922 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner);
5923 return nativeResponseValue;
5925 // struct LDKNodeAnnouncement CResult_NodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5927 export function CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
5928 if(!isWasmInitialized) {
5929 throw new Error("initializeWasm() must be awaited first!");
5931 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner);
5932 return nativeResponseValue;
5934 // struct LDKDecodeError CResult_NodeAnnouncementDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5936 export function CResult_NodeAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
5937 if(!isWasmInitialized) {
5938 throw new Error("initializeWasm() must be awaited first!");
5940 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_err(owner);
5941 return nativeResponseValue;
5943 // struct LDKQueryShortChannelIds CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
5945 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner: bigint): bigint {
5946 if(!isWasmInitialized) {
5947 throw new Error("initializeWasm() must be awaited first!");
5949 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner);
5950 return nativeResponseValue;
5952 // struct LDKDecodeError CResult_QueryShortChannelIdsDecodeErrorZ_get_err(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
5954 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner: bigint): bigint {
5955 if(!isWasmInitialized) {
5956 throw new Error("initializeWasm() must be awaited first!");
5958 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner);
5959 return nativeResponseValue;
5961 // struct LDKReplyShortChannelIdsEnd CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
5963 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner: bigint): bigint {
5964 if(!isWasmInitialized) {
5965 throw new Error("initializeWasm() must be awaited first!");
5967 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner);
5968 return nativeResponseValue;
5970 // struct LDKDecodeError CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
5972 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner: bigint): bigint {
5973 if(!isWasmInitialized) {
5974 throw new Error("initializeWasm() must be awaited first!");
5976 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner);
5977 return nativeResponseValue;
5979 // struct LDKQueryChannelRange CResult_QueryChannelRangeDecodeErrorZ_get_ok(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5981 export function CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
5982 if(!isWasmInitialized) {
5983 throw new Error("initializeWasm() must be awaited first!");
5985 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner);
5986 return nativeResponseValue;
5988 // struct LDKDecodeError CResult_QueryChannelRangeDecodeErrorZ_get_err(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5990 export function CResult_QueryChannelRangeDecodeErrorZ_get_err(owner: bigint): bigint {
5991 if(!isWasmInitialized) {
5992 throw new Error("initializeWasm() must be awaited first!");
5994 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_err(owner);
5995 return nativeResponseValue;
5997 // struct LDKReplyChannelRange CResult_ReplyChannelRangeDecodeErrorZ_get_ok(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5999 export function CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
6000 if(!isWasmInitialized) {
6001 throw new Error("initializeWasm() must be awaited first!");
6003 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner);
6004 return nativeResponseValue;
6006 // struct LDKDecodeError CResult_ReplyChannelRangeDecodeErrorZ_get_err(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
6008 export function CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner: bigint): bigint {
6009 if(!isWasmInitialized) {
6010 throw new Error("initializeWasm() must be awaited first!");
6012 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner);
6013 return nativeResponseValue;
6015 // struct LDKGossipTimestampFilter CResult_GossipTimestampFilterDecodeErrorZ_get_ok(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
6017 export function CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner: bigint): bigint {
6018 if(!isWasmInitialized) {
6019 throw new Error("initializeWasm() must be awaited first!");
6021 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner);
6022 return nativeResponseValue;
6024 // struct LDKDecodeError CResult_GossipTimestampFilterDecodeErrorZ_get_err(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
6026 export function CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner: bigint): bigint {
6027 if(!isWasmInitialized) {
6028 throw new Error("initializeWasm() must be awaited first!");
6030 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner);
6031 return nativeResponseValue;
6034 export class LDKSignOrCreationError {
6035 protected constructor() {}
6038 export function LDKSignOrCreationError_ty_from_ptr(ptr: bigint): number {
6039 if(!isWasmInitialized) {
6040 throw new Error("initializeWasm() must be awaited first!");
6042 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_ty_from_ptr(ptr);
6043 return nativeResponseValue;
6046 export function LDKSignOrCreationError_CreationError_get_creation_error(ptr: bigint): CreationError {
6047 if(!isWasmInitialized) {
6048 throw new Error("initializeWasm() must be awaited first!");
6050 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_CreationError_get_creation_error(ptr);
6051 return nativeResponseValue;
6053 // struct LDKInvoice CResult_InvoiceSignOrCreationErrorZ_get_ok(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
6055 export function CResult_InvoiceSignOrCreationErrorZ_get_ok(owner: bigint): bigint {
6056 if(!isWasmInitialized) {
6057 throw new Error("initializeWasm() must be awaited first!");
6059 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_ok(owner);
6060 return nativeResponseValue;
6062 // struct LDKSignOrCreationError CResult_InvoiceSignOrCreationErrorZ_get_err(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
6064 export function CResult_InvoiceSignOrCreationErrorZ_get_err(owner: bigint): bigint {
6065 if(!isWasmInitialized) {
6066 throw new Error("initializeWasm() must be awaited first!");
6068 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_err(owner);
6069 return nativeResponseValue;
6072 export interface LDKFilter {
6073 register_tx (txid: number, script_pubkey: number): void;
6074 register_output (output: bigint): void;
6078 export function LDKFilter_new(impl: LDKFilter): [bigint, number] {
6079 if(!isWasmInitialized) {
6080 throw new Error("initializeWasm() must be awaited first!");
6082 var new_obj_idx = js_objs.length;
6083 for (var i = 0; i < js_objs.length; i++) {
6084 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6086 js_objs[i] = new WeakRef(impl);
6087 return [wasm.TS_LDKFilter_new(i), i];
6089 // void Filter_register_tx LDKFilter *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
6091 export function Filter_register_tx(this_arg: bigint, txid: number, script_pubkey: number): void {
6092 if(!isWasmInitialized) {
6093 throw new Error("initializeWasm() must be awaited first!");
6095 const nativeResponseValue = wasm.TS_Filter_register_tx(this_arg, txid, script_pubkey);
6096 // debug statements here
6098 // void Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
6100 export function Filter_register_output(this_arg: bigint, output: bigint): void {
6101 if(!isWasmInitialized) {
6102 throw new Error("initializeWasm() must be awaited first!");
6104 const nativeResponseValue = wasm.TS_Filter_register_output(this_arg, output);
6105 // debug statements here
6108 export class LDKCOption_FilterZ {
6109 protected constructor() {}
6112 export function LDKCOption_FilterZ_ty_from_ptr(ptr: bigint): number {
6113 if(!isWasmInitialized) {
6114 throw new Error("initializeWasm() must be awaited first!");
6116 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_ty_from_ptr(ptr);
6117 return nativeResponseValue;
6120 export function LDKCOption_FilterZ_Some_get_some(ptr: bigint): bigint {
6121 if(!isWasmInitialized) {
6122 throw new Error("initializeWasm() must be awaited first!");
6124 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_Some_get_some(ptr);
6125 return nativeResponseValue;
6127 // struct LDKLockedChannelMonitor CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
6129 export function CResult_LockedChannelMonitorNoneZ_get_ok(owner: bigint): bigint {
6130 if(!isWasmInitialized) {
6131 throw new Error("initializeWasm() must be awaited first!");
6133 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_ok(owner);
6134 return nativeResponseValue;
6136 // void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
6138 export function CResult_LockedChannelMonitorNoneZ_get_err(owner: bigint): void {
6139 if(!isWasmInitialized) {
6140 throw new Error("initializeWasm() must be awaited first!");
6142 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_err(owner);
6143 // debug statements here
6146 export interface LDKMessageSendEventsProvider {
6147 get_and_clear_pending_msg_events (): number;
6151 export function LDKMessageSendEventsProvider_new(impl: LDKMessageSendEventsProvider): [bigint, number] {
6152 if(!isWasmInitialized) {
6153 throw new Error("initializeWasm() must be awaited first!");
6155 var new_obj_idx = js_objs.length;
6156 for (var i = 0; i < js_objs.length; i++) {
6157 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6159 js_objs[i] = new WeakRef(impl);
6160 return [wasm.TS_LDKMessageSendEventsProvider_new(i), i];
6162 // LDKCVec_MessageSendEventZ MessageSendEventsProvider_get_and_clear_pending_msg_events LDKMessageSendEventsProvider *NONNULL_PTR this_arg
6164 export function MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg: bigint): number {
6165 if(!isWasmInitialized) {
6166 throw new Error("initializeWasm() must be awaited first!");
6168 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg);
6169 return nativeResponseValue;
6172 export interface LDKOnionMessageProvider {
6173 next_onion_message_for_peer (peer_node_id: number): bigint;
6177 export function LDKOnionMessageProvider_new(impl: LDKOnionMessageProvider): [bigint, number] {
6178 if(!isWasmInitialized) {
6179 throw new Error("initializeWasm() must be awaited first!");
6181 var new_obj_idx = js_objs.length;
6182 for (var i = 0; i < js_objs.length; i++) {
6183 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6185 js_objs[i] = new WeakRef(impl);
6186 return [wasm.TS_LDKOnionMessageProvider_new(i), i];
6188 // LDKOnionMessage OnionMessageProvider_next_onion_message_for_peer LDKOnionMessageProvider *NONNULL_PTR this_arg, struct LDKPublicKey peer_node_id
6190 export function OnionMessageProvider_next_onion_message_for_peer(this_arg: bigint, peer_node_id: number): bigint {
6191 if(!isWasmInitialized) {
6192 throw new Error("initializeWasm() must be awaited first!");
6194 const nativeResponseValue = wasm.TS_OnionMessageProvider_next_onion_message_for_peer(this_arg, peer_node_id);
6195 return nativeResponseValue;
6198 export interface LDKEventHandler {
6199 handle_event (event: bigint): void;
6203 export function LDKEventHandler_new(impl: LDKEventHandler): [bigint, number] {
6204 if(!isWasmInitialized) {
6205 throw new Error("initializeWasm() must be awaited first!");
6207 var new_obj_idx = js_objs.length;
6208 for (var i = 0; i < js_objs.length; i++) {
6209 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6211 js_objs[i] = new WeakRef(impl);
6212 return [wasm.TS_LDKEventHandler_new(i), i];
6214 // void EventHandler_handle_event LDKEventHandler *NONNULL_PTR this_arg, const struct LDKEvent *NONNULL_PTR event
6216 export function EventHandler_handle_event(this_arg: bigint, event: bigint): void {
6217 if(!isWasmInitialized) {
6218 throw new Error("initializeWasm() must be awaited first!");
6220 const nativeResponseValue = wasm.TS_EventHandler_handle_event(this_arg, event);
6221 // debug statements here
6224 export interface LDKEventsProvider {
6225 process_pending_events (handler: bigint): void;
6229 export function LDKEventsProvider_new(impl: LDKEventsProvider): [bigint, number] {
6230 if(!isWasmInitialized) {
6231 throw new Error("initializeWasm() must be awaited first!");
6233 var new_obj_idx = js_objs.length;
6234 for (var i = 0; i < js_objs.length; i++) {
6235 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6237 js_objs[i] = new WeakRef(impl);
6238 return [wasm.TS_LDKEventsProvider_new(i), i];
6240 // void EventsProvider_process_pending_events LDKEventsProvider *NONNULL_PTR this_arg, struct LDKEventHandler handler
6242 export function EventsProvider_process_pending_events(this_arg: bigint, handler: bigint): void {
6243 if(!isWasmInitialized) {
6244 throw new Error("initializeWasm() must be awaited first!");
6246 const nativeResponseValue = wasm.TS_EventsProvider_process_pending_events(this_arg, handler);
6247 // debug statements here
6250 export interface LDKScore {
6251 channel_penalty_msat (short_channel_id: bigint, source: bigint, target: bigint, usage: bigint): bigint;
6252 payment_path_failed (path: number, short_channel_id: bigint): void;
6253 payment_path_successful (path: number): void;
6254 probe_failed (path: number, short_channel_id: bigint): void;
6255 probe_successful (path: number): void;
6260 export function LDKScore_new(impl: LDKScore): [bigint, number] {
6261 if(!isWasmInitialized) {
6262 throw new Error("initializeWasm() must be awaited first!");
6264 var new_obj_idx = js_objs.length;
6265 for (var i = 0; i < js_objs.length; i++) {
6266 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6268 js_objs[i] = new WeakRef(impl);
6269 return [wasm.TS_LDKScore_new(i), i];
6271 // 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
6273 export function Score_channel_penalty_msat(this_arg: bigint, short_channel_id: bigint, source: bigint, target: bigint, usage: bigint): bigint {
6274 if(!isWasmInitialized) {
6275 throw new Error("initializeWasm() must be awaited first!");
6277 const nativeResponseValue = wasm.TS_Score_channel_penalty_msat(this_arg, short_channel_id, source, target, usage);
6278 return nativeResponseValue;
6280 // void Score_payment_path_failed LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
6282 export function Score_payment_path_failed(this_arg: bigint, path: number, short_channel_id: bigint): void {
6283 if(!isWasmInitialized) {
6284 throw new Error("initializeWasm() must be awaited first!");
6286 const nativeResponseValue = wasm.TS_Score_payment_path_failed(this_arg, path, short_channel_id);
6287 // debug statements here
6289 // void Score_payment_path_successful LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
6291 export function Score_payment_path_successful(this_arg: bigint, path: number): void {
6292 if(!isWasmInitialized) {
6293 throw new Error("initializeWasm() must be awaited first!");
6295 const nativeResponseValue = wasm.TS_Score_payment_path_successful(this_arg, path);
6296 // debug statements here
6298 // void Score_probe_failed LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
6300 export function Score_probe_failed(this_arg: bigint, path: number, short_channel_id: bigint): void {
6301 if(!isWasmInitialized) {
6302 throw new Error("initializeWasm() must be awaited first!");
6304 const nativeResponseValue = wasm.TS_Score_probe_failed(this_arg, path, short_channel_id);
6305 // debug statements here
6307 // void Score_probe_successful LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
6309 export function Score_probe_successful(this_arg: bigint, path: number): void {
6310 if(!isWasmInitialized) {
6311 throw new Error("initializeWasm() must be awaited first!");
6313 const nativeResponseValue = wasm.TS_Score_probe_successful(this_arg, path);
6314 // debug statements here
6316 // LDKCVec_u8Z Score_write LDKScore *NONNULL_PTR this_arg
6318 export function Score_write(this_arg: bigint): number {
6319 if(!isWasmInitialized) {
6320 throw new Error("initializeWasm() must be awaited first!");
6322 const nativeResponseValue = wasm.TS_Score_write(this_arg);
6323 return nativeResponseValue;
6326 export interface LDKLockableScore {
6331 export function LDKLockableScore_new(impl: LDKLockableScore): [bigint, number] {
6332 if(!isWasmInitialized) {
6333 throw new Error("initializeWasm() must be awaited first!");
6335 var new_obj_idx = js_objs.length;
6336 for (var i = 0; i < js_objs.length; i++) {
6337 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6339 js_objs[i] = new WeakRef(impl);
6340 return [wasm.TS_LDKLockableScore_new(i), i];
6342 // LDKScore LockableScore_lock LDKLockableScore *NONNULL_PTR this_arg
6344 export function LockableScore_lock(this_arg: bigint): bigint {
6345 if(!isWasmInitialized) {
6346 throw new Error("initializeWasm() must be awaited first!");
6348 const nativeResponseValue = wasm.TS_LockableScore_lock(this_arg);
6349 return nativeResponseValue;
6352 export interface LDKWriteableScore {
6357 export function LDKWriteableScore_new(impl: LDKWriteableScore, LockableScore: number): [bigint, number] {
6358 if(!isWasmInitialized) {
6359 throw new Error("initializeWasm() must be awaited first!");
6361 var new_obj_idx = js_objs.length;
6362 for (var i = 0; i < js_objs.length; i++) {
6363 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6365 js_objs[i] = new WeakRef(impl);
6366 return [wasm.TS_LDKWriteableScore_new(i, LockableScore), i];
6368 // LDKCVec_u8Z WriteableScore_write LDKWriteableScore *NONNULL_PTR this_arg
6370 export function WriteableScore_write(this_arg: bigint): number {
6371 if(!isWasmInitialized) {
6372 throw new Error("initializeWasm() must be awaited first!");
6374 const nativeResponseValue = wasm.TS_WriteableScore_write(this_arg);
6375 return nativeResponseValue;
6378 export interface LDKPersister {
6379 persist_manager (channel_manager: bigint): bigint;
6380 persist_graph (network_graph: bigint): bigint;
6381 persist_scorer (scorer: bigint): bigint;
6385 export function LDKPersister_new(impl: LDKPersister): [bigint, number] {
6386 if(!isWasmInitialized) {
6387 throw new Error("initializeWasm() must be awaited first!");
6389 var new_obj_idx = js_objs.length;
6390 for (var i = 0; i < js_objs.length; i++) {
6391 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6393 js_objs[i] = new WeakRef(impl);
6394 return [wasm.TS_LDKPersister_new(i), i];
6396 // LDKCResult_NoneErrorZ Persister_persist_manager LDKPersister *NONNULL_PTR this_arg, const struct LDKChannelManager *NONNULL_PTR channel_manager
6398 export function Persister_persist_manager(this_arg: bigint, channel_manager: bigint): bigint {
6399 if(!isWasmInitialized) {
6400 throw new Error("initializeWasm() must be awaited first!");
6402 const nativeResponseValue = wasm.TS_Persister_persist_manager(this_arg, channel_manager);
6403 return nativeResponseValue;
6405 // LDKCResult_NoneErrorZ Persister_persist_graph LDKPersister *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR network_graph
6407 export function Persister_persist_graph(this_arg: bigint, network_graph: bigint): bigint {
6408 if(!isWasmInitialized) {
6409 throw new Error("initializeWasm() must be awaited first!");
6411 const nativeResponseValue = wasm.TS_Persister_persist_graph(this_arg, network_graph);
6412 return nativeResponseValue;
6414 // LDKCResult_NoneErrorZ Persister_persist_scorer LDKPersister *NONNULL_PTR this_arg, const struct LDKWriteableScore *NONNULL_PTR scorer
6416 export function Persister_persist_scorer(this_arg: bigint, scorer: bigint): bigint {
6417 if(!isWasmInitialized) {
6418 throw new Error("initializeWasm() must be awaited first!");
6420 const nativeResponseValue = wasm.TS_Persister_persist_scorer(this_arg, scorer);
6421 return nativeResponseValue;
6424 export interface LDKFutureCallback {
6429 export function LDKFutureCallback_new(impl: LDKFutureCallback): [bigint, number] {
6430 if(!isWasmInitialized) {
6431 throw new Error("initializeWasm() must be awaited first!");
6433 var new_obj_idx = js_objs.length;
6434 for (var i = 0; i < js_objs.length; i++) {
6435 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6437 js_objs[i] = new WeakRef(impl);
6438 return [wasm.TS_LDKFutureCallback_new(i), i];
6440 // void FutureCallback_call LDKFutureCallback *NONNULL_PTR this_arg
6442 export function FutureCallback_call(this_arg: bigint): void {
6443 if(!isWasmInitialized) {
6444 throw new Error("initializeWasm() must be awaited first!");
6446 const nativeResponseValue = wasm.TS_FutureCallback_call(this_arg);
6447 // debug statements here
6450 export interface LDKListen {
6451 filtered_block_connected (header: number, txdata: number, height: number): void;
6452 block_connected (block: number, height: number): void;
6453 block_disconnected (header: number, height: number): void;
6457 export function LDKListen_new(impl: LDKListen): [bigint, number] {
6458 if(!isWasmInitialized) {
6459 throw new Error("initializeWasm() must be awaited first!");
6461 var new_obj_idx = js_objs.length;
6462 for (var i = 0; i < js_objs.length; i++) {
6463 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6465 js_objs[i] = new WeakRef(impl);
6466 return [wasm.TS_LDKListen_new(i), i];
6468 // void Listen_filtered_block_connected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
6470 export function Listen_filtered_block_connected(this_arg: bigint, header: number, txdata: number, height: number): void {
6471 if(!isWasmInitialized) {
6472 throw new Error("initializeWasm() must be awaited first!");
6474 const nativeResponseValue = wasm.TS_Listen_filtered_block_connected(this_arg, header, txdata, height);
6475 // debug statements here
6477 // void Listen_block_connected LDKListen *NONNULL_PTR this_arg, struct LDKu8slice block, uint32_t height
6479 export function Listen_block_connected(this_arg: bigint, block: number, height: number): void {
6480 if(!isWasmInitialized) {
6481 throw new Error("initializeWasm() must be awaited first!");
6483 const nativeResponseValue = wasm.TS_Listen_block_connected(this_arg, block, height);
6484 // debug statements here
6486 // void Listen_block_disconnected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
6488 export function Listen_block_disconnected(this_arg: bigint, header: number, height: number): void {
6489 if(!isWasmInitialized) {
6490 throw new Error("initializeWasm() must be awaited first!");
6492 const nativeResponseValue = wasm.TS_Listen_block_disconnected(this_arg, header, height);
6493 // debug statements here
6496 export interface LDKConfirm {
6497 transactions_confirmed (header: number, txdata: number, height: number): void;
6498 transaction_unconfirmed (txid: number): void;
6499 best_block_updated (header: number, height: number): void;
6500 get_relevant_txids (): number;
6504 export function LDKConfirm_new(impl: LDKConfirm): [bigint, number] {
6505 if(!isWasmInitialized) {
6506 throw new Error("initializeWasm() must be awaited first!");
6508 var new_obj_idx = js_objs.length;
6509 for (var i = 0; i < js_objs.length; i++) {
6510 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6512 js_objs[i] = new WeakRef(impl);
6513 return [wasm.TS_LDKConfirm_new(i), i];
6515 // void Confirm_transactions_confirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
6517 export function Confirm_transactions_confirmed(this_arg: bigint, header: number, txdata: number, height: number): void {
6518 if(!isWasmInitialized) {
6519 throw new Error("initializeWasm() must be awaited first!");
6521 const nativeResponseValue = wasm.TS_Confirm_transactions_confirmed(this_arg, header, txdata, height);
6522 // debug statements here
6524 // void Confirm_transaction_unconfirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*txid)[32]
6526 export function Confirm_transaction_unconfirmed(this_arg: bigint, txid: number): void {
6527 if(!isWasmInitialized) {
6528 throw new Error("initializeWasm() must be awaited first!");
6530 const nativeResponseValue = wasm.TS_Confirm_transaction_unconfirmed(this_arg, txid);
6531 // debug statements here
6533 // void Confirm_best_block_updated LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
6535 export function Confirm_best_block_updated(this_arg: bigint, header: number, height: number): void {
6536 if(!isWasmInitialized) {
6537 throw new Error("initializeWasm() must be awaited first!");
6539 const nativeResponseValue = wasm.TS_Confirm_best_block_updated(this_arg, header, height);
6540 // debug statements here
6542 // LDKCVec_TxidZ Confirm_get_relevant_txids LDKConfirm *NONNULL_PTR this_arg
6544 export function Confirm_get_relevant_txids(this_arg: bigint): number {
6545 if(!isWasmInitialized) {
6546 throw new Error("initializeWasm() must be awaited first!");
6548 const nativeResponseValue = wasm.TS_Confirm_get_relevant_txids(this_arg);
6549 return nativeResponseValue;
6552 export interface LDKPersist {
6553 persist_new_channel (channel_id: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus;
6554 update_persisted_channel (channel_id: bigint, update: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus;
6558 export function LDKPersist_new(impl: LDKPersist): [bigint, number] {
6559 if(!isWasmInitialized) {
6560 throw new Error("initializeWasm() must be awaited first!");
6562 var new_obj_idx = js_objs.length;
6563 for (var i = 0; i < js_objs.length; i++) {
6564 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6566 js_objs[i] = new WeakRef(impl);
6567 return [wasm.TS_LDKPersist_new(i), i];
6569 // LDKChannelMonitorUpdateStatus Persist_persist_new_channel LDKPersist *NONNULL_PTR this_arg, struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id
6571 export function Persist_persist_new_channel(this_arg: bigint, channel_id: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus {
6572 if(!isWasmInitialized) {
6573 throw new Error("initializeWasm() must be awaited first!");
6575 const nativeResponseValue = wasm.TS_Persist_persist_new_channel(this_arg, channel_id, data, update_id);
6576 return nativeResponseValue;
6578 // LDKChannelMonitorUpdateStatus 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
6580 export function Persist_update_persisted_channel(this_arg: bigint, channel_id: bigint, update: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus {
6581 if(!isWasmInitialized) {
6582 throw new Error("initializeWasm() must be awaited first!");
6584 const nativeResponseValue = wasm.TS_Persist_update_persisted_channel(this_arg, channel_id, update, data, update_id);
6585 return nativeResponseValue;
6588 export interface LDKChannelMessageHandler {
6589 handle_open_channel (their_node_id: number, their_features: bigint, msg: bigint): void;
6590 handle_accept_channel (their_node_id: number, their_features: bigint, msg: bigint): void;
6591 handle_funding_created (their_node_id: number, msg: bigint): void;
6592 handle_funding_signed (their_node_id: number, msg: bigint): void;
6593 handle_channel_ready (their_node_id: number, msg: bigint): void;
6594 handle_shutdown (their_node_id: number, their_features: bigint, msg: bigint): void;
6595 handle_closing_signed (their_node_id: number, msg: bigint): void;
6596 handle_update_add_htlc (their_node_id: number, msg: bigint): void;
6597 handle_update_fulfill_htlc (their_node_id: number, msg: bigint): void;
6598 handle_update_fail_htlc (their_node_id: number, msg: bigint): void;
6599 handle_update_fail_malformed_htlc (their_node_id: number, msg: bigint): void;
6600 handle_commitment_signed (their_node_id: number, msg: bigint): void;
6601 handle_revoke_and_ack (their_node_id: number, msg: bigint): void;
6602 handle_update_fee (their_node_id: number, msg: bigint): void;
6603 handle_announcement_signatures (their_node_id: number, msg: bigint): void;
6604 peer_disconnected (their_node_id: number, no_connection_possible: boolean): void;
6605 peer_connected (their_node_id: number, msg: bigint): bigint;
6606 handle_channel_reestablish (their_node_id: number, msg: bigint): void;
6607 handle_channel_update (their_node_id: number, msg: bigint): void;
6608 handle_error (their_node_id: number, msg: bigint): void;
6609 provided_node_features (): bigint;
6610 provided_init_features (their_node_id: number): bigint;
6614 export function LDKChannelMessageHandler_new(impl: LDKChannelMessageHandler, MessageSendEventsProvider: number): [bigint, number] {
6615 if(!isWasmInitialized) {
6616 throw new Error("initializeWasm() must be awaited first!");
6618 var new_obj_idx = js_objs.length;
6619 for (var i = 0; i < js_objs.length; i++) {
6620 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6622 js_objs[i] = new WeakRef(impl);
6623 return [wasm.TS_LDKChannelMessageHandler_new(i, MessageSendEventsProvider), i];
6625 // 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
6627 export function ChannelMessageHandler_handle_open_channel(this_arg: bigint, their_node_id: number, their_features: bigint, msg: bigint): void {
6628 if(!isWasmInitialized) {
6629 throw new Error("initializeWasm() must be awaited first!");
6631 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_open_channel(this_arg, their_node_id, their_features, msg);
6632 // debug statements here
6634 // 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
6636 export function ChannelMessageHandler_handle_accept_channel(this_arg: bigint, their_node_id: number, their_features: bigint, msg: bigint): void {
6637 if(!isWasmInitialized) {
6638 throw new Error("initializeWasm() must be awaited first!");
6640 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_accept_channel(this_arg, their_node_id, their_features, msg);
6641 // debug statements here
6643 // void ChannelMessageHandler_handle_funding_created LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg
6645 export function ChannelMessageHandler_handle_funding_created(this_arg: bigint, their_node_id: number, msg: bigint): void {
6646 if(!isWasmInitialized) {
6647 throw new Error("initializeWasm() must be awaited first!");
6649 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_created(this_arg, their_node_id, msg);
6650 // debug statements here
6652 // void ChannelMessageHandler_handle_funding_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg
6654 export function ChannelMessageHandler_handle_funding_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
6655 if(!isWasmInitialized) {
6656 throw new Error("initializeWasm() must be awaited first!");
6658 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_signed(this_arg, their_node_id, msg);
6659 // debug statements here
6661 // void ChannelMessageHandler_handle_channel_ready LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg
6663 export function ChannelMessageHandler_handle_channel_ready(this_arg: bigint, their_node_id: number, msg: bigint): void {
6664 if(!isWasmInitialized) {
6665 throw new Error("initializeWasm() must be awaited first!");
6667 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_ready(this_arg, their_node_id, msg);
6668 // debug statements here
6670 // 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
6672 export function ChannelMessageHandler_handle_shutdown(this_arg: bigint, their_node_id: number, their_features: bigint, msg: bigint): void {
6673 if(!isWasmInitialized) {
6674 throw new Error("initializeWasm() must be awaited first!");
6676 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_shutdown(this_arg, their_node_id, their_features, msg);
6677 // debug statements here
6679 // void ChannelMessageHandler_handle_closing_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg
6681 export function ChannelMessageHandler_handle_closing_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
6682 if(!isWasmInitialized) {
6683 throw new Error("initializeWasm() must be awaited first!");
6685 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_closing_signed(this_arg, their_node_id, msg);
6686 // debug statements here
6688 // void ChannelMessageHandler_handle_update_add_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg
6690 export function ChannelMessageHandler_handle_update_add_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
6691 if(!isWasmInitialized) {
6692 throw new Error("initializeWasm() must be awaited first!");
6694 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_add_htlc(this_arg, their_node_id, msg);
6695 // debug statements here
6697 // void ChannelMessageHandler_handle_update_fulfill_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg
6699 export function ChannelMessageHandler_handle_update_fulfill_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
6700 if(!isWasmInitialized) {
6701 throw new Error("initializeWasm() must be awaited first!");
6703 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fulfill_htlc(this_arg, their_node_id, msg);
6704 // debug statements here
6706 // void ChannelMessageHandler_handle_update_fail_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg
6708 export function ChannelMessageHandler_handle_update_fail_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
6709 if(!isWasmInitialized) {
6710 throw new Error("initializeWasm() must be awaited first!");
6712 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_htlc(this_arg, their_node_id, msg);
6713 // debug statements here
6715 // void ChannelMessageHandler_handle_update_fail_malformed_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg
6717 export function ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
6718 if(!isWasmInitialized) {
6719 throw new Error("initializeWasm() must be awaited first!");
6721 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg, their_node_id, msg);
6722 // debug statements here
6724 // void ChannelMessageHandler_handle_commitment_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg
6726 export function ChannelMessageHandler_handle_commitment_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
6727 if(!isWasmInitialized) {
6728 throw new Error("initializeWasm() must be awaited first!");
6730 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_commitment_signed(this_arg, their_node_id, msg);
6731 // debug statements here
6733 // void ChannelMessageHandler_handle_revoke_and_ack LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg
6735 export function ChannelMessageHandler_handle_revoke_and_ack(this_arg: bigint, their_node_id: number, msg: bigint): void {
6736 if(!isWasmInitialized) {
6737 throw new Error("initializeWasm() must be awaited first!");
6739 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_revoke_and_ack(this_arg, their_node_id, msg);
6740 // debug statements here
6742 // void ChannelMessageHandler_handle_update_fee LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg
6744 export function ChannelMessageHandler_handle_update_fee(this_arg: bigint, their_node_id: number, msg: bigint): void {
6745 if(!isWasmInitialized) {
6746 throw new Error("initializeWasm() must be awaited first!");
6748 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fee(this_arg, their_node_id, msg);
6749 // debug statements here
6751 // void ChannelMessageHandler_handle_announcement_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg
6753 export function ChannelMessageHandler_handle_announcement_signatures(this_arg: bigint, their_node_id: number, msg: bigint): void {
6754 if(!isWasmInitialized) {
6755 throw new Error("initializeWasm() must be awaited first!");
6757 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_announcement_signatures(this_arg, their_node_id, msg);
6758 // debug statements here
6760 // void ChannelMessageHandler_peer_disconnected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, bool no_connection_possible
6762 export function ChannelMessageHandler_peer_disconnected(this_arg: bigint, their_node_id: number, no_connection_possible: boolean): void {
6763 if(!isWasmInitialized) {
6764 throw new Error("initializeWasm() must be awaited first!");
6766 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_disconnected(this_arg, their_node_id, no_connection_possible);
6767 // debug statements here
6769 // LDKCResult_NoneNoneZ ChannelMessageHandler_peer_connected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg
6771 export function ChannelMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
6772 if(!isWasmInitialized) {
6773 throw new Error("initializeWasm() must be awaited first!");
6775 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_connected(this_arg, their_node_id, msg);
6776 return nativeResponseValue;
6778 // void ChannelMessageHandler_handle_channel_reestablish LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg
6780 export function ChannelMessageHandler_handle_channel_reestablish(this_arg: bigint, their_node_id: number, msg: bigint): void {
6781 if(!isWasmInitialized) {
6782 throw new Error("initializeWasm() must be awaited first!");
6784 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_reestablish(this_arg, their_node_id, msg);
6785 // debug statements here
6787 // void ChannelMessageHandler_handle_channel_update LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg
6789 export function ChannelMessageHandler_handle_channel_update(this_arg: bigint, their_node_id: number, msg: bigint): void {
6790 if(!isWasmInitialized) {
6791 throw new Error("initializeWasm() must be awaited first!");
6793 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_update(this_arg, their_node_id, msg);
6794 // debug statements here
6796 // void ChannelMessageHandler_handle_error LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
6798 export function ChannelMessageHandler_handle_error(this_arg: bigint, their_node_id: number, msg: bigint): void {
6799 if(!isWasmInitialized) {
6800 throw new Error("initializeWasm() must be awaited first!");
6802 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_error(this_arg, their_node_id, msg);
6803 // debug statements here
6805 // LDKNodeFeatures ChannelMessageHandler_provided_node_features LDKChannelMessageHandler *NONNULL_PTR this_arg
6807 export function ChannelMessageHandler_provided_node_features(this_arg: bigint): bigint {
6808 if(!isWasmInitialized) {
6809 throw new Error("initializeWasm() must be awaited first!");
6811 const nativeResponseValue = wasm.TS_ChannelMessageHandler_provided_node_features(this_arg);
6812 return nativeResponseValue;
6814 // LDKInitFeatures ChannelMessageHandler_provided_init_features LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
6816 export function ChannelMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
6817 if(!isWasmInitialized) {
6818 throw new Error("initializeWasm() must be awaited first!");
6820 const nativeResponseValue = wasm.TS_ChannelMessageHandler_provided_init_features(this_arg, their_node_id);
6821 return nativeResponseValue;
6824 export interface LDKRoutingMessageHandler {
6825 handle_node_announcement (msg: bigint): bigint;
6826 handle_channel_announcement (msg: bigint): bigint;
6827 handle_channel_update (msg: bigint): bigint;
6828 get_next_channel_announcement (starting_point: bigint): bigint;
6829 get_next_node_announcement (starting_point: number): bigint;
6830 peer_connected (their_node_id: number, init: bigint): bigint;
6831 handle_reply_channel_range (their_node_id: number, msg: bigint): bigint;
6832 handle_reply_short_channel_ids_end (their_node_id: number, msg: bigint): bigint;
6833 handle_query_channel_range (their_node_id: number, msg: bigint): bigint;
6834 handle_query_short_channel_ids (their_node_id: number, msg: bigint): bigint;
6835 provided_node_features (): bigint;
6836 provided_init_features (their_node_id: number): bigint;
6840 export function LDKRoutingMessageHandler_new(impl: LDKRoutingMessageHandler, MessageSendEventsProvider: number): [bigint, number] {
6841 if(!isWasmInitialized) {
6842 throw new Error("initializeWasm() must be awaited first!");
6844 var new_obj_idx = js_objs.length;
6845 for (var i = 0; i < js_objs.length; i++) {
6846 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6848 js_objs[i] = new WeakRef(impl);
6849 return [wasm.TS_LDKRoutingMessageHandler_new(i, MessageSendEventsProvider), i];
6851 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg
6853 export function RoutingMessageHandler_handle_node_announcement(this_arg: bigint, msg: bigint): bigint {
6854 if(!isWasmInitialized) {
6855 throw new Error("initializeWasm() must be awaited first!");
6857 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_node_announcement(this_arg, msg);
6858 return nativeResponseValue;
6860 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg
6862 export function RoutingMessageHandler_handle_channel_announcement(this_arg: bigint, msg: bigint): bigint {
6863 if(!isWasmInitialized) {
6864 throw new Error("initializeWasm() must be awaited first!");
6866 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_announcement(this_arg, msg);
6867 return nativeResponseValue;
6869 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_update LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg
6871 export function RoutingMessageHandler_handle_channel_update(this_arg: bigint, msg: bigint): bigint {
6872 if(!isWasmInitialized) {
6873 throw new Error("initializeWasm() must be awaited first!");
6875 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_update(this_arg, msg);
6876 return nativeResponseValue;
6878 // LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler_get_next_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, uint64_t starting_point
6880 export function RoutingMessageHandler_get_next_channel_announcement(this_arg: bigint, starting_point: bigint): bigint {
6881 if(!isWasmInitialized) {
6882 throw new Error("initializeWasm() must be awaited first!");
6884 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_channel_announcement(this_arg, starting_point);
6885 return nativeResponseValue;
6887 // LDKNodeAnnouncement RoutingMessageHandler_get_next_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey starting_point
6889 export function RoutingMessageHandler_get_next_node_announcement(this_arg: bigint, starting_point: number): bigint {
6890 if(!isWasmInitialized) {
6891 throw new Error("initializeWasm() must be awaited first!");
6893 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_node_announcement(this_arg, starting_point);
6894 return nativeResponseValue;
6896 // LDKCResult_NoneNoneZ RoutingMessageHandler_peer_connected LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init
6898 export function RoutingMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, init: bigint): bigint {
6899 if(!isWasmInitialized) {
6900 throw new Error("initializeWasm() must be awaited first!");
6902 const nativeResponseValue = wasm.TS_RoutingMessageHandler_peer_connected(this_arg, their_node_id, init);
6903 return nativeResponseValue;
6905 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg
6907 export function RoutingMessageHandler_handle_reply_channel_range(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
6908 if(!isWasmInitialized) {
6909 throw new Error("initializeWasm() must be awaited first!");
6911 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_channel_range(this_arg, their_node_id, msg);
6912 return nativeResponseValue;
6914 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_short_channel_ids_end LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg
6916 export function RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
6917 if(!isWasmInitialized) {
6918 throw new Error("initializeWasm() must be awaited first!");
6920 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg, their_node_id, msg);
6921 return nativeResponseValue;
6923 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg
6925 export function RoutingMessageHandler_handle_query_channel_range(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
6926 if(!isWasmInitialized) {
6927 throw new Error("initializeWasm() must be awaited first!");
6929 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_channel_range(this_arg, their_node_id, msg);
6930 return nativeResponseValue;
6932 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_short_channel_ids LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg
6934 export function RoutingMessageHandler_handle_query_short_channel_ids(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
6935 if(!isWasmInitialized) {
6936 throw new Error("initializeWasm() must be awaited first!");
6938 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_short_channel_ids(this_arg, their_node_id, msg);
6939 return nativeResponseValue;
6941 // LDKNodeFeatures RoutingMessageHandler_provided_node_features LDKRoutingMessageHandler *NONNULL_PTR this_arg
6943 export function RoutingMessageHandler_provided_node_features(this_arg: bigint): bigint {
6944 if(!isWasmInitialized) {
6945 throw new Error("initializeWasm() must be awaited first!");
6947 const nativeResponseValue = wasm.TS_RoutingMessageHandler_provided_node_features(this_arg);
6948 return nativeResponseValue;
6950 // LDKInitFeatures RoutingMessageHandler_provided_init_features LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
6952 export function RoutingMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
6953 if(!isWasmInitialized) {
6954 throw new Error("initializeWasm() must be awaited first!");
6956 const nativeResponseValue = wasm.TS_RoutingMessageHandler_provided_init_features(this_arg, their_node_id);
6957 return nativeResponseValue;
6960 export interface LDKOnionMessageHandler {
6961 handle_onion_message (peer_node_id: number, msg: bigint): void;
6962 peer_connected (their_node_id: number, init: bigint): bigint;
6963 peer_disconnected (their_node_id: number, no_connection_possible: boolean): void;
6964 provided_node_features (): bigint;
6965 provided_init_features (their_node_id: number): bigint;
6969 export function LDKOnionMessageHandler_new(impl: LDKOnionMessageHandler, OnionMessageProvider: number): [bigint, number] {
6970 if(!isWasmInitialized) {
6971 throw new Error("initializeWasm() must be awaited first!");
6973 var new_obj_idx = js_objs.length;
6974 for (var i = 0; i < js_objs.length; i++) {
6975 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6977 js_objs[i] = new WeakRef(impl);
6978 return [wasm.TS_LDKOnionMessageHandler_new(i, OnionMessageProvider), i];
6980 // void OnionMessageHandler_handle_onion_message LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg
6982 export function OnionMessageHandler_handle_onion_message(this_arg: bigint, peer_node_id: number, msg: bigint): void {
6983 if(!isWasmInitialized) {
6984 throw new Error("initializeWasm() must be awaited first!");
6986 const nativeResponseValue = wasm.TS_OnionMessageHandler_handle_onion_message(this_arg, peer_node_id, msg);
6987 // debug statements here
6989 // LDKCResult_NoneNoneZ OnionMessageHandler_peer_connected LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init
6991 export function OnionMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, init: bigint): bigint {
6992 if(!isWasmInitialized) {
6993 throw new Error("initializeWasm() must be awaited first!");
6995 const nativeResponseValue = wasm.TS_OnionMessageHandler_peer_connected(this_arg, their_node_id, init);
6996 return nativeResponseValue;
6998 // void OnionMessageHandler_peer_disconnected LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, bool no_connection_possible
7000 export function OnionMessageHandler_peer_disconnected(this_arg: bigint, their_node_id: number, no_connection_possible: boolean): void {
7001 if(!isWasmInitialized) {
7002 throw new Error("initializeWasm() must be awaited first!");
7004 const nativeResponseValue = wasm.TS_OnionMessageHandler_peer_disconnected(this_arg, their_node_id, no_connection_possible);
7005 // debug statements here
7007 // LDKNodeFeatures OnionMessageHandler_provided_node_features LDKOnionMessageHandler *NONNULL_PTR this_arg
7009 export function OnionMessageHandler_provided_node_features(this_arg: bigint): bigint {
7010 if(!isWasmInitialized) {
7011 throw new Error("initializeWasm() must be awaited first!");
7013 const nativeResponseValue = wasm.TS_OnionMessageHandler_provided_node_features(this_arg);
7014 return nativeResponseValue;
7016 // LDKInitFeatures OnionMessageHandler_provided_init_features LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
7018 export function OnionMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
7019 if(!isWasmInitialized) {
7020 throw new Error("initializeWasm() must be awaited first!");
7022 const nativeResponseValue = wasm.TS_OnionMessageHandler_provided_init_features(this_arg, their_node_id);
7023 return nativeResponseValue;
7026 export interface LDKCustomMessageReader {
7027 read (message_type: number, buffer: number): bigint;
7031 export function LDKCustomMessageReader_new(impl: LDKCustomMessageReader): [bigint, number] {
7032 if(!isWasmInitialized) {
7033 throw new Error("initializeWasm() must be awaited first!");
7035 var new_obj_idx = js_objs.length;
7036 for (var i = 0; i < js_objs.length; i++) {
7037 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7039 js_objs[i] = new WeakRef(impl);
7040 return [wasm.TS_LDKCustomMessageReader_new(i), i];
7042 // LDKCResult_COption_TypeZDecodeErrorZ CustomMessageReader_read LDKCustomMessageReader *NONNULL_PTR this_arg, uint16_t message_type, struct LDKu8slice buffer
7044 export function CustomMessageReader_read(this_arg: bigint, message_type: number, buffer: number): bigint {
7045 if(!isWasmInitialized) {
7046 throw new Error("initializeWasm() must be awaited first!");
7048 const nativeResponseValue = wasm.TS_CustomMessageReader_read(this_arg, message_type, buffer);
7049 return nativeResponseValue;
7052 export interface LDKCustomMessageHandler {
7053 handle_custom_message (msg: bigint, sender_node_id: number): bigint;
7054 get_and_clear_pending_msg (): number;
7058 export function LDKCustomMessageHandler_new(impl: LDKCustomMessageHandler, CustomMessageReader: number): [bigint, number] {
7059 if(!isWasmInitialized) {
7060 throw new Error("initializeWasm() must be awaited first!");
7062 var new_obj_idx = js_objs.length;
7063 for (var i = 0; i < js_objs.length; i++) {
7064 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7066 js_objs[i] = new WeakRef(impl);
7067 return [wasm.TS_LDKCustomMessageHandler_new(i, CustomMessageReader), i];
7069 // LDKCResult_NoneLightningErrorZ CustomMessageHandler_handle_custom_message LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKType msg, struct LDKPublicKey sender_node_id
7071 export function CustomMessageHandler_handle_custom_message(this_arg: bigint, msg: bigint, sender_node_id: number): bigint {
7072 if(!isWasmInitialized) {
7073 throw new Error("initializeWasm() must be awaited first!");
7075 const nativeResponseValue = wasm.TS_CustomMessageHandler_handle_custom_message(this_arg, msg, sender_node_id);
7076 return nativeResponseValue;
7078 // LDKCVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler_get_and_clear_pending_msg LDKCustomMessageHandler *NONNULL_PTR this_arg
7080 export function CustomMessageHandler_get_and_clear_pending_msg(this_arg: bigint): number {
7081 if(!isWasmInitialized) {
7082 throw new Error("initializeWasm() must be awaited first!");
7084 const nativeResponseValue = wasm.TS_CustomMessageHandler_get_and_clear_pending_msg(this_arg);
7085 return nativeResponseValue;
7088 export interface LDKCustomOnionMessageHandler {
7089 handle_custom_message (msg: bigint): void;
7090 read_custom_message (message_type: bigint, buffer: number): bigint;
7094 export function LDKCustomOnionMessageHandler_new(impl: LDKCustomOnionMessageHandler): [bigint, number] {
7095 if(!isWasmInitialized) {
7096 throw new Error("initializeWasm() must be awaited first!");
7098 var new_obj_idx = js_objs.length;
7099 for (var i = 0; i < js_objs.length; i++) {
7100 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7102 js_objs[i] = new WeakRef(impl);
7103 return [wasm.TS_LDKCustomOnionMessageHandler_new(i), i];
7105 // void CustomOnionMessageHandler_handle_custom_message LDKCustomOnionMessageHandler *NONNULL_PTR this_arg, struct LDKCustomOnionMessageContents msg
7107 export function CustomOnionMessageHandler_handle_custom_message(this_arg: bigint, msg: bigint): void {
7108 if(!isWasmInitialized) {
7109 throw new Error("initializeWasm() must be awaited first!");
7111 const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_handle_custom_message(this_arg, msg);
7112 // debug statements here
7114 // LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ CustomOnionMessageHandler_read_custom_message LDKCustomOnionMessageHandler *NONNULL_PTR this_arg, uint64_t message_type, struct LDKu8slice buffer
7116 export function CustomOnionMessageHandler_read_custom_message(this_arg: bigint, message_type: bigint, buffer: number): bigint {
7117 if(!isWasmInitialized) {
7118 throw new Error("initializeWasm() must be awaited first!");
7120 const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_read_custom_message(this_arg, message_type, buffer);
7121 return nativeResponseValue;
7124 export interface LDKSocketDescriptor {
7125 send_data (data: number, resume_read: boolean): number;
7126 disconnect_socket (): void;
7127 eq (other_arg: bigint): boolean;
7132 export function LDKSocketDescriptor_new(impl: LDKSocketDescriptor): [bigint, number] {
7133 if(!isWasmInitialized) {
7134 throw new Error("initializeWasm() must be awaited first!");
7136 var new_obj_idx = js_objs.length;
7137 for (var i = 0; i < js_objs.length; i++) {
7138 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7140 js_objs[i] = new WeakRef(impl);
7141 return [wasm.TS_LDKSocketDescriptor_new(i), i];
7143 // uintptr_t SocketDescriptor_send_data LDKSocketDescriptor *NONNULL_PTR this_arg, struct LDKu8slice data, bool resume_read
7145 export function SocketDescriptor_send_data(this_arg: bigint, data: number, resume_read: boolean): number {
7146 if(!isWasmInitialized) {
7147 throw new Error("initializeWasm() must be awaited first!");
7149 const nativeResponseValue = wasm.TS_SocketDescriptor_send_data(this_arg, data, resume_read);
7150 return nativeResponseValue;
7152 // void SocketDescriptor_disconnect_socket LDKSocketDescriptor *NONNULL_PTR this_arg
7154 export function SocketDescriptor_disconnect_socket(this_arg: bigint): void {
7155 if(!isWasmInitialized) {
7156 throw new Error("initializeWasm() must be awaited first!");
7158 const nativeResponseValue = wasm.TS_SocketDescriptor_disconnect_socket(this_arg);
7159 // debug statements here
7161 // uint64_t SocketDescriptor_hash LDKSocketDescriptor *NONNULL_PTR this_arg
7163 export function SocketDescriptor_hash(this_arg: bigint): bigint {
7164 if(!isWasmInitialized) {
7165 throw new Error("initializeWasm() must be awaited first!");
7167 const nativeResponseValue = wasm.TS_SocketDescriptor_hash(this_arg);
7168 return nativeResponseValue;
7171 export class LDKEffectiveCapacity {
7172 protected constructor() {}
7175 export function LDKEffectiveCapacity_ty_from_ptr(ptr: bigint): number {
7176 if(!isWasmInitialized) {
7177 throw new Error("initializeWasm() must be awaited first!");
7179 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ty_from_ptr(ptr);
7180 return nativeResponseValue;
7183 export function LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr: bigint): bigint {
7184 if(!isWasmInitialized) {
7185 throw new Error("initializeWasm() must be awaited first!");
7187 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr);
7188 return nativeResponseValue;
7191 export function LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr: bigint): bigint {
7192 if(!isWasmInitialized) {
7193 throw new Error("initializeWasm() must be awaited first!");
7195 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr);
7196 return nativeResponseValue;
7199 export function LDKEffectiveCapacity_Total_get_capacity_msat(ptr: bigint): bigint {
7200 if(!isWasmInitialized) {
7201 throw new Error("initializeWasm() must be awaited first!");
7203 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_capacity_msat(ptr);
7204 return nativeResponseValue;
7207 export function LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr: bigint): bigint {
7208 if(!isWasmInitialized) {
7209 throw new Error("initializeWasm() must be awaited first!");
7211 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr);
7212 return nativeResponseValue;
7215 export class LDKDestination {
7216 protected constructor() {}
7219 export function LDKDestination_ty_from_ptr(ptr: bigint): number {
7220 if(!isWasmInitialized) {
7221 throw new Error("initializeWasm() must be awaited first!");
7223 const nativeResponseValue = wasm.TS_LDKDestination_ty_from_ptr(ptr);
7224 return nativeResponseValue;
7227 export function LDKDestination_Node_get_node(ptr: bigint): number {
7228 if(!isWasmInitialized) {
7229 throw new Error("initializeWasm() must be awaited first!");
7231 const nativeResponseValue = wasm.TS_LDKDestination_Node_get_node(ptr);
7232 return nativeResponseValue;
7235 export function LDKDestination_BlindedRoute_get_blinded_route(ptr: bigint): bigint {
7236 if(!isWasmInitialized) {
7237 throw new Error("initializeWasm() must be awaited first!");
7239 const nativeResponseValue = wasm.TS_LDKDestination_BlindedRoute_get_blinded_route(ptr);
7240 return nativeResponseValue;
7243 export class LDKFallback {
7244 protected constructor() {}
7247 export function LDKFallback_ty_from_ptr(ptr: bigint): number {
7248 if(!isWasmInitialized) {
7249 throw new Error("initializeWasm() must be awaited first!");
7251 const nativeResponseValue = wasm.TS_LDKFallback_ty_from_ptr(ptr);
7252 return nativeResponseValue;
7255 export function LDKFallback_SegWitProgram_get_version(ptr: bigint): number {
7256 if(!isWasmInitialized) {
7257 throw new Error("initializeWasm() must be awaited first!");
7259 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_version(ptr);
7260 return nativeResponseValue;
7263 export function LDKFallback_SegWitProgram_get_program(ptr: bigint): number {
7264 if(!isWasmInitialized) {
7265 throw new Error("initializeWasm() must be awaited first!");
7267 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_program(ptr);
7268 return nativeResponseValue;
7271 export function LDKFallback_PubKeyHash_get_pub_key_hash(ptr: bigint): number {
7272 if(!isWasmInitialized) {
7273 throw new Error("initializeWasm() must be awaited first!");
7275 const nativeResponseValue = wasm.TS_LDKFallback_PubKeyHash_get_pub_key_hash(ptr);
7276 return nativeResponseValue;
7279 export function LDKFallback_ScriptHash_get_script_hash(ptr: bigint): number {
7280 if(!isWasmInitialized) {
7281 throw new Error("initializeWasm() must be awaited first!");
7283 const nativeResponseValue = wasm.TS_LDKFallback_ScriptHash_get_script_hash(ptr);
7284 return nativeResponseValue;
7287 export interface LDKPayer {
7289 first_hops (): number;
7290 send_payment (route: bigint, payment_hash: number, payment_secret: number): bigint;
7291 send_spontaneous_payment (route: bigint, payment_preimage: number): bigint;
7292 retry_payment (route: bigint, payment_id: number): bigint;
7293 abandon_payment (payment_id: number): void;
7297 export function LDKPayer_new(impl: LDKPayer): [bigint, number] {
7298 if(!isWasmInitialized) {
7299 throw new Error("initializeWasm() must be awaited first!");
7301 var new_obj_idx = js_objs.length;
7302 for (var i = 0; i < js_objs.length; i++) {
7303 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7305 js_objs[i] = new WeakRef(impl);
7306 return [wasm.TS_LDKPayer_new(i), i];
7308 // LDKPublicKey Payer_node_id LDKPayer *NONNULL_PTR this_arg
7310 export function Payer_node_id(this_arg: bigint): number {
7311 if(!isWasmInitialized) {
7312 throw new Error("initializeWasm() must be awaited first!");
7314 const nativeResponseValue = wasm.TS_Payer_node_id(this_arg);
7315 return nativeResponseValue;
7317 // LDKCVec_ChannelDetailsZ Payer_first_hops LDKPayer *NONNULL_PTR this_arg
7319 export function Payer_first_hops(this_arg: bigint): number {
7320 if(!isWasmInitialized) {
7321 throw new Error("initializeWasm() must be awaited first!");
7323 const nativeResponseValue = wasm.TS_Payer_first_hops(this_arg);
7324 return nativeResponseValue;
7326 // LDKCResult_PaymentIdPaymentSendFailureZ Payer_send_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret
7328 export function Payer_send_payment(this_arg: bigint, route: bigint, payment_hash: number, payment_secret: number): bigint {
7329 if(!isWasmInitialized) {
7330 throw new Error("initializeWasm() must be awaited first!");
7332 const nativeResponseValue = wasm.TS_Payer_send_payment(this_arg, route, payment_hash, payment_secret);
7333 return nativeResponseValue;
7335 // LDKCResult_PaymentIdPaymentSendFailureZ Payer_send_spontaneous_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage
7337 export function Payer_send_spontaneous_payment(this_arg: bigint, route: bigint, payment_preimage: number): bigint {
7338 if(!isWasmInitialized) {
7339 throw new Error("initializeWasm() must be awaited first!");
7341 const nativeResponseValue = wasm.TS_Payer_send_spontaneous_payment(this_arg, route, payment_preimage);
7342 return nativeResponseValue;
7344 // LDKCResult_NonePaymentSendFailureZ Payer_retry_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_id
7346 export function Payer_retry_payment(this_arg: bigint, route: bigint, payment_id: number): bigint {
7347 if(!isWasmInitialized) {
7348 throw new Error("initializeWasm() must be awaited first!");
7350 const nativeResponseValue = wasm.TS_Payer_retry_payment(this_arg, route, payment_id);
7351 return nativeResponseValue;
7353 // void Payer_abandon_payment LDKPayer *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id
7355 export function Payer_abandon_payment(this_arg: bigint, payment_id: number): void {
7356 if(!isWasmInitialized) {
7357 throw new Error("initializeWasm() must be awaited first!");
7359 const nativeResponseValue = wasm.TS_Payer_abandon_payment(this_arg, payment_id);
7360 // debug statements here
7363 export interface LDKRouter {
7364 find_route (payer: number, route_params: bigint, payment_hash: number, first_hops: number, inflight_htlcs: bigint): bigint;
7365 notify_payment_path_failed (path: number, short_channel_id: bigint): void;
7366 notify_payment_path_successful (path: number): void;
7367 notify_payment_probe_successful (path: number): void;
7368 notify_payment_probe_failed (path: number, short_channel_id: bigint): void;
7372 export function LDKRouter_new(impl: LDKRouter): [bigint, number] {
7373 if(!isWasmInitialized) {
7374 throw new Error("initializeWasm() must be awaited first!");
7376 var new_obj_idx = js_objs.length;
7377 for (var i = 0; i < js_objs.length; i++) {
7378 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7380 js_objs[i] = new WeakRef(impl);
7381 return [wasm.TS_LDKRouter_new(i), i];
7383 // 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
7385 export function Router_find_route(this_arg: bigint, payer: number, route_params: bigint, payment_hash: number, first_hops: number, inflight_htlcs: bigint): bigint {
7386 if(!isWasmInitialized) {
7387 throw new Error("initializeWasm() must be awaited first!");
7389 const nativeResponseValue = wasm.TS_Router_find_route(this_arg, payer, route_params, payment_hash, first_hops, inflight_htlcs);
7390 return nativeResponseValue;
7392 // void Router_notify_payment_path_failed LDKRouter *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
7394 export function Router_notify_payment_path_failed(this_arg: bigint, path: number, short_channel_id: bigint): void {
7395 if(!isWasmInitialized) {
7396 throw new Error("initializeWasm() must be awaited first!");
7398 const nativeResponseValue = wasm.TS_Router_notify_payment_path_failed(this_arg, path, short_channel_id);
7399 // debug statements here
7401 // void Router_notify_payment_path_successful LDKRouter *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
7403 export function Router_notify_payment_path_successful(this_arg: bigint, path: number): void {
7404 if(!isWasmInitialized) {
7405 throw new Error("initializeWasm() must be awaited first!");
7407 const nativeResponseValue = wasm.TS_Router_notify_payment_path_successful(this_arg, path);
7408 // debug statements here
7410 // void Router_notify_payment_probe_successful LDKRouter *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
7412 export function Router_notify_payment_probe_successful(this_arg: bigint, path: number): void {
7413 if(!isWasmInitialized) {
7414 throw new Error("initializeWasm() must be awaited first!");
7416 const nativeResponseValue = wasm.TS_Router_notify_payment_probe_successful(this_arg, path);
7417 // debug statements here
7419 // void Router_notify_payment_probe_failed LDKRouter *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
7421 export function Router_notify_payment_probe_failed(this_arg: bigint, path: number, short_channel_id: bigint): void {
7422 if(!isWasmInitialized) {
7423 throw new Error("initializeWasm() must be awaited first!");
7425 const nativeResponseValue = wasm.TS_Router_notify_payment_probe_failed(this_arg, path, short_channel_id);
7426 // debug statements here
7429 export class LDKRetry {
7430 protected constructor() {}
7433 export function LDKRetry_ty_from_ptr(ptr: bigint): number {
7434 if(!isWasmInitialized) {
7435 throw new Error("initializeWasm() must be awaited first!");
7437 const nativeResponseValue = wasm.TS_LDKRetry_ty_from_ptr(ptr);
7438 return nativeResponseValue;
7441 export function LDKRetry_Attempts_get_attempts(ptr: bigint): number {
7442 if(!isWasmInitialized) {
7443 throw new Error("initializeWasm() must be awaited first!");
7445 const nativeResponseValue = wasm.TS_LDKRetry_Attempts_get_attempts(ptr);
7446 return nativeResponseValue;
7448 // struct LDKStr _ldk_get_compiled_version(void);
7450 export function _ldk_get_compiled_version(): number {
7451 if(!isWasmInitialized) {
7452 throw new Error("initializeWasm() must be awaited first!");
7454 const nativeResponseValue = wasm.TS__ldk_get_compiled_version();
7455 return nativeResponseValue;
7457 // struct LDKStr _ldk_c_bindings_get_compiled_version(void);
7459 export function _ldk_c_bindings_get_compiled_version(): number {
7460 if(!isWasmInitialized) {
7461 throw new Error("initializeWasm() must be awaited first!");
7463 const nativeResponseValue = wasm.TS__ldk_c_bindings_get_compiled_version();
7464 return nativeResponseValue;
7466 // struct LDKBigEndianScalar BigEndianScalar_new(struct LDKThirtyTwoBytes big_endian_bytes);
7468 export function BigEndianScalar_new(big_endian_bytes: number): bigint {
7469 if(!isWasmInitialized) {
7470 throw new Error("initializeWasm() must be awaited first!");
7472 const nativeResponseValue = wasm.TS_BigEndianScalar_new(big_endian_bytes);
7473 return nativeResponseValue;
7475 // uint64_t Bech32Error_clone_ptr(LDKBech32Error *NONNULL_PTR arg);
7477 export function Bech32Error_clone_ptr(arg: bigint): bigint {
7478 if(!isWasmInitialized) {
7479 throw new Error("initializeWasm() must be awaited first!");
7481 const nativeResponseValue = wasm.TS_Bech32Error_clone_ptr(arg);
7482 return nativeResponseValue;
7484 // struct LDKBech32Error Bech32Error_clone(const struct LDKBech32Error *NONNULL_PTR orig);
7486 export function Bech32Error_clone(orig: bigint): bigint {
7487 if(!isWasmInitialized) {
7488 throw new Error("initializeWasm() must be awaited first!");
7490 const nativeResponseValue = wasm.TS_Bech32Error_clone(orig);
7491 return nativeResponseValue;
7493 // void Bech32Error_free(struct LDKBech32Error o);
7495 export function Bech32Error_free(o: bigint): void {
7496 if(!isWasmInitialized) {
7497 throw new Error("initializeWasm() must be awaited first!");
7499 const nativeResponseValue = wasm.TS_Bech32Error_free(o);
7500 // debug statements here
7502 // void Transaction_free(struct LDKTransaction _res);
7504 export function Transaction_free(_res: number): void {
7505 if(!isWasmInitialized) {
7506 throw new Error("initializeWasm() must be awaited first!");
7508 const nativeResponseValue = wasm.TS_Transaction_free(_res);
7509 // debug statements here
7511 // struct LDKTxOut TxOut_new(struct LDKCVec_u8Z script_pubkey, uint64_t value);
7513 export function TxOut_new(script_pubkey: number, value: bigint): bigint {
7514 if(!isWasmInitialized) {
7515 throw new Error("initializeWasm() must be awaited first!");
7517 const nativeResponseValue = wasm.TS_TxOut_new(script_pubkey, value);
7518 return nativeResponseValue;
7520 // void TxOut_free(struct LDKTxOut _res);
7522 export function TxOut_free(_res: bigint): void {
7523 if(!isWasmInitialized) {
7524 throw new Error("initializeWasm() must be awaited first!");
7526 const nativeResponseValue = wasm.TS_TxOut_free(_res);
7527 // debug statements here
7529 // uint64_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg);
7531 export function TxOut_clone_ptr(arg: bigint): bigint {
7532 if(!isWasmInitialized) {
7533 throw new Error("initializeWasm() must be awaited first!");
7535 const nativeResponseValue = wasm.TS_TxOut_clone_ptr(arg);
7536 return nativeResponseValue;
7538 // struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
7540 export function TxOut_clone(orig: bigint): bigint {
7541 if(!isWasmInitialized) {
7542 throw new Error("initializeWasm() must be awaited first!");
7544 const nativeResponseValue = wasm.TS_TxOut_clone(orig);
7545 return nativeResponseValue;
7547 // void Str_free(struct LDKStr _res);
7549 export function Str_free(_res: number): void {
7550 if(!isWasmInitialized) {
7551 throw new Error("initializeWasm() must be awaited first!");
7553 const nativeResponseValue = wasm.TS_Str_free(_res);
7554 // debug statements here
7556 // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
7558 export function CVec_PublicKeyZ_free(_res: number): void {
7559 if(!isWasmInitialized) {
7560 throw new Error("initializeWasm() must be awaited first!");
7562 const nativeResponseValue = wasm.TS_CVec_PublicKeyZ_free(_res);
7563 // debug statements here
7565 // struct LDKCResult_BlindedRouteNoneZ CResult_BlindedRouteNoneZ_ok(struct LDKBlindedRoute o);
7567 export function CResult_BlindedRouteNoneZ_ok(o: bigint): bigint {
7568 if(!isWasmInitialized) {
7569 throw new Error("initializeWasm() must be awaited first!");
7571 const nativeResponseValue = wasm.TS_CResult_BlindedRouteNoneZ_ok(o);
7572 return nativeResponseValue;
7574 // struct LDKCResult_BlindedRouteNoneZ CResult_BlindedRouteNoneZ_err(void);
7576 export function CResult_BlindedRouteNoneZ_err(): bigint {
7577 if(!isWasmInitialized) {
7578 throw new Error("initializeWasm() must be awaited first!");
7580 const nativeResponseValue = wasm.TS_CResult_BlindedRouteNoneZ_err();
7581 return nativeResponseValue;
7583 // bool CResult_BlindedRouteNoneZ_is_ok(const struct LDKCResult_BlindedRouteNoneZ *NONNULL_PTR o);
7585 export function CResult_BlindedRouteNoneZ_is_ok(o: bigint): boolean {
7586 if(!isWasmInitialized) {
7587 throw new Error("initializeWasm() must be awaited first!");
7589 const nativeResponseValue = wasm.TS_CResult_BlindedRouteNoneZ_is_ok(o);
7590 return nativeResponseValue;
7592 // void CResult_BlindedRouteNoneZ_free(struct LDKCResult_BlindedRouteNoneZ _res);
7594 export function CResult_BlindedRouteNoneZ_free(_res: bigint): void {
7595 if(!isWasmInitialized) {
7596 throw new Error("initializeWasm() must be awaited first!");
7598 const nativeResponseValue = wasm.TS_CResult_BlindedRouteNoneZ_free(_res);
7599 // debug statements here
7601 // struct LDKCResult_BlindedRouteDecodeErrorZ CResult_BlindedRouteDecodeErrorZ_ok(struct LDKBlindedRoute o);
7603 export function CResult_BlindedRouteDecodeErrorZ_ok(o: bigint): bigint {
7604 if(!isWasmInitialized) {
7605 throw new Error("initializeWasm() must be awaited first!");
7607 const nativeResponseValue = wasm.TS_CResult_BlindedRouteDecodeErrorZ_ok(o);
7608 return nativeResponseValue;
7610 // struct LDKCResult_BlindedRouteDecodeErrorZ CResult_BlindedRouteDecodeErrorZ_err(struct LDKDecodeError e);
7612 export function CResult_BlindedRouteDecodeErrorZ_err(e: bigint): bigint {
7613 if(!isWasmInitialized) {
7614 throw new Error("initializeWasm() must be awaited first!");
7616 const nativeResponseValue = wasm.TS_CResult_BlindedRouteDecodeErrorZ_err(e);
7617 return nativeResponseValue;
7619 // bool CResult_BlindedRouteDecodeErrorZ_is_ok(const struct LDKCResult_BlindedRouteDecodeErrorZ *NONNULL_PTR o);
7621 export function CResult_BlindedRouteDecodeErrorZ_is_ok(o: bigint): boolean {
7622 if(!isWasmInitialized) {
7623 throw new Error("initializeWasm() must be awaited first!");
7625 const nativeResponseValue = wasm.TS_CResult_BlindedRouteDecodeErrorZ_is_ok(o);
7626 return nativeResponseValue;
7628 // void CResult_BlindedRouteDecodeErrorZ_free(struct LDKCResult_BlindedRouteDecodeErrorZ _res);
7630 export function CResult_BlindedRouteDecodeErrorZ_free(_res: bigint): void {
7631 if(!isWasmInitialized) {
7632 throw new Error("initializeWasm() must be awaited first!");
7634 const nativeResponseValue = wasm.TS_CResult_BlindedRouteDecodeErrorZ_free(_res);
7635 // debug statements here
7637 // struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_ok(struct LDKBlindedHop o);
7639 export function CResult_BlindedHopDecodeErrorZ_ok(o: bigint): bigint {
7640 if(!isWasmInitialized) {
7641 throw new Error("initializeWasm() must be awaited first!");
7643 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_ok(o);
7644 return nativeResponseValue;
7646 // struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_err(struct LDKDecodeError e);
7648 export function CResult_BlindedHopDecodeErrorZ_err(e: bigint): bigint {
7649 if(!isWasmInitialized) {
7650 throw new Error("initializeWasm() must be awaited first!");
7652 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_err(e);
7653 return nativeResponseValue;
7655 // bool CResult_BlindedHopDecodeErrorZ_is_ok(const struct LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR o);
7657 export function CResult_BlindedHopDecodeErrorZ_is_ok(o: bigint): boolean {
7658 if(!isWasmInitialized) {
7659 throw new Error("initializeWasm() must be awaited first!");
7661 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_is_ok(o);
7662 return nativeResponseValue;
7664 // void CResult_BlindedHopDecodeErrorZ_free(struct LDKCResult_BlindedHopDecodeErrorZ _res);
7666 export function CResult_BlindedHopDecodeErrorZ_free(_res: bigint): void {
7667 if(!isWasmInitialized) {
7668 throw new Error("initializeWasm() must be awaited first!");
7670 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_free(_res);
7671 // debug statements here
7673 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_ok(void);
7675 export function CResult_NoneNoneZ_ok(): bigint {
7676 if(!isWasmInitialized) {
7677 throw new Error("initializeWasm() must be awaited first!");
7679 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_ok();
7680 return nativeResponseValue;
7682 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_err(void);
7684 export function CResult_NoneNoneZ_err(): bigint {
7685 if(!isWasmInitialized) {
7686 throw new Error("initializeWasm() must be awaited first!");
7688 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_err();
7689 return nativeResponseValue;
7691 // bool CResult_NoneNoneZ_is_ok(const struct LDKCResult_NoneNoneZ *NONNULL_PTR o);
7693 export function CResult_NoneNoneZ_is_ok(o: bigint): boolean {
7694 if(!isWasmInitialized) {
7695 throw new Error("initializeWasm() must be awaited first!");
7697 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_is_ok(o);
7698 return nativeResponseValue;
7700 // void CResult_NoneNoneZ_free(struct LDKCResult_NoneNoneZ _res);
7702 export function CResult_NoneNoneZ_free(_res: bigint): void {
7703 if(!isWasmInitialized) {
7704 throw new Error("initializeWasm() must be awaited first!");
7706 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_free(_res);
7707 // debug statements here
7709 // uint64_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg);
7711 export function CResult_NoneNoneZ_clone_ptr(arg: bigint): bigint {
7712 if(!isWasmInitialized) {
7713 throw new Error("initializeWasm() must be awaited first!");
7715 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone_ptr(arg);
7716 return nativeResponseValue;
7718 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_clone(const struct LDKCResult_NoneNoneZ *NONNULL_PTR orig);
7720 export function CResult_NoneNoneZ_clone(orig: bigint): bigint {
7721 if(!isWasmInitialized) {
7722 throw new Error("initializeWasm() must be awaited first!");
7724 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone(orig);
7725 return nativeResponseValue;
7727 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(struct LDKCounterpartyCommitmentSecrets o);
7729 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o: bigint): bigint {
7730 if(!isWasmInitialized) {
7731 throw new Error("initializeWasm() must be awaited first!");
7733 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o);
7734 return nativeResponseValue;
7736 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(struct LDKDecodeError e);
7738 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e: bigint): bigint {
7739 if(!isWasmInitialized) {
7740 throw new Error("initializeWasm() must be awaited first!");
7742 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e);
7743 return nativeResponseValue;
7745 // bool CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR o);
7747 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o: bigint): boolean {
7748 if(!isWasmInitialized) {
7749 throw new Error("initializeWasm() must be awaited first!");
7751 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o);
7752 return nativeResponseValue;
7754 // void CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ _res);
7756 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res: bigint): void {
7757 if(!isWasmInitialized) {
7758 throw new Error("initializeWasm() must be awaited first!");
7760 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res);
7761 // debug statements here
7763 // uint64_t CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR arg);
7765 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
7766 if(!isWasmInitialized) {
7767 throw new Error("initializeWasm() must be awaited first!");
7769 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg);
7770 return nativeResponseValue;
7772 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR orig);
7774 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig: bigint): bigint {
7775 if(!isWasmInitialized) {
7776 throw new Error("initializeWasm() must be awaited first!");
7778 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig);
7779 return nativeResponseValue;
7781 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_ok(struct LDKSecretKey o);
7783 export function CResult_SecretKeyErrorZ_ok(o: number): bigint {
7784 if(!isWasmInitialized) {
7785 throw new Error("initializeWasm() must be awaited first!");
7787 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_ok(o);
7788 return nativeResponseValue;
7790 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_err(enum LDKSecp256k1Error e);
7792 export function CResult_SecretKeyErrorZ_err(e: Secp256k1Error): bigint {
7793 if(!isWasmInitialized) {
7794 throw new Error("initializeWasm() must be awaited first!");
7796 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_err(e);
7797 return nativeResponseValue;
7799 // bool CResult_SecretKeyErrorZ_is_ok(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR o);
7801 export function CResult_SecretKeyErrorZ_is_ok(o: bigint): boolean {
7802 if(!isWasmInitialized) {
7803 throw new Error("initializeWasm() must be awaited first!");
7805 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_is_ok(o);
7806 return nativeResponseValue;
7808 // void CResult_SecretKeyErrorZ_free(struct LDKCResult_SecretKeyErrorZ _res);
7810 export function CResult_SecretKeyErrorZ_free(_res: bigint): void {
7811 if(!isWasmInitialized) {
7812 throw new Error("initializeWasm() must be awaited first!");
7814 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_free(_res);
7815 // debug statements here
7817 // uint64_t CResult_SecretKeyErrorZ_clone_ptr(LDKCResult_SecretKeyErrorZ *NONNULL_PTR arg);
7819 export function CResult_SecretKeyErrorZ_clone_ptr(arg: bigint): bigint {
7820 if(!isWasmInitialized) {
7821 throw new Error("initializeWasm() must be awaited first!");
7823 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_clone_ptr(arg);
7824 return nativeResponseValue;
7826 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_clone(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR orig);
7828 export function CResult_SecretKeyErrorZ_clone(orig: bigint): bigint {
7829 if(!isWasmInitialized) {
7830 throw new Error("initializeWasm() must be awaited first!");
7832 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_clone(orig);
7833 return nativeResponseValue;
7835 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_ok(struct LDKPublicKey o);
7837 export function CResult_PublicKeyErrorZ_ok(o: number): bigint {
7838 if(!isWasmInitialized) {
7839 throw new Error("initializeWasm() must be awaited first!");
7841 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_ok(o);
7842 return nativeResponseValue;
7844 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_err(enum LDKSecp256k1Error e);
7846 export function CResult_PublicKeyErrorZ_err(e: Secp256k1Error): bigint {
7847 if(!isWasmInitialized) {
7848 throw new Error("initializeWasm() must be awaited first!");
7850 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_err(e);
7851 return nativeResponseValue;
7853 // bool CResult_PublicKeyErrorZ_is_ok(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR o);
7855 export function CResult_PublicKeyErrorZ_is_ok(o: bigint): boolean {
7856 if(!isWasmInitialized) {
7857 throw new Error("initializeWasm() must be awaited first!");
7859 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_is_ok(o);
7860 return nativeResponseValue;
7862 // void CResult_PublicKeyErrorZ_free(struct LDKCResult_PublicKeyErrorZ _res);
7864 export function CResult_PublicKeyErrorZ_free(_res: bigint): void {
7865 if(!isWasmInitialized) {
7866 throw new Error("initializeWasm() must be awaited first!");
7868 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_free(_res);
7869 // debug statements here
7871 // uint64_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg);
7873 export function CResult_PublicKeyErrorZ_clone_ptr(arg: bigint): bigint {
7874 if(!isWasmInitialized) {
7875 throw new Error("initializeWasm() must be awaited first!");
7877 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone_ptr(arg);
7878 return nativeResponseValue;
7880 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_clone(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR orig);
7882 export function CResult_PublicKeyErrorZ_clone(orig: bigint): bigint {
7883 if(!isWasmInitialized) {
7884 throw new Error("initializeWasm() must be awaited first!");
7886 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone(orig);
7887 return nativeResponseValue;
7889 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_ok(struct LDKTxCreationKeys o);
7891 export function CResult_TxCreationKeysDecodeErrorZ_ok(o: bigint): bigint {
7892 if(!isWasmInitialized) {
7893 throw new Error("initializeWasm() must be awaited first!");
7895 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_ok(o);
7896 return nativeResponseValue;
7898 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_err(struct LDKDecodeError e);
7900 export function CResult_TxCreationKeysDecodeErrorZ_err(e: bigint): bigint {
7901 if(!isWasmInitialized) {
7902 throw new Error("initializeWasm() must be awaited first!");
7904 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_err(e);
7905 return nativeResponseValue;
7907 // bool CResult_TxCreationKeysDecodeErrorZ_is_ok(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR o);
7909 export function CResult_TxCreationKeysDecodeErrorZ_is_ok(o: bigint): boolean {
7910 if(!isWasmInitialized) {
7911 throw new Error("initializeWasm() must be awaited first!");
7913 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(o);
7914 return nativeResponseValue;
7916 // void CResult_TxCreationKeysDecodeErrorZ_free(struct LDKCResult_TxCreationKeysDecodeErrorZ _res);
7918 export function CResult_TxCreationKeysDecodeErrorZ_free(_res: bigint): void {
7919 if(!isWasmInitialized) {
7920 throw new Error("initializeWasm() must be awaited first!");
7922 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_free(_res);
7923 // debug statements here
7925 // uint64_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg);
7927 export function CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg: bigint): bigint {
7928 if(!isWasmInitialized) {
7929 throw new Error("initializeWasm() must be awaited first!");
7931 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg);
7932 return nativeResponseValue;
7934 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_clone(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR orig);
7936 export function CResult_TxCreationKeysDecodeErrorZ_clone(orig: bigint): bigint {
7937 if(!isWasmInitialized) {
7938 throw new Error("initializeWasm() must be awaited first!");
7940 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone(orig);
7941 return nativeResponseValue;
7943 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_ok(struct LDKChannelPublicKeys o);
7945 export function CResult_ChannelPublicKeysDecodeErrorZ_ok(o: bigint): bigint {
7946 if(!isWasmInitialized) {
7947 throw new Error("initializeWasm() must be awaited first!");
7949 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_ok(o);
7950 return nativeResponseValue;
7952 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_err(struct LDKDecodeError e);
7954 export function CResult_ChannelPublicKeysDecodeErrorZ_err(e: bigint): bigint {
7955 if(!isWasmInitialized) {
7956 throw new Error("initializeWasm() must be awaited first!");
7958 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_err(e);
7959 return nativeResponseValue;
7961 // bool CResult_ChannelPublicKeysDecodeErrorZ_is_ok(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR o);
7963 export function CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o: bigint): boolean {
7964 if(!isWasmInitialized) {
7965 throw new Error("initializeWasm() must be awaited first!");
7967 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o);
7968 return nativeResponseValue;
7970 // void CResult_ChannelPublicKeysDecodeErrorZ_free(struct LDKCResult_ChannelPublicKeysDecodeErrorZ _res);
7972 export function CResult_ChannelPublicKeysDecodeErrorZ_free(_res: bigint): void {
7973 if(!isWasmInitialized) {
7974 throw new Error("initializeWasm() must be awaited first!");
7976 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_free(_res);
7977 // debug statements here
7979 // uint64_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg);
7981 export function CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg: bigint): bigint {
7982 if(!isWasmInitialized) {
7983 throw new Error("initializeWasm() must be awaited first!");
7985 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg);
7986 return nativeResponseValue;
7988 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_clone(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR orig);
7990 export function CResult_ChannelPublicKeysDecodeErrorZ_clone(orig: bigint): bigint {
7991 if(!isWasmInitialized) {
7992 throw new Error("initializeWasm() must be awaited first!");
7994 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(orig);
7995 return nativeResponseValue;
7997 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_ok(struct LDKTxCreationKeys o);
7999 export function CResult_TxCreationKeysErrorZ_ok(o: bigint): bigint {
8000 if(!isWasmInitialized) {
8001 throw new Error("initializeWasm() must be awaited first!");
8003 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_ok(o);
8004 return nativeResponseValue;
8006 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_err(enum LDKSecp256k1Error e);
8008 export function CResult_TxCreationKeysErrorZ_err(e: Secp256k1Error): bigint {
8009 if(!isWasmInitialized) {
8010 throw new Error("initializeWasm() must be awaited first!");
8012 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_err(e);
8013 return nativeResponseValue;
8015 // bool CResult_TxCreationKeysErrorZ_is_ok(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR o);
8017 export function CResult_TxCreationKeysErrorZ_is_ok(o: bigint): boolean {
8018 if(!isWasmInitialized) {
8019 throw new Error("initializeWasm() must be awaited first!");
8021 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_is_ok(o);
8022 return nativeResponseValue;
8024 // void CResult_TxCreationKeysErrorZ_free(struct LDKCResult_TxCreationKeysErrorZ _res);
8026 export function CResult_TxCreationKeysErrorZ_free(_res: bigint): void {
8027 if(!isWasmInitialized) {
8028 throw new Error("initializeWasm() must be awaited first!");
8030 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_free(_res);
8031 // debug statements here
8033 // uint64_t CResult_TxCreationKeysErrorZ_clone_ptr(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR arg);
8035 export function CResult_TxCreationKeysErrorZ_clone_ptr(arg: bigint): bigint {
8036 if(!isWasmInitialized) {
8037 throw new Error("initializeWasm() must be awaited first!");
8039 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone_ptr(arg);
8040 return nativeResponseValue;
8042 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_clone(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR orig);
8044 export function CResult_TxCreationKeysErrorZ_clone(orig: bigint): bigint {
8045 if(!isWasmInitialized) {
8046 throw new Error("initializeWasm() must be awaited first!");
8048 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone(orig);
8049 return nativeResponseValue;
8051 // struct LDKCOption_u32Z COption_u32Z_some(uint32_t o);
8053 export function COption_u32Z_some(o: number): bigint {
8054 if(!isWasmInitialized) {
8055 throw new Error("initializeWasm() must be awaited first!");
8057 const nativeResponseValue = wasm.TS_COption_u32Z_some(o);
8058 return nativeResponseValue;
8060 // struct LDKCOption_u32Z COption_u32Z_none(void);
8062 export function COption_u32Z_none(): bigint {
8063 if(!isWasmInitialized) {
8064 throw new Error("initializeWasm() must be awaited first!");
8066 const nativeResponseValue = wasm.TS_COption_u32Z_none();
8067 return nativeResponseValue;
8069 // void COption_u32Z_free(struct LDKCOption_u32Z _res);
8071 export function COption_u32Z_free(_res: bigint): void {
8072 if(!isWasmInitialized) {
8073 throw new Error("initializeWasm() must be awaited first!");
8075 const nativeResponseValue = wasm.TS_COption_u32Z_free(_res);
8076 // debug statements here
8078 // uint64_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg);
8080 export function COption_u32Z_clone_ptr(arg: bigint): bigint {
8081 if(!isWasmInitialized) {
8082 throw new Error("initializeWasm() must be awaited first!");
8084 const nativeResponseValue = wasm.TS_COption_u32Z_clone_ptr(arg);
8085 return nativeResponseValue;
8087 // struct LDKCOption_u32Z COption_u32Z_clone(const struct LDKCOption_u32Z *NONNULL_PTR orig);
8089 export function COption_u32Z_clone(orig: bigint): bigint {
8090 if(!isWasmInitialized) {
8091 throw new Error("initializeWasm() must be awaited first!");
8093 const nativeResponseValue = wasm.TS_COption_u32Z_clone(orig);
8094 return nativeResponseValue;
8096 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(struct LDKHTLCOutputInCommitment o);
8098 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o: bigint): bigint {
8099 if(!isWasmInitialized) {
8100 throw new Error("initializeWasm() must be awaited first!");
8102 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o);
8103 return nativeResponseValue;
8105 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_err(struct LDKDecodeError e);
8107 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e: bigint): bigint {
8108 if(!isWasmInitialized) {
8109 throw new Error("initializeWasm() must be awaited first!");
8111 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e);
8112 return nativeResponseValue;
8114 // bool CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR o);
8116 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o: bigint): boolean {
8117 if(!isWasmInitialized) {
8118 throw new Error("initializeWasm() must be awaited first!");
8120 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o);
8121 return nativeResponseValue;
8123 // void CResult_HTLCOutputInCommitmentDecodeErrorZ_free(struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res);
8125 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res: bigint): void {
8126 if(!isWasmInitialized) {
8127 throw new Error("initializeWasm() must be awaited first!");
8129 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res);
8130 // debug statements here
8132 // uint64_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg);
8134 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8135 if(!isWasmInitialized) {
8136 throw new Error("initializeWasm() must be awaited first!");
8138 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg);
8139 return nativeResponseValue;
8141 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR orig);
8143 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig: bigint): bigint {
8144 if(!isWasmInitialized) {
8145 throw new Error("initializeWasm() must be awaited first!");
8147 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig);
8148 return nativeResponseValue;
8150 // enum LDKCOption_NoneZ COption_NoneZ_some(void);
8152 export function COption_NoneZ_some(): COption_NoneZ {
8153 if(!isWasmInitialized) {
8154 throw new Error("initializeWasm() must be awaited first!");
8156 const nativeResponseValue = wasm.TS_COption_NoneZ_some();
8157 return nativeResponseValue;
8159 // enum LDKCOption_NoneZ COption_NoneZ_none(void);
8161 export function COption_NoneZ_none(): COption_NoneZ {
8162 if(!isWasmInitialized) {
8163 throw new Error("initializeWasm() must be awaited first!");
8165 const nativeResponseValue = wasm.TS_COption_NoneZ_none();
8166 return nativeResponseValue;
8168 // void COption_NoneZ_free(enum LDKCOption_NoneZ _res);
8170 export function COption_NoneZ_free(_res: COption_NoneZ): void {
8171 if(!isWasmInitialized) {
8172 throw new Error("initializeWasm() must be awaited first!");
8174 const nativeResponseValue = wasm.TS_COption_NoneZ_free(_res);
8175 // debug statements here
8177 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(struct LDKCounterpartyChannelTransactionParameters o);
8179 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o: bigint): bigint {
8180 if(!isWasmInitialized) {
8181 throw new Error("initializeWasm() must be awaited first!");
8183 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o);
8184 return nativeResponseValue;
8186 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
8188 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e: bigint): bigint {
8189 if(!isWasmInitialized) {
8190 throw new Error("initializeWasm() must be awaited first!");
8192 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e);
8193 return nativeResponseValue;
8195 // bool CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
8197 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o: bigint): boolean {
8198 if(!isWasmInitialized) {
8199 throw new Error("initializeWasm() must be awaited first!");
8201 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o);
8202 return nativeResponseValue;
8204 // void CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res);
8206 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res: bigint): void {
8207 if(!isWasmInitialized) {
8208 throw new Error("initializeWasm() must be awaited first!");
8210 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res);
8211 // debug statements here
8213 // uint64_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
8215 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8216 if(!isWasmInitialized) {
8217 throw new Error("initializeWasm() must be awaited first!");
8219 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
8220 return nativeResponseValue;
8222 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
8224 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig: bigint): bigint {
8225 if(!isWasmInitialized) {
8226 throw new Error("initializeWasm() must be awaited first!");
8228 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig);
8229 return nativeResponseValue;
8231 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_ok(struct LDKChannelTransactionParameters o);
8233 export function CResult_ChannelTransactionParametersDecodeErrorZ_ok(o: bigint): bigint {
8234 if(!isWasmInitialized) {
8235 throw new Error("initializeWasm() must be awaited first!");
8237 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok(o);
8238 return nativeResponseValue;
8240 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
8242 export function CResult_ChannelTransactionParametersDecodeErrorZ_err(e: bigint): bigint {
8243 if(!isWasmInitialized) {
8244 throw new Error("initializeWasm() must be awaited first!");
8246 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_err(e);
8247 return nativeResponseValue;
8249 // bool CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
8251 export function CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o: bigint): boolean {
8252 if(!isWasmInitialized) {
8253 throw new Error("initializeWasm() must be awaited first!");
8255 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o);
8256 return nativeResponseValue;
8258 // void CResult_ChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_ChannelTransactionParametersDecodeErrorZ _res);
8260 export function CResult_ChannelTransactionParametersDecodeErrorZ_free(_res: bigint): void {
8261 if(!isWasmInitialized) {
8262 throw new Error("initializeWasm() must be awaited first!");
8264 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(_res);
8265 // debug statements here
8267 // uint64_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
8269 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8270 if(!isWasmInitialized) {
8271 throw new Error("initializeWasm() must be awaited first!");
8273 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
8274 return nativeResponseValue;
8276 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
8278 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig: bigint): bigint {
8279 if(!isWasmInitialized) {
8280 throw new Error("initializeWasm() must be awaited first!");
8282 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig);
8283 return nativeResponseValue;
8285 // void CVec_SignatureZ_free(struct LDKCVec_SignatureZ _res);
8287 export function CVec_SignatureZ_free(_res: number): void {
8288 if(!isWasmInitialized) {
8289 throw new Error("initializeWasm() must be awaited first!");
8291 const nativeResponseValue = wasm.TS_CVec_SignatureZ_free(_res);
8292 // debug statements here
8294 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_ok(struct LDKHolderCommitmentTransaction o);
8296 export function CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
8297 if(!isWasmInitialized) {
8298 throw new Error("initializeWasm() must be awaited first!");
8300 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o);
8301 return nativeResponseValue;
8303 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
8305 export function CResult_HolderCommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
8306 if(!isWasmInitialized) {
8307 throw new Error("initializeWasm() must be awaited first!");
8309 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err(e);
8310 return nativeResponseValue;
8312 // bool CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
8314 export function CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
8315 if(!isWasmInitialized) {
8316 throw new Error("initializeWasm() must be awaited first!");
8318 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o);
8319 return nativeResponseValue;
8321 // void CResult_HolderCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res);
8323 export function CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
8324 if(!isWasmInitialized) {
8325 throw new Error("initializeWasm() must be awaited first!");
8327 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res);
8328 // debug statements here
8330 // uint64_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
8332 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8333 if(!isWasmInitialized) {
8334 throw new Error("initializeWasm() must be awaited first!");
8336 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
8337 return nativeResponseValue;
8339 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
8341 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
8342 if(!isWasmInitialized) {
8343 throw new Error("initializeWasm() must be awaited first!");
8345 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig);
8346 return nativeResponseValue;
8348 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(struct LDKBuiltCommitmentTransaction o);
8350 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
8351 if(!isWasmInitialized) {
8352 throw new Error("initializeWasm() must be awaited first!");
8354 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o);
8355 return nativeResponseValue;
8357 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
8359 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
8360 if(!isWasmInitialized) {
8361 throw new Error("initializeWasm() must be awaited first!");
8363 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e);
8364 return nativeResponseValue;
8366 // bool CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
8368 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
8369 if(!isWasmInitialized) {
8370 throw new Error("initializeWasm() must be awaited first!");
8372 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o);
8373 return nativeResponseValue;
8375 // void CResult_BuiltCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res);
8377 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
8378 if(!isWasmInitialized) {
8379 throw new Error("initializeWasm() must be awaited first!");
8381 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res);
8382 // debug statements here
8384 // uint64_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
8386 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8387 if(!isWasmInitialized) {
8388 throw new Error("initializeWasm() must be awaited first!");
8390 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
8391 return nativeResponseValue;
8393 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
8395 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
8396 if(!isWasmInitialized) {
8397 throw new Error("initializeWasm() must be awaited first!");
8399 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig);
8400 return nativeResponseValue;
8402 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_ok(struct LDKTrustedClosingTransaction o);
8404 export function CResult_TrustedClosingTransactionNoneZ_ok(o: bigint): bigint {
8405 if(!isWasmInitialized) {
8406 throw new Error("initializeWasm() must be awaited first!");
8408 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_ok(o);
8409 return nativeResponseValue;
8411 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_err(void);
8413 export function CResult_TrustedClosingTransactionNoneZ_err(): bigint {
8414 if(!isWasmInitialized) {
8415 throw new Error("initializeWasm() must be awaited first!");
8417 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_err();
8418 return nativeResponseValue;
8420 // bool CResult_TrustedClosingTransactionNoneZ_is_ok(const struct LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR o);
8422 export function CResult_TrustedClosingTransactionNoneZ_is_ok(o: bigint): boolean {
8423 if(!isWasmInitialized) {
8424 throw new Error("initializeWasm() must be awaited first!");
8426 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_is_ok(o);
8427 return nativeResponseValue;
8429 // void CResult_TrustedClosingTransactionNoneZ_free(struct LDKCResult_TrustedClosingTransactionNoneZ _res);
8431 export function CResult_TrustedClosingTransactionNoneZ_free(_res: bigint): void {
8432 if(!isWasmInitialized) {
8433 throw new Error("initializeWasm() must be awaited first!");
8435 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_free(_res);
8436 // debug statements here
8438 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_ok(struct LDKCommitmentTransaction o);
8440 export function CResult_CommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
8441 if(!isWasmInitialized) {
8442 throw new Error("initializeWasm() must be awaited first!");
8444 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_ok(o);
8445 return nativeResponseValue;
8447 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
8449 export function CResult_CommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
8450 if(!isWasmInitialized) {
8451 throw new Error("initializeWasm() must be awaited first!");
8453 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_err(e);
8454 return nativeResponseValue;
8456 // bool CResult_CommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
8458 export function CResult_CommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
8459 if(!isWasmInitialized) {
8460 throw new Error("initializeWasm() must be awaited first!");
8462 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(o);
8463 return nativeResponseValue;
8465 // void CResult_CommitmentTransactionDecodeErrorZ_free(struct LDKCResult_CommitmentTransactionDecodeErrorZ _res);
8467 export function CResult_CommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
8468 if(!isWasmInitialized) {
8469 throw new Error("initializeWasm() must be awaited first!");
8471 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_free(_res);
8472 // debug statements here
8474 // uint64_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
8476 export function CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8477 if(!isWasmInitialized) {
8478 throw new Error("initializeWasm() must be awaited first!");
8480 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg);
8481 return nativeResponseValue;
8483 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
8485 export function CResult_CommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
8486 if(!isWasmInitialized) {
8487 throw new Error("initializeWasm() must be awaited first!");
8489 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone(orig);
8490 return nativeResponseValue;
8492 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_ok(struct LDKTrustedCommitmentTransaction o);
8494 export function CResult_TrustedCommitmentTransactionNoneZ_ok(o: bigint): bigint {
8495 if(!isWasmInitialized) {
8496 throw new Error("initializeWasm() must be awaited first!");
8498 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_ok(o);
8499 return nativeResponseValue;
8501 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_err(void);
8503 export function CResult_TrustedCommitmentTransactionNoneZ_err(): bigint {
8504 if(!isWasmInitialized) {
8505 throw new Error("initializeWasm() must be awaited first!");
8507 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_err();
8508 return nativeResponseValue;
8510 // bool CResult_TrustedCommitmentTransactionNoneZ_is_ok(const struct LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR o);
8512 export function CResult_TrustedCommitmentTransactionNoneZ_is_ok(o: bigint): boolean {
8513 if(!isWasmInitialized) {
8514 throw new Error("initializeWasm() must be awaited first!");
8516 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(o);
8517 return nativeResponseValue;
8519 // void CResult_TrustedCommitmentTransactionNoneZ_free(struct LDKCResult_TrustedCommitmentTransactionNoneZ _res);
8521 export function CResult_TrustedCommitmentTransactionNoneZ_free(_res: bigint): void {
8522 if(!isWasmInitialized) {
8523 throw new Error("initializeWasm() must be awaited first!");
8525 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_free(_res);
8526 // debug statements here
8528 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_ok(struct LDKCVec_SignatureZ o);
8530 export function CResult_CVec_SignatureZNoneZ_ok(o: number): bigint {
8531 if(!isWasmInitialized) {
8532 throw new Error("initializeWasm() must be awaited first!");
8534 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_ok(o);
8535 return nativeResponseValue;
8537 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_err(void);
8539 export function CResult_CVec_SignatureZNoneZ_err(): bigint {
8540 if(!isWasmInitialized) {
8541 throw new Error("initializeWasm() must be awaited first!");
8543 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_err();
8544 return nativeResponseValue;
8546 // bool CResult_CVec_SignatureZNoneZ_is_ok(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR o);
8548 export function CResult_CVec_SignatureZNoneZ_is_ok(o: bigint): boolean {
8549 if(!isWasmInitialized) {
8550 throw new Error("initializeWasm() must be awaited first!");
8552 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_is_ok(o);
8553 return nativeResponseValue;
8555 // void CResult_CVec_SignatureZNoneZ_free(struct LDKCResult_CVec_SignatureZNoneZ _res);
8557 export function CResult_CVec_SignatureZNoneZ_free(_res: bigint): void {
8558 if(!isWasmInitialized) {
8559 throw new Error("initializeWasm() must be awaited first!");
8561 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_free(_res);
8562 // debug statements here
8564 // uint64_t CResult_CVec_SignatureZNoneZ_clone_ptr(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR arg);
8566 export function CResult_CVec_SignatureZNoneZ_clone_ptr(arg: bigint): bigint {
8567 if(!isWasmInitialized) {
8568 throw new Error("initializeWasm() must be awaited first!");
8570 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone_ptr(arg);
8571 return nativeResponseValue;
8573 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_clone(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR orig);
8575 export function CResult_CVec_SignatureZNoneZ_clone(orig: bigint): bigint {
8576 if(!isWasmInitialized) {
8577 throw new Error("initializeWasm() must be awaited first!");
8579 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone(orig);
8580 return nativeResponseValue;
8582 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_ok(struct LDKShutdownScript o);
8584 export function CResult_ShutdownScriptDecodeErrorZ_ok(o: bigint): bigint {
8585 if(!isWasmInitialized) {
8586 throw new Error("initializeWasm() must be awaited first!");
8588 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_ok(o);
8589 return nativeResponseValue;
8591 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_err(struct LDKDecodeError e);
8593 export function CResult_ShutdownScriptDecodeErrorZ_err(e: bigint): bigint {
8594 if(!isWasmInitialized) {
8595 throw new Error("initializeWasm() must be awaited first!");
8597 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_err(e);
8598 return nativeResponseValue;
8600 // bool CResult_ShutdownScriptDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR o);
8602 export function CResult_ShutdownScriptDecodeErrorZ_is_ok(o: bigint): boolean {
8603 if(!isWasmInitialized) {
8604 throw new Error("initializeWasm() must be awaited first!");
8606 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(o);
8607 return nativeResponseValue;
8609 // void CResult_ShutdownScriptDecodeErrorZ_free(struct LDKCResult_ShutdownScriptDecodeErrorZ _res);
8611 export function CResult_ShutdownScriptDecodeErrorZ_free(_res: bigint): void {
8612 if(!isWasmInitialized) {
8613 throw new Error("initializeWasm() must be awaited first!");
8615 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_free(_res);
8616 // debug statements here
8618 // uint64_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg);
8620 export function CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8621 if(!isWasmInitialized) {
8622 throw new Error("initializeWasm() must be awaited first!");
8624 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg);
8625 return nativeResponseValue;
8627 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_clone(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR orig);
8629 export function CResult_ShutdownScriptDecodeErrorZ_clone(orig: bigint): bigint {
8630 if(!isWasmInitialized) {
8631 throw new Error("initializeWasm() must be awaited first!");
8633 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone(orig);
8634 return nativeResponseValue;
8636 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_ok(struct LDKShutdownScript o);
8638 export function CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o: bigint): bigint {
8639 if(!isWasmInitialized) {
8640 throw new Error("initializeWasm() must be awaited first!");
8642 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o);
8643 return nativeResponseValue;
8645 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_err(struct LDKInvalidShutdownScript e);
8647 export function CResult_ShutdownScriptInvalidShutdownScriptZ_err(e: bigint): bigint {
8648 if(!isWasmInitialized) {
8649 throw new Error("initializeWasm() must be awaited first!");
8651 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err(e);
8652 return nativeResponseValue;
8654 // bool CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR o);
8656 export function CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o: bigint): boolean {
8657 if(!isWasmInitialized) {
8658 throw new Error("initializeWasm() must be awaited first!");
8660 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o);
8661 return nativeResponseValue;
8663 // void CResult_ShutdownScriptInvalidShutdownScriptZ_free(struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res);
8665 export function CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res: bigint): void {
8666 if(!isWasmInitialized) {
8667 throw new Error("initializeWasm() must be awaited first!");
8669 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res);
8670 // debug statements here
8672 // uint64_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg);
8674 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg: bigint): bigint {
8675 if(!isWasmInitialized) {
8676 throw new Error("initializeWasm() must be awaited first!");
8678 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg);
8679 return nativeResponseValue;
8681 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_clone(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR orig);
8683 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig: bigint): bigint {
8684 if(!isWasmInitialized) {
8685 throw new Error("initializeWasm() must be awaited first!");
8687 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig);
8688 return nativeResponseValue;
8690 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_ok(struct LDKRouteHop o);
8692 export function CResult_RouteHopDecodeErrorZ_ok(o: bigint): bigint {
8693 if(!isWasmInitialized) {
8694 throw new Error("initializeWasm() must be awaited first!");
8696 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_ok(o);
8697 return nativeResponseValue;
8699 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_err(struct LDKDecodeError e);
8701 export function CResult_RouteHopDecodeErrorZ_err(e: bigint): bigint {
8702 if(!isWasmInitialized) {
8703 throw new Error("initializeWasm() must be awaited first!");
8705 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_err(e);
8706 return nativeResponseValue;
8708 // bool CResult_RouteHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR o);
8710 export function CResult_RouteHopDecodeErrorZ_is_ok(o: bigint): boolean {
8711 if(!isWasmInitialized) {
8712 throw new Error("initializeWasm() must be awaited first!");
8714 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_is_ok(o);
8715 return nativeResponseValue;
8717 // void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
8719 export function CResult_RouteHopDecodeErrorZ_free(_res: bigint): void {
8720 if(!isWasmInitialized) {
8721 throw new Error("initializeWasm() must be awaited first!");
8723 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_free(_res);
8724 // debug statements here
8726 // uint64_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg);
8728 export function CResult_RouteHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8729 if(!isWasmInitialized) {
8730 throw new Error("initializeWasm() must be awaited first!");
8732 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone_ptr(arg);
8733 return nativeResponseValue;
8735 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
8737 export function CResult_RouteHopDecodeErrorZ_clone(orig: bigint): bigint {
8738 if(!isWasmInitialized) {
8739 throw new Error("initializeWasm() must be awaited first!");
8741 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone(orig);
8742 return nativeResponseValue;
8744 // void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
8746 export function CVec_RouteHopZ_free(_res: number): void {
8747 if(!isWasmInitialized) {
8748 throw new Error("initializeWasm() must be awaited first!");
8750 const nativeResponseValue = wasm.TS_CVec_RouteHopZ_free(_res);
8751 // debug statements here
8753 // void CVec_CVec_RouteHopZZ_free(struct LDKCVec_CVec_RouteHopZZ _res);
8755 export function CVec_CVec_RouteHopZZ_free(_res: number): void {
8756 if(!isWasmInitialized) {
8757 throw new Error("initializeWasm() must be awaited first!");
8759 const nativeResponseValue = wasm.TS_CVec_CVec_RouteHopZZ_free(_res);
8760 // debug statements here
8762 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
8764 export function CResult_RouteDecodeErrorZ_ok(o: bigint): bigint {
8765 if(!isWasmInitialized) {
8766 throw new Error("initializeWasm() must be awaited first!");
8768 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_ok(o);
8769 return nativeResponseValue;
8771 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
8773 export function CResult_RouteDecodeErrorZ_err(e: bigint): bigint {
8774 if(!isWasmInitialized) {
8775 throw new Error("initializeWasm() must be awaited first!");
8777 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_err(e);
8778 return nativeResponseValue;
8780 // bool CResult_RouteDecodeErrorZ_is_ok(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR o);
8782 export function CResult_RouteDecodeErrorZ_is_ok(o: bigint): boolean {
8783 if(!isWasmInitialized) {
8784 throw new Error("initializeWasm() must be awaited first!");
8786 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_is_ok(o);
8787 return nativeResponseValue;
8789 // void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
8791 export function CResult_RouteDecodeErrorZ_free(_res: bigint): void {
8792 if(!isWasmInitialized) {
8793 throw new Error("initializeWasm() must be awaited first!");
8795 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_free(_res);
8796 // debug statements here
8798 // uint64_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg);
8800 export function CResult_RouteDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8801 if(!isWasmInitialized) {
8802 throw new Error("initializeWasm() must be awaited first!");
8804 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone_ptr(arg);
8805 return nativeResponseValue;
8807 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
8809 export function CResult_RouteDecodeErrorZ_clone(orig: bigint): bigint {
8810 if(!isWasmInitialized) {
8811 throw new Error("initializeWasm() must be awaited first!");
8813 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone(orig);
8814 return nativeResponseValue;
8816 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_ok(struct LDKRouteParameters o);
8818 export function CResult_RouteParametersDecodeErrorZ_ok(o: bigint): bigint {
8819 if(!isWasmInitialized) {
8820 throw new Error("initializeWasm() must be awaited first!");
8822 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_ok(o);
8823 return nativeResponseValue;
8825 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_err(struct LDKDecodeError e);
8827 export function CResult_RouteParametersDecodeErrorZ_err(e: bigint): bigint {
8828 if(!isWasmInitialized) {
8829 throw new Error("initializeWasm() must be awaited first!");
8831 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_err(e);
8832 return nativeResponseValue;
8834 // bool CResult_RouteParametersDecodeErrorZ_is_ok(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR o);
8836 export function CResult_RouteParametersDecodeErrorZ_is_ok(o: bigint): boolean {
8837 if(!isWasmInitialized) {
8838 throw new Error("initializeWasm() must be awaited first!");
8840 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_is_ok(o);
8841 return nativeResponseValue;
8843 // void CResult_RouteParametersDecodeErrorZ_free(struct LDKCResult_RouteParametersDecodeErrorZ _res);
8845 export function CResult_RouteParametersDecodeErrorZ_free(_res: bigint): void {
8846 if(!isWasmInitialized) {
8847 throw new Error("initializeWasm() must be awaited first!");
8849 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_free(_res);
8850 // debug statements here
8852 // uint64_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg);
8854 export function CResult_RouteParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8855 if(!isWasmInitialized) {
8856 throw new Error("initializeWasm() must be awaited first!");
8858 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(arg);
8859 return nativeResponseValue;
8861 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_clone(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR orig);
8863 export function CResult_RouteParametersDecodeErrorZ_clone(orig: bigint): bigint {
8864 if(!isWasmInitialized) {
8865 throw new Error("initializeWasm() must be awaited first!");
8867 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone(orig);
8868 return nativeResponseValue;
8870 // void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
8872 export function CVec_RouteHintZ_free(_res: number): void {
8873 if(!isWasmInitialized) {
8874 throw new Error("initializeWasm() must be awaited first!");
8876 const nativeResponseValue = wasm.TS_CVec_RouteHintZ_free(_res);
8877 // debug statements here
8879 // struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
8881 export function COption_u64Z_some(o: bigint): bigint {
8882 if(!isWasmInitialized) {
8883 throw new Error("initializeWasm() must be awaited first!");
8885 const nativeResponseValue = wasm.TS_COption_u64Z_some(o);
8886 return nativeResponseValue;
8888 // struct LDKCOption_u64Z COption_u64Z_none(void);
8890 export function COption_u64Z_none(): bigint {
8891 if(!isWasmInitialized) {
8892 throw new Error("initializeWasm() must be awaited first!");
8894 const nativeResponseValue = wasm.TS_COption_u64Z_none();
8895 return nativeResponseValue;
8897 // void COption_u64Z_free(struct LDKCOption_u64Z _res);
8899 export function COption_u64Z_free(_res: bigint): void {
8900 if(!isWasmInitialized) {
8901 throw new Error("initializeWasm() must be awaited first!");
8903 const nativeResponseValue = wasm.TS_COption_u64Z_free(_res);
8904 // debug statements here
8906 // uint64_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg);
8908 export function COption_u64Z_clone_ptr(arg: bigint): bigint {
8909 if(!isWasmInitialized) {
8910 throw new Error("initializeWasm() must be awaited first!");
8912 const nativeResponseValue = wasm.TS_COption_u64Z_clone_ptr(arg);
8913 return nativeResponseValue;
8915 // struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
8917 export function COption_u64Z_clone(orig: bigint): bigint {
8918 if(!isWasmInitialized) {
8919 throw new Error("initializeWasm() must be awaited first!");
8921 const nativeResponseValue = wasm.TS_COption_u64Z_clone(orig);
8922 return nativeResponseValue;
8924 // void CVec_u64Z_free(struct LDKCVec_u64Z _res);
8926 export function CVec_u64Z_free(_res: number): void {
8927 if(!isWasmInitialized) {
8928 throw new Error("initializeWasm() must be awaited first!");
8930 const nativeResponseValue = wasm.TS_CVec_u64Z_free(_res);
8931 // debug statements here
8933 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_ok(struct LDKPaymentParameters o);
8935 export function CResult_PaymentParametersDecodeErrorZ_ok(o: bigint): bigint {
8936 if(!isWasmInitialized) {
8937 throw new Error("initializeWasm() must be awaited first!");
8939 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_ok(o);
8940 return nativeResponseValue;
8942 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_err(struct LDKDecodeError e);
8944 export function CResult_PaymentParametersDecodeErrorZ_err(e: bigint): bigint {
8945 if(!isWasmInitialized) {
8946 throw new Error("initializeWasm() must be awaited first!");
8948 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_err(e);
8949 return nativeResponseValue;
8951 // bool CResult_PaymentParametersDecodeErrorZ_is_ok(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR o);
8953 export function CResult_PaymentParametersDecodeErrorZ_is_ok(o: bigint): boolean {
8954 if(!isWasmInitialized) {
8955 throw new Error("initializeWasm() must be awaited first!");
8957 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_is_ok(o);
8958 return nativeResponseValue;
8960 // void CResult_PaymentParametersDecodeErrorZ_free(struct LDKCResult_PaymentParametersDecodeErrorZ _res);
8962 export function CResult_PaymentParametersDecodeErrorZ_free(_res: bigint): void {
8963 if(!isWasmInitialized) {
8964 throw new Error("initializeWasm() must be awaited first!");
8966 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_free(_res);
8967 // debug statements here
8969 // uint64_t CResult_PaymentParametersDecodeErrorZ_clone_ptr(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR arg);
8971 export function CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8972 if(!isWasmInitialized) {
8973 throw new Error("initializeWasm() must be awaited first!");
8975 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg);
8976 return nativeResponseValue;
8978 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_clone(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR orig);
8980 export function CResult_PaymentParametersDecodeErrorZ_clone(orig: bigint): bigint {
8981 if(!isWasmInitialized) {
8982 throw new Error("initializeWasm() must be awaited first!");
8984 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone(orig);
8985 return nativeResponseValue;
8987 // void CVec_RouteHintHopZ_free(struct LDKCVec_RouteHintHopZ _res);
8989 export function CVec_RouteHintHopZ_free(_res: number): void {
8990 if(!isWasmInitialized) {
8991 throw new Error("initializeWasm() must be awaited first!");
8993 const nativeResponseValue = wasm.TS_CVec_RouteHintHopZ_free(_res);
8994 // debug statements here
8996 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_ok(struct LDKRouteHint o);
8998 export function CResult_RouteHintDecodeErrorZ_ok(o: bigint): bigint {
8999 if(!isWasmInitialized) {
9000 throw new Error("initializeWasm() must be awaited first!");
9002 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_ok(o);
9003 return nativeResponseValue;
9005 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_err(struct LDKDecodeError e);
9007 export function CResult_RouteHintDecodeErrorZ_err(e: bigint): bigint {
9008 if(!isWasmInitialized) {
9009 throw new Error("initializeWasm() must be awaited first!");
9011 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_err(e);
9012 return nativeResponseValue;
9014 // bool CResult_RouteHintDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR o);
9016 export function CResult_RouteHintDecodeErrorZ_is_ok(o: bigint): boolean {
9017 if(!isWasmInitialized) {
9018 throw new Error("initializeWasm() must be awaited first!");
9020 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_is_ok(o);
9021 return nativeResponseValue;
9023 // void CResult_RouteHintDecodeErrorZ_free(struct LDKCResult_RouteHintDecodeErrorZ _res);
9025 export function CResult_RouteHintDecodeErrorZ_free(_res: bigint): void {
9026 if(!isWasmInitialized) {
9027 throw new Error("initializeWasm() must be awaited first!");
9029 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_free(_res);
9030 // debug statements here
9032 // uint64_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg);
9034 export function CResult_RouteHintDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9035 if(!isWasmInitialized) {
9036 throw new Error("initializeWasm() must be awaited first!");
9038 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone_ptr(arg);
9039 return nativeResponseValue;
9041 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_clone(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR orig);
9043 export function CResult_RouteHintDecodeErrorZ_clone(orig: bigint): bigint {
9044 if(!isWasmInitialized) {
9045 throw new Error("initializeWasm() must be awaited first!");
9047 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone(orig);
9048 return nativeResponseValue;
9050 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_ok(struct LDKRouteHintHop o);
9052 export function CResult_RouteHintHopDecodeErrorZ_ok(o: bigint): bigint {
9053 if(!isWasmInitialized) {
9054 throw new Error("initializeWasm() must be awaited first!");
9056 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_ok(o);
9057 return nativeResponseValue;
9059 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_err(struct LDKDecodeError e);
9061 export function CResult_RouteHintHopDecodeErrorZ_err(e: bigint): bigint {
9062 if(!isWasmInitialized) {
9063 throw new Error("initializeWasm() must be awaited first!");
9065 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_err(e);
9066 return nativeResponseValue;
9068 // bool CResult_RouteHintHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR o);
9070 export function CResult_RouteHintHopDecodeErrorZ_is_ok(o: bigint): boolean {
9071 if(!isWasmInitialized) {
9072 throw new Error("initializeWasm() must be awaited first!");
9074 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_is_ok(o);
9075 return nativeResponseValue;
9077 // void CResult_RouteHintHopDecodeErrorZ_free(struct LDKCResult_RouteHintHopDecodeErrorZ _res);
9079 export function CResult_RouteHintHopDecodeErrorZ_free(_res: bigint): void {
9080 if(!isWasmInitialized) {
9081 throw new Error("initializeWasm() must be awaited first!");
9083 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_free(_res);
9084 // debug statements here
9086 // uint64_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg);
9088 export function CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9089 if(!isWasmInitialized) {
9090 throw new Error("initializeWasm() must be awaited first!");
9092 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg);
9093 return nativeResponseValue;
9095 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_clone(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR orig);
9097 export function CResult_RouteHintHopDecodeErrorZ_clone(orig: bigint): bigint {
9098 if(!isWasmInitialized) {
9099 throw new Error("initializeWasm() must be awaited first!");
9101 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone(orig);
9102 return nativeResponseValue;
9104 // void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
9106 export function CVec_ChannelDetailsZ_free(_res: number): void {
9107 if(!isWasmInitialized) {
9108 throw new Error("initializeWasm() must be awaited first!");
9110 const nativeResponseValue = wasm.TS_CVec_ChannelDetailsZ_free(_res);
9111 // debug statements here
9113 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
9115 export function CResult_RouteLightningErrorZ_ok(o: bigint): bigint {
9116 if(!isWasmInitialized) {
9117 throw new Error("initializeWasm() must be awaited first!");
9119 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_ok(o);
9120 return nativeResponseValue;
9122 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
9124 export function CResult_RouteLightningErrorZ_err(e: bigint): bigint {
9125 if(!isWasmInitialized) {
9126 throw new Error("initializeWasm() must be awaited first!");
9128 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_err(e);
9129 return nativeResponseValue;
9131 // bool CResult_RouteLightningErrorZ_is_ok(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR o);
9133 export function CResult_RouteLightningErrorZ_is_ok(o: bigint): boolean {
9134 if(!isWasmInitialized) {
9135 throw new Error("initializeWasm() must be awaited first!");
9137 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_is_ok(o);
9138 return nativeResponseValue;
9140 // void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
9142 export function CResult_RouteLightningErrorZ_free(_res: bigint): void {
9143 if(!isWasmInitialized) {
9144 throw new Error("initializeWasm() must be awaited first!");
9146 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_free(_res);
9147 // debug statements here
9149 // uint64_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg);
9151 export function CResult_RouteLightningErrorZ_clone_ptr(arg: bigint): bigint {
9152 if(!isWasmInitialized) {
9153 throw new Error("initializeWasm() must be awaited first!");
9155 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone_ptr(arg);
9156 return nativeResponseValue;
9158 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
9160 export function CResult_RouteLightningErrorZ_clone(orig: bigint): bigint {
9161 if(!isWasmInitialized) {
9162 throw new Error("initializeWasm() must be awaited first!");
9164 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone(orig);
9165 return nativeResponseValue;
9167 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_ok(struct LDKPaymentPurpose o);
9169 export function CResult_PaymentPurposeDecodeErrorZ_ok(o: bigint): bigint {
9170 if(!isWasmInitialized) {
9171 throw new Error("initializeWasm() must be awaited first!");
9173 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_ok(o);
9174 return nativeResponseValue;
9176 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_err(struct LDKDecodeError e);
9178 export function CResult_PaymentPurposeDecodeErrorZ_err(e: bigint): bigint {
9179 if(!isWasmInitialized) {
9180 throw new Error("initializeWasm() must be awaited first!");
9182 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_err(e);
9183 return nativeResponseValue;
9185 // bool CResult_PaymentPurposeDecodeErrorZ_is_ok(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR o);
9187 export function CResult_PaymentPurposeDecodeErrorZ_is_ok(o: bigint): boolean {
9188 if(!isWasmInitialized) {
9189 throw new Error("initializeWasm() must be awaited first!");
9191 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_is_ok(o);
9192 return nativeResponseValue;
9194 // void CResult_PaymentPurposeDecodeErrorZ_free(struct LDKCResult_PaymentPurposeDecodeErrorZ _res);
9196 export function CResult_PaymentPurposeDecodeErrorZ_free(_res: bigint): void {
9197 if(!isWasmInitialized) {
9198 throw new Error("initializeWasm() must be awaited first!");
9200 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_free(_res);
9201 // debug statements here
9203 // uint64_t CResult_PaymentPurposeDecodeErrorZ_clone_ptr(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR arg);
9205 export function CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9206 if(!isWasmInitialized) {
9207 throw new Error("initializeWasm() must be awaited first!");
9209 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg);
9210 return nativeResponseValue;
9212 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_clone(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR orig);
9214 export function CResult_PaymentPurposeDecodeErrorZ_clone(orig: bigint): bigint {
9215 if(!isWasmInitialized) {
9216 throw new Error("initializeWasm() must be awaited first!");
9218 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone(orig);
9219 return nativeResponseValue;
9221 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_some(struct LDKClosureReason o);
9223 export function COption_ClosureReasonZ_some(o: bigint): bigint {
9224 if(!isWasmInitialized) {
9225 throw new Error("initializeWasm() must be awaited first!");
9227 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_some(o);
9228 return nativeResponseValue;
9230 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_none(void);
9232 export function COption_ClosureReasonZ_none(): bigint {
9233 if(!isWasmInitialized) {
9234 throw new Error("initializeWasm() must be awaited first!");
9236 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_none();
9237 return nativeResponseValue;
9239 // void COption_ClosureReasonZ_free(struct LDKCOption_ClosureReasonZ _res);
9241 export function COption_ClosureReasonZ_free(_res: bigint): void {
9242 if(!isWasmInitialized) {
9243 throw new Error("initializeWasm() must be awaited first!");
9245 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_free(_res);
9246 // debug statements here
9248 // uint64_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg);
9250 export function COption_ClosureReasonZ_clone_ptr(arg: bigint): bigint {
9251 if(!isWasmInitialized) {
9252 throw new Error("initializeWasm() must be awaited first!");
9254 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone_ptr(arg);
9255 return nativeResponseValue;
9257 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_clone(const struct LDKCOption_ClosureReasonZ *NONNULL_PTR orig);
9259 export function COption_ClosureReasonZ_clone(orig: bigint): bigint {
9260 if(!isWasmInitialized) {
9261 throw new Error("initializeWasm() must be awaited first!");
9263 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone(orig);
9264 return nativeResponseValue;
9266 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_ok(struct LDKCOption_ClosureReasonZ o);
9268 export function CResult_COption_ClosureReasonZDecodeErrorZ_ok(o: bigint): bigint {
9269 if(!isWasmInitialized) {
9270 throw new Error("initializeWasm() must be awaited first!");
9272 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(o);
9273 return nativeResponseValue;
9275 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_err(struct LDKDecodeError e);
9277 export function CResult_COption_ClosureReasonZDecodeErrorZ_err(e: bigint): bigint {
9278 if(!isWasmInitialized) {
9279 throw new Error("initializeWasm() must be awaited first!");
9281 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(e);
9282 return nativeResponseValue;
9284 // bool CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR o);
9286 export function CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o: bigint): boolean {
9287 if(!isWasmInitialized) {
9288 throw new Error("initializeWasm() must be awaited first!");
9290 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o);
9291 return nativeResponseValue;
9293 // void CResult_COption_ClosureReasonZDecodeErrorZ_free(struct LDKCResult_COption_ClosureReasonZDecodeErrorZ _res);
9295 export function CResult_COption_ClosureReasonZDecodeErrorZ_free(_res: bigint): void {
9296 if(!isWasmInitialized) {
9297 throw new Error("initializeWasm() must be awaited first!");
9299 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(_res);
9300 // debug statements here
9302 // uint64_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg);
9304 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9305 if(!isWasmInitialized) {
9306 throw new Error("initializeWasm() must be awaited first!");
9308 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg);
9309 return nativeResponseValue;
9311 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_clone(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR orig);
9313 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig: bigint): bigint {
9314 if(!isWasmInitialized) {
9315 throw new Error("initializeWasm() must be awaited first!");
9317 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig);
9318 return nativeResponseValue;
9320 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_some(struct LDKHTLCDestination o);
9322 export function COption_HTLCDestinationZ_some(o: bigint): bigint {
9323 if(!isWasmInitialized) {
9324 throw new Error("initializeWasm() must be awaited first!");
9326 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_some(o);
9327 return nativeResponseValue;
9329 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_none(void);
9331 export function COption_HTLCDestinationZ_none(): bigint {
9332 if(!isWasmInitialized) {
9333 throw new Error("initializeWasm() must be awaited first!");
9335 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_none();
9336 return nativeResponseValue;
9338 // void COption_HTLCDestinationZ_free(struct LDKCOption_HTLCDestinationZ _res);
9340 export function COption_HTLCDestinationZ_free(_res: bigint): void {
9341 if(!isWasmInitialized) {
9342 throw new Error("initializeWasm() must be awaited first!");
9344 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_free(_res);
9345 // debug statements here
9347 // uint64_t COption_HTLCDestinationZ_clone_ptr(LDKCOption_HTLCDestinationZ *NONNULL_PTR arg);
9349 export function COption_HTLCDestinationZ_clone_ptr(arg: bigint): bigint {
9350 if(!isWasmInitialized) {
9351 throw new Error("initializeWasm() must be awaited first!");
9353 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone_ptr(arg);
9354 return nativeResponseValue;
9356 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_clone(const struct LDKCOption_HTLCDestinationZ *NONNULL_PTR orig);
9358 export function COption_HTLCDestinationZ_clone(orig: bigint): bigint {
9359 if(!isWasmInitialized) {
9360 throw new Error("initializeWasm() must be awaited first!");
9362 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone(orig);
9363 return nativeResponseValue;
9365 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_ok(struct LDKCOption_HTLCDestinationZ o);
9367 export function CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o: bigint): bigint {
9368 if(!isWasmInitialized) {
9369 throw new Error("initializeWasm() must be awaited first!");
9371 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o);
9372 return nativeResponseValue;
9374 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_err(struct LDKDecodeError e);
9376 export function CResult_COption_HTLCDestinationZDecodeErrorZ_err(e: bigint): bigint {
9377 if(!isWasmInitialized) {
9378 throw new Error("initializeWasm() must be awaited first!");
9380 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_err(e);
9381 return nativeResponseValue;
9383 // bool CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR o);
9385 export function CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o: bigint): boolean {
9386 if(!isWasmInitialized) {
9387 throw new Error("initializeWasm() must be awaited first!");
9389 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o);
9390 return nativeResponseValue;
9392 // void CResult_COption_HTLCDestinationZDecodeErrorZ_free(struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ _res);
9394 export function CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res: bigint): void {
9395 if(!isWasmInitialized) {
9396 throw new Error("initializeWasm() must be awaited first!");
9398 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res);
9399 // debug statements here
9401 // uint64_t CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR arg);
9403 export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9404 if(!isWasmInitialized) {
9405 throw new Error("initializeWasm() must be awaited first!");
9407 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg);
9408 return nativeResponseValue;
9410 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_clone(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR orig);
9412 export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig: bigint): bigint {
9413 if(!isWasmInitialized) {
9414 throw new Error("initializeWasm() must be awaited first!");
9416 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig);
9417 return nativeResponseValue;
9419 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_some(struct LDKNetworkUpdate o);
9421 export function COption_NetworkUpdateZ_some(o: bigint): bigint {
9422 if(!isWasmInitialized) {
9423 throw new Error("initializeWasm() must be awaited first!");
9425 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_some(o);
9426 return nativeResponseValue;
9428 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_none(void);
9430 export function COption_NetworkUpdateZ_none(): bigint {
9431 if(!isWasmInitialized) {
9432 throw new Error("initializeWasm() must be awaited first!");
9434 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_none();
9435 return nativeResponseValue;
9437 // void COption_NetworkUpdateZ_free(struct LDKCOption_NetworkUpdateZ _res);
9439 export function COption_NetworkUpdateZ_free(_res: bigint): void {
9440 if(!isWasmInitialized) {
9441 throw new Error("initializeWasm() must be awaited first!");
9443 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_free(_res);
9444 // debug statements here
9446 // uint64_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg);
9448 export function COption_NetworkUpdateZ_clone_ptr(arg: bigint): bigint {
9449 if(!isWasmInitialized) {
9450 throw new Error("initializeWasm() must be awaited first!");
9452 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone_ptr(arg);
9453 return nativeResponseValue;
9455 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_clone(const struct LDKCOption_NetworkUpdateZ *NONNULL_PTR orig);
9457 export function COption_NetworkUpdateZ_clone(orig: bigint): bigint {
9458 if(!isWasmInitialized) {
9459 throw new Error("initializeWasm() must be awaited first!");
9461 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone(orig);
9462 return nativeResponseValue;
9464 // void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
9466 export function CVec_SpendableOutputDescriptorZ_free(_res: number): void {
9467 if(!isWasmInitialized) {
9468 throw new Error("initializeWasm() must be awaited first!");
9470 const nativeResponseValue = wasm.TS_CVec_SpendableOutputDescriptorZ_free(_res);
9471 // debug statements here
9473 // struct LDKCOption_EventZ COption_EventZ_some(struct LDKEvent o);
9475 export function COption_EventZ_some(o: bigint): bigint {
9476 if(!isWasmInitialized) {
9477 throw new Error("initializeWasm() must be awaited first!");
9479 const nativeResponseValue = wasm.TS_COption_EventZ_some(o);
9480 return nativeResponseValue;
9482 // struct LDKCOption_EventZ COption_EventZ_none(void);
9484 export function COption_EventZ_none(): bigint {
9485 if(!isWasmInitialized) {
9486 throw new Error("initializeWasm() must be awaited first!");
9488 const nativeResponseValue = wasm.TS_COption_EventZ_none();
9489 return nativeResponseValue;
9491 // void COption_EventZ_free(struct LDKCOption_EventZ _res);
9493 export function COption_EventZ_free(_res: bigint): void {
9494 if(!isWasmInitialized) {
9495 throw new Error("initializeWasm() must be awaited first!");
9497 const nativeResponseValue = wasm.TS_COption_EventZ_free(_res);
9498 // debug statements here
9500 // uint64_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg);
9502 export function COption_EventZ_clone_ptr(arg: bigint): bigint {
9503 if(!isWasmInitialized) {
9504 throw new Error("initializeWasm() must be awaited first!");
9506 const nativeResponseValue = wasm.TS_COption_EventZ_clone_ptr(arg);
9507 return nativeResponseValue;
9509 // struct LDKCOption_EventZ COption_EventZ_clone(const struct LDKCOption_EventZ *NONNULL_PTR orig);
9511 export function COption_EventZ_clone(orig: bigint): bigint {
9512 if(!isWasmInitialized) {
9513 throw new Error("initializeWasm() must be awaited first!");
9515 const nativeResponseValue = wasm.TS_COption_EventZ_clone(orig);
9516 return nativeResponseValue;
9518 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_ok(struct LDKCOption_EventZ o);
9520 export function CResult_COption_EventZDecodeErrorZ_ok(o: bigint): bigint {
9521 if(!isWasmInitialized) {
9522 throw new Error("initializeWasm() must be awaited first!");
9524 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_ok(o);
9525 return nativeResponseValue;
9527 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_err(struct LDKDecodeError e);
9529 export function CResult_COption_EventZDecodeErrorZ_err(e: bigint): bigint {
9530 if(!isWasmInitialized) {
9531 throw new Error("initializeWasm() must be awaited first!");
9533 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_err(e);
9534 return nativeResponseValue;
9536 // bool CResult_COption_EventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR o);
9538 export function CResult_COption_EventZDecodeErrorZ_is_ok(o: bigint): boolean {
9539 if(!isWasmInitialized) {
9540 throw new Error("initializeWasm() must be awaited first!");
9542 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_is_ok(o);
9543 return nativeResponseValue;
9545 // void CResult_COption_EventZDecodeErrorZ_free(struct LDKCResult_COption_EventZDecodeErrorZ _res);
9547 export function CResult_COption_EventZDecodeErrorZ_free(_res: bigint): void {
9548 if(!isWasmInitialized) {
9549 throw new Error("initializeWasm() must be awaited first!");
9551 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_free(_res);
9552 // debug statements here
9554 // uint64_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg);
9556 export function CResult_COption_EventZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9557 if(!isWasmInitialized) {
9558 throw new Error("initializeWasm() must be awaited first!");
9560 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(arg);
9561 return nativeResponseValue;
9563 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_clone(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR orig);
9565 export function CResult_COption_EventZDecodeErrorZ_clone(orig: bigint): bigint {
9566 if(!isWasmInitialized) {
9567 throw new Error("initializeWasm() must be awaited first!");
9569 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone(orig);
9570 return nativeResponseValue;
9572 // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
9574 export function CVec_MessageSendEventZ_free(_res: number): void {
9575 if(!isWasmInitialized) {
9576 throw new Error("initializeWasm() must be awaited first!");
9578 const nativeResponseValue = wasm.TS_CVec_MessageSendEventZ_free(_res);
9579 // debug statements here
9581 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_ok(struct LDKTxOut o);
9583 export function CResult_TxOutAccessErrorZ_ok(o: bigint): bigint {
9584 if(!isWasmInitialized) {
9585 throw new Error("initializeWasm() must be awaited first!");
9587 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_ok(o);
9588 return nativeResponseValue;
9590 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_err(enum LDKAccessError e);
9592 export function CResult_TxOutAccessErrorZ_err(e: AccessError): bigint {
9593 if(!isWasmInitialized) {
9594 throw new Error("initializeWasm() must be awaited first!");
9596 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_err(e);
9597 return nativeResponseValue;
9599 // bool CResult_TxOutAccessErrorZ_is_ok(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR o);
9601 export function CResult_TxOutAccessErrorZ_is_ok(o: bigint): boolean {
9602 if(!isWasmInitialized) {
9603 throw new Error("initializeWasm() must be awaited first!");
9605 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_is_ok(o);
9606 return nativeResponseValue;
9608 // void CResult_TxOutAccessErrorZ_free(struct LDKCResult_TxOutAccessErrorZ _res);
9610 export function CResult_TxOutAccessErrorZ_free(_res: bigint): void {
9611 if(!isWasmInitialized) {
9612 throw new Error("initializeWasm() must be awaited first!");
9614 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_free(_res);
9615 // debug statements here
9617 // uint64_t CResult_TxOutAccessErrorZ_clone_ptr(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR arg);
9619 export function CResult_TxOutAccessErrorZ_clone_ptr(arg: bigint): bigint {
9620 if(!isWasmInitialized) {
9621 throw new Error("initializeWasm() must be awaited first!");
9623 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone_ptr(arg);
9624 return nativeResponseValue;
9626 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_clone(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR orig);
9628 export function CResult_TxOutAccessErrorZ_clone(orig: bigint): bigint {
9629 if(!isWasmInitialized) {
9630 throw new Error("initializeWasm() must be awaited first!");
9632 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone(orig);
9633 return nativeResponseValue;
9635 // uint64_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg);
9637 export function C2Tuple_usizeTransactionZ_clone_ptr(arg: bigint): bigint {
9638 if(!isWasmInitialized) {
9639 throw new Error("initializeWasm() must be awaited first!");
9641 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone_ptr(arg);
9642 return nativeResponseValue;
9644 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_clone(const struct LDKC2Tuple_usizeTransactionZ *NONNULL_PTR orig);
9646 export function C2Tuple_usizeTransactionZ_clone(orig: bigint): bigint {
9647 if(!isWasmInitialized) {
9648 throw new Error("initializeWasm() must be awaited first!");
9650 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone(orig);
9651 return nativeResponseValue;
9653 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
9655 export function C2Tuple_usizeTransactionZ_new(a: number, b: number): bigint {
9656 if(!isWasmInitialized) {
9657 throw new Error("initializeWasm() must be awaited first!");
9659 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_new(a, b);
9660 return nativeResponseValue;
9662 // void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
9664 export function C2Tuple_usizeTransactionZ_free(_res: bigint): void {
9665 if(!isWasmInitialized) {
9666 throw new Error("initializeWasm() must be awaited first!");
9668 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_free(_res);
9669 // debug statements here
9671 // void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
9673 export function CVec_C2Tuple_usizeTransactionZZ_free(_res: number): void {
9674 if(!isWasmInitialized) {
9675 throw new Error("initializeWasm() must be awaited first!");
9677 const nativeResponseValue = wasm.TS_CVec_C2Tuple_usizeTransactionZZ_free(_res);
9678 // debug statements here
9680 // void CVec_TxidZ_free(struct LDKCVec_TxidZ _res);
9682 export function CVec_TxidZ_free(_res: number): void {
9683 if(!isWasmInitialized) {
9684 throw new Error("initializeWasm() must be awaited first!");
9686 const nativeResponseValue = wasm.TS_CVec_TxidZ_free(_res);
9687 // debug statements here
9689 // void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
9691 export function CVec_MonitorEventZ_free(_res: number): void {
9692 if(!isWasmInitialized) {
9693 throw new Error("initializeWasm() must be awaited first!");
9695 const nativeResponseValue = wasm.TS_CVec_MonitorEventZ_free(_res);
9696 // debug statements here
9698 // uint64_t C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR arg);
9700 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg: bigint): bigint {
9701 if(!isWasmInitialized) {
9702 throw new Error("initializeWasm() must be awaited first!");
9704 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg);
9705 return nativeResponseValue;
9707 // struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(const struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR orig);
9709 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig: bigint): bigint {
9710 if(!isWasmInitialized) {
9711 throw new Error("initializeWasm() must be awaited first!");
9713 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig);
9714 return nativeResponseValue;
9716 // struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(struct LDKOutPoint a, struct LDKCVec_MonitorEventZ b, struct LDKPublicKey c);
9718 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a: bigint, b: number, c: number): bigint {
9719 if(!isWasmInitialized) {
9720 throw new Error("initializeWasm() must be awaited first!");
9722 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a, b, c);
9723 return nativeResponseValue;
9725 // void C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ _res);
9727 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res: bigint): void {
9728 if(!isWasmInitialized) {
9729 throw new Error("initializeWasm() must be awaited first!");
9731 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res);
9732 // debug statements here
9734 // void CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(struct LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ _res);
9736 export function CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res: number): void {
9737 if(!isWasmInitialized) {
9738 throw new Error("initializeWasm() must be awaited first!");
9740 const nativeResponseValue = wasm.TS_CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res);
9741 // debug statements here
9743 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_ok(struct LDKFixedPenaltyScorer o);
9745 export function CResult_FixedPenaltyScorerDecodeErrorZ_ok(o: bigint): bigint {
9746 if(!isWasmInitialized) {
9747 throw new Error("initializeWasm() must be awaited first!");
9749 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok(o);
9750 return nativeResponseValue;
9752 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_err(struct LDKDecodeError e);
9754 export function CResult_FixedPenaltyScorerDecodeErrorZ_err(e: bigint): bigint {
9755 if(!isWasmInitialized) {
9756 throw new Error("initializeWasm() must be awaited first!");
9758 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_err(e);
9759 return nativeResponseValue;
9761 // bool CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR o);
9763 export function CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o: bigint): boolean {
9764 if(!isWasmInitialized) {
9765 throw new Error("initializeWasm() must be awaited first!");
9767 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o);
9768 return nativeResponseValue;
9770 // void CResult_FixedPenaltyScorerDecodeErrorZ_free(struct LDKCResult_FixedPenaltyScorerDecodeErrorZ _res);
9772 export function CResult_FixedPenaltyScorerDecodeErrorZ_free(_res: bigint): void {
9773 if(!isWasmInitialized) {
9774 throw new Error("initializeWasm() must be awaited first!");
9776 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_free(_res);
9777 // debug statements here
9779 // uint64_t CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR arg);
9781 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9782 if(!isWasmInitialized) {
9783 throw new Error("initializeWasm() must be awaited first!");
9785 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg);
9786 return nativeResponseValue;
9788 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_clone(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR orig);
9790 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig: bigint): bigint {
9791 if(!isWasmInitialized) {
9792 throw new Error("initializeWasm() must be awaited first!");
9794 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig);
9795 return nativeResponseValue;
9797 // uint64_t C2Tuple_u64u64Z_clone_ptr(LDKC2Tuple_u64u64Z *NONNULL_PTR arg);
9799 export function C2Tuple_u64u64Z_clone_ptr(arg: bigint): bigint {
9800 if(!isWasmInitialized) {
9801 throw new Error("initializeWasm() must be awaited first!");
9803 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone_ptr(arg);
9804 return nativeResponseValue;
9806 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_clone(const struct LDKC2Tuple_u64u64Z *NONNULL_PTR orig);
9808 export function C2Tuple_u64u64Z_clone(orig: bigint): bigint {
9809 if(!isWasmInitialized) {
9810 throw new Error("initializeWasm() must be awaited first!");
9812 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone(orig);
9813 return nativeResponseValue;
9815 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_new(uint64_t a, uint64_t b);
9817 export function C2Tuple_u64u64Z_new(a: bigint, b: bigint): bigint {
9818 if(!isWasmInitialized) {
9819 throw new Error("initializeWasm() must be awaited first!");
9821 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_new(a, b);
9822 return nativeResponseValue;
9824 // void C2Tuple_u64u64Z_free(struct LDKC2Tuple_u64u64Z _res);
9826 export function C2Tuple_u64u64Z_free(_res: bigint): void {
9827 if(!isWasmInitialized) {
9828 throw new Error("initializeWasm() must be awaited first!");
9830 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_free(_res);
9831 // debug statements here
9833 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_some(struct LDKC2Tuple_u64u64Z o);
9835 export function COption_C2Tuple_u64u64ZZ_some(o: bigint): bigint {
9836 if(!isWasmInitialized) {
9837 throw new Error("initializeWasm() must be awaited first!");
9839 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_some(o);
9840 return nativeResponseValue;
9842 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_none(void);
9844 export function COption_C2Tuple_u64u64ZZ_none(): bigint {
9845 if(!isWasmInitialized) {
9846 throw new Error("initializeWasm() must be awaited first!");
9848 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_none();
9849 return nativeResponseValue;
9851 // void COption_C2Tuple_u64u64ZZ_free(struct LDKCOption_C2Tuple_u64u64ZZ _res);
9853 export function COption_C2Tuple_u64u64ZZ_free(_res: bigint): void {
9854 if(!isWasmInitialized) {
9855 throw new Error("initializeWasm() must be awaited first!");
9857 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_free(_res);
9858 // debug statements here
9860 // uint64_t COption_C2Tuple_u64u64ZZ_clone_ptr(LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR arg);
9862 export function COption_C2Tuple_u64u64ZZ_clone_ptr(arg: bigint): bigint {
9863 if(!isWasmInitialized) {
9864 throw new Error("initializeWasm() must be awaited first!");
9866 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone_ptr(arg);
9867 return nativeResponseValue;
9869 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_clone(const struct LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR orig);
9871 export function COption_C2Tuple_u64u64ZZ_clone(orig: bigint): bigint {
9872 if(!isWasmInitialized) {
9873 throw new Error("initializeWasm() must be awaited first!");
9875 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone(orig);
9876 return nativeResponseValue;
9878 // void CVec_NodeIdZ_free(struct LDKCVec_NodeIdZ _res);
9880 export function CVec_NodeIdZ_free(_res: number): void {
9881 if(!isWasmInitialized) {
9882 throw new Error("initializeWasm() must be awaited first!");
9884 const nativeResponseValue = wasm.TS_CVec_NodeIdZ_free(_res);
9885 // debug statements here
9887 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_ok(struct LDKProbabilisticScorer o);
9889 export function CResult_ProbabilisticScorerDecodeErrorZ_ok(o: bigint): bigint {
9890 if(!isWasmInitialized) {
9891 throw new Error("initializeWasm() must be awaited first!");
9893 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_ok(o);
9894 return nativeResponseValue;
9896 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_err(struct LDKDecodeError e);
9898 export function CResult_ProbabilisticScorerDecodeErrorZ_err(e: bigint): bigint {
9899 if(!isWasmInitialized) {
9900 throw new Error("initializeWasm() must be awaited first!");
9902 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_err(e);
9903 return nativeResponseValue;
9905 // bool CResult_ProbabilisticScorerDecodeErrorZ_is_ok(const struct LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR o);
9907 export function CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o: bigint): boolean {
9908 if(!isWasmInitialized) {
9909 throw new Error("initializeWasm() must be awaited first!");
9911 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o);
9912 return nativeResponseValue;
9914 // void CResult_ProbabilisticScorerDecodeErrorZ_free(struct LDKCResult_ProbabilisticScorerDecodeErrorZ _res);
9916 export function CResult_ProbabilisticScorerDecodeErrorZ_free(_res: bigint): void {
9917 if(!isWasmInitialized) {
9918 throw new Error("initializeWasm() must be awaited first!");
9920 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_free(_res);
9921 // debug statements here
9923 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
9925 export function CResult_InitFeaturesDecodeErrorZ_ok(o: bigint): bigint {
9926 if(!isWasmInitialized) {
9927 throw new Error("initializeWasm() must be awaited first!");
9929 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_ok(o);
9930 return nativeResponseValue;
9932 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
9934 export function CResult_InitFeaturesDecodeErrorZ_err(e: bigint): bigint {
9935 if(!isWasmInitialized) {
9936 throw new Error("initializeWasm() must be awaited first!");
9938 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_err(e);
9939 return nativeResponseValue;
9941 // bool CResult_InitFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR o);
9943 export function CResult_InitFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
9944 if(!isWasmInitialized) {
9945 throw new Error("initializeWasm() must be awaited first!");
9947 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_is_ok(o);
9948 return nativeResponseValue;
9950 // void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
9952 export function CResult_InitFeaturesDecodeErrorZ_free(_res: bigint): void {
9953 if(!isWasmInitialized) {
9954 throw new Error("initializeWasm() must be awaited first!");
9956 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_free(_res);
9957 // debug statements here
9959 // uint64_t CResult_InitFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR arg);
9961 export function CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9962 if(!isWasmInitialized) {
9963 throw new Error("initializeWasm() must be awaited first!");
9965 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg);
9966 return nativeResponseValue;
9968 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_clone(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR orig);
9970 export function CResult_InitFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
9971 if(!isWasmInitialized) {
9972 throw new Error("initializeWasm() must be awaited first!");
9974 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone(orig);
9975 return nativeResponseValue;
9977 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
9979 export function CResult_ChannelFeaturesDecodeErrorZ_ok(o: bigint): bigint {
9980 if(!isWasmInitialized) {
9981 throw new Error("initializeWasm() must be awaited first!");
9983 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_ok(o);
9984 return nativeResponseValue;
9986 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
9988 export function CResult_ChannelFeaturesDecodeErrorZ_err(e: bigint): bigint {
9989 if(!isWasmInitialized) {
9990 throw new Error("initializeWasm() must be awaited first!");
9992 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_err(e);
9993 return nativeResponseValue;
9995 // bool CResult_ChannelFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR o);
9997 export function CResult_ChannelFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
9998 if(!isWasmInitialized) {
9999 throw new Error("initializeWasm() must be awaited first!");
10001 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(o);
10002 return nativeResponseValue;
10004 // void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
10006 export function CResult_ChannelFeaturesDecodeErrorZ_free(_res: bigint): void {
10007 if(!isWasmInitialized) {
10008 throw new Error("initializeWasm() must be awaited first!");
10010 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_free(_res);
10011 // debug statements here
10013 // uint64_t CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR arg);
10015 export function CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10016 if(!isWasmInitialized) {
10017 throw new Error("initializeWasm() must be awaited first!");
10019 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg);
10020 return nativeResponseValue;
10022 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR orig);
10024 export function CResult_ChannelFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
10025 if(!isWasmInitialized) {
10026 throw new Error("initializeWasm() must be awaited first!");
10028 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone(orig);
10029 return nativeResponseValue;
10031 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
10033 export function CResult_NodeFeaturesDecodeErrorZ_ok(o: bigint): bigint {
10034 if(!isWasmInitialized) {
10035 throw new Error("initializeWasm() must be awaited first!");
10037 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_ok(o);
10038 return nativeResponseValue;
10040 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
10042 export function CResult_NodeFeaturesDecodeErrorZ_err(e: bigint): bigint {
10043 if(!isWasmInitialized) {
10044 throw new Error("initializeWasm() must be awaited first!");
10046 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_err(e);
10047 return nativeResponseValue;
10049 // bool CResult_NodeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR o);
10051 export function CResult_NodeFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
10052 if(!isWasmInitialized) {
10053 throw new Error("initializeWasm() must be awaited first!");
10055 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(o);
10056 return nativeResponseValue;
10058 // void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
10060 export function CResult_NodeFeaturesDecodeErrorZ_free(_res: bigint): void {
10061 if(!isWasmInitialized) {
10062 throw new Error("initializeWasm() must be awaited first!");
10064 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_free(_res);
10065 // debug statements here
10067 // uint64_t CResult_NodeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR arg);
10069 export function CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10070 if(!isWasmInitialized) {
10071 throw new Error("initializeWasm() must be awaited first!");
10073 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg);
10074 return nativeResponseValue;
10076 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_clone(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR orig);
10078 export function CResult_NodeFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
10079 if(!isWasmInitialized) {
10080 throw new Error("initializeWasm() must be awaited first!");
10082 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone(orig);
10083 return nativeResponseValue;
10085 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_ok(struct LDKInvoiceFeatures o);
10087 export function CResult_InvoiceFeaturesDecodeErrorZ_ok(o: bigint): bigint {
10088 if(!isWasmInitialized) {
10089 throw new Error("initializeWasm() must be awaited first!");
10091 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_ok(o);
10092 return nativeResponseValue;
10094 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
10096 export function CResult_InvoiceFeaturesDecodeErrorZ_err(e: bigint): bigint {
10097 if(!isWasmInitialized) {
10098 throw new Error("initializeWasm() must be awaited first!");
10100 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_err(e);
10101 return nativeResponseValue;
10103 // bool CResult_InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
10105 export function CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
10106 if(!isWasmInitialized) {
10107 throw new Error("initializeWasm() must be awaited first!");
10109 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o);
10110 return nativeResponseValue;
10112 // void CResult_InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_InvoiceFeaturesDecodeErrorZ _res);
10114 export function CResult_InvoiceFeaturesDecodeErrorZ_free(_res: bigint): void {
10115 if(!isWasmInitialized) {
10116 throw new Error("initializeWasm() must be awaited first!");
10118 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_free(_res);
10119 // debug statements here
10121 // uint64_t CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg);
10123 export function CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10124 if(!isWasmInitialized) {
10125 throw new Error("initializeWasm() must be awaited first!");
10127 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg);
10128 return nativeResponseValue;
10130 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_clone(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR orig);
10132 export function CResult_InvoiceFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
10133 if(!isWasmInitialized) {
10134 throw new Error("initializeWasm() must be awaited first!");
10136 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_clone(orig);
10137 return nativeResponseValue;
10139 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_ok(struct LDKChannelTypeFeatures o);
10141 export function CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o: bigint): bigint {
10142 if(!isWasmInitialized) {
10143 throw new Error("initializeWasm() must be awaited first!");
10145 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o);
10146 return nativeResponseValue;
10148 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
10150 export function CResult_ChannelTypeFeaturesDecodeErrorZ_err(e: bigint): bigint {
10151 if(!isWasmInitialized) {
10152 throw new Error("initializeWasm() must be awaited first!");
10154 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(e);
10155 return nativeResponseValue;
10157 // bool CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR o);
10159 export function CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
10160 if(!isWasmInitialized) {
10161 throw new Error("initializeWasm() must be awaited first!");
10163 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o);
10164 return nativeResponseValue;
10166 // void CResult_ChannelTypeFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res);
10168 export function CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res: bigint): void {
10169 if(!isWasmInitialized) {
10170 throw new Error("initializeWasm() must be awaited first!");
10172 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res);
10173 // debug statements here
10175 // uint64_t CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR arg);
10177 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10178 if(!isWasmInitialized) {
10179 throw new Error("initializeWasm() must be awaited first!");
10181 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg);
10182 return nativeResponseValue;
10184 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR orig);
10186 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
10187 if(!isWasmInitialized) {
10188 throw new Error("initializeWasm() must be awaited first!");
10190 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig);
10191 return nativeResponseValue;
10193 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_ok(struct LDKNodeId o);
10195 export function CResult_NodeIdDecodeErrorZ_ok(o: bigint): bigint {
10196 if(!isWasmInitialized) {
10197 throw new Error("initializeWasm() must be awaited first!");
10199 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_ok(o);
10200 return nativeResponseValue;
10202 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_err(struct LDKDecodeError e);
10204 export function CResult_NodeIdDecodeErrorZ_err(e: bigint): bigint {
10205 if(!isWasmInitialized) {
10206 throw new Error("initializeWasm() must be awaited first!");
10208 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_err(e);
10209 return nativeResponseValue;
10211 // bool CResult_NodeIdDecodeErrorZ_is_ok(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR o);
10213 export function CResult_NodeIdDecodeErrorZ_is_ok(o: bigint): boolean {
10214 if(!isWasmInitialized) {
10215 throw new Error("initializeWasm() must be awaited first!");
10217 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_is_ok(o);
10218 return nativeResponseValue;
10220 // void CResult_NodeIdDecodeErrorZ_free(struct LDKCResult_NodeIdDecodeErrorZ _res);
10222 export function CResult_NodeIdDecodeErrorZ_free(_res: bigint): void {
10223 if(!isWasmInitialized) {
10224 throw new Error("initializeWasm() must be awaited first!");
10226 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_free(_res);
10227 // debug statements here
10229 // uint64_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg);
10231 export function CResult_NodeIdDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10232 if(!isWasmInitialized) {
10233 throw new Error("initializeWasm() must be awaited first!");
10235 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone_ptr(arg);
10236 return nativeResponseValue;
10238 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_clone(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR orig);
10240 export function CResult_NodeIdDecodeErrorZ_clone(orig: bigint): bigint {
10241 if(!isWasmInitialized) {
10242 throw new Error("initializeWasm() must be awaited first!");
10244 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone(orig);
10245 return nativeResponseValue;
10247 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_ok(struct LDKCOption_NetworkUpdateZ o);
10249 export function CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o: bigint): bigint {
10250 if(!isWasmInitialized) {
10251 throw new Error("initializeWasm() must be awaited first!");
10253 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o);
10254 return nativeResponseValue;
10256 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_err(struct LDKDecodeError e);
10258 export function CResult_COption_NetworkUpdateZDecodeErrorZ_err(e: bigint): bigint {
10259 if(!isWasmInitialized) {
10260 throw new Error("initializeWasm() must be awaited first!");
10262 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(e);
10263 return nativeResponseValue;
10265 // bool CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR o);
10267 export function CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o: bigint): boolean {
10268 if(!isWasmInitialized) {
10269 throw new Error("initializeWasm() must be awaited first!");
10271 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o);
10272 return nativeResponseValue;
10274 // void CResult_COption_NetworkUpdateZDecodeErrorZ_free(struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res);
10276 export function CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res: bigint): void {
10277 if(!isWasmInitialized) {
10278 throw new Error("initializeWasm() must be awaited first!");
10280 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res);
10281 // debug statements here
10283 // uint64_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg);
10285 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10286 if(!isWasmInitialized) {
10287 throw new Error("initializeWasm() must be awaited first!");
10289 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg);
10290 return nativeResponseValue;
10292 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_clone(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR orig);
10294 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig: bigint): bigint {
10295 if(!isWasmInitialized) {
10296 throw new Error("initializeWasm() must be awaited first!");
10298 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig);
10299 return nativeResponseValue;
10301 // struct LDKCOption_AccessZ COption_AccessZ_some(struct LDKAccess o);
10303 export function COption_AccessZ_some(o: bigint): bigint {
10304 if(!isWasmInitialized) {
10305 throw new Error("initializeWasm() must be awaited first!");
10307 const nativeResponseValue = wasm.TS_COption_AccessZ_some(o);
10308 return nativeResponseValue;
10310 // struct LDKCOption_AccessZ COption_AccessZ_none(void);
10312 export function COption_AccessZ_none(): bigint {
10313 if(!isWasmInitialized) {
10314 throw new Error("initializeWasm() must be awaited first!");
10316 const nativeResponseValue = wasm.TS_COption_AccessZ_none();
10317 return nativeResponseValue;
10319 // void COption_AccessZ_free(struct LDKCOption_AccessZ _res);
10321 export function COption_AccessZ_free(_res: bigint): void {
10322 if(!isWasmInitialized) {
10323 throw new Error("initializeWasm() must be awaited first!");
10325 const nativeResponseValue = wasm.TS_COption_AccessZ_free(_res);
10326 // debug statements here
10328 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
10330 export function CResult_boolLightningErrorZ_ok(o: boolean): bigint {
10331 if(!isWasmInitialized) {
10332 throw new Error("initializeWasm() must be awaited first!");
10334 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_ok(o);
10335 return nativeResponseValue;
10337 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
10339 export function CResult_boolLightningErrorZ_err(e: bigint): bigint {
10340 if(!isWasmInitialized) {
10341 throw new Error("initializeWasm() must be awaited first!");
10343 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_err(e);
10344 return nativeResponseValue;
10346 // bool CResult_boolLightningErrorZ_is_ok(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR o);
10348 export function CResult_boolLightningErrorZ_is_ok(o: bigint): boolean {
10349 if(!isWasmInitialized) {
10350 throw new Error("initializeWasm() must be awaited first!");
10352 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_is_ok(o);
10353 return nativeResponseValue;
10355 // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
10357 export function CResult_boolLightningErrorZ_free(_res: bigint): void {
10358 if(!isWasmInitialized) {
10359 throw new Error("initializeWasm() must be awaited first!");
10361 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_free(_res);
10362 // debug statements here
10364 // uint64_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg);
10366 export function CResult_boolLightningErrorZ_clone_ptr(arg: bigint): bigint {
10367 if(!isWasmInitialized) {
10368 throw new Error("initializeWasm() must be awaited first!");
10370 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone_ptr(arg);
10371 return nativeResponseValue;
10373 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
10375 export function CResult_boolLightningErrorZ_clone(orig: bigint): bigint {
10376 if(!isWasmInitialized) {
10377 throw new Error("initializeWasm() must be awaited first!");
10379 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone(orig);
10380 return nativeResponseValue;
10382 // uint64_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg);
10384 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg: bigint): bigint {
10385 if(!isWasmInitialized) {
10386 throw new Error("initializeWasm() must be awaited first!");
10388 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg);
10389 return nativeResponseValue;
10391 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
10393 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: bigint): bigint {
10394 if(!isWasmInitialized) {
10395 throw new Error("initializeWasm() must be awaited first!");
10397 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig);
10398 return nativeResponseValue;
10400 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
10402 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: bigint, b: bigint, c: bigint): bigint {
10403 if(!isWasmInitialized) {
10404 throw new Error("initializeWasm() must be awaited first!");
10406 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c);
10407 return nativeResponseValue;
10409 // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
10411 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: bigint): void {
10412 if(!isWasmInitialized) {
10413 throw new Error("initializeWasm() must be awaited first!");
10415 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res);
10416 // debug statements here
10418 // struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ o);
10420 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(o: bigint): bigint {
10421 if(!isWasmInitialized) {
10422 throw new Error("initializeWasm() must be awaited first!");
10424 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(o);
10425 return nativeResponseValue;
10427 // struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none(void);
10429 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none(): bigint {
10430 if(!isWasmInitialized) {
10431 throw new Error("initializeWasm() must be awaited first!");
10433 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none();
10434 return nativeResponseValue;
10436 // void COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
10438 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: bigint): void {
10439 if(!isWasmInitialized) {
10440 throw new Error("initializeWasm() must be awaited first!");
10442 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res);
10443 // debug statements here
10445 // uint64_t COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *NONNULL_PTR arg);
10447 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(arg: bigint): bigint {
10448 if(!isWasmInitialized) {
10449 throw new Error("initializeWasm() must be awaited first!");
10451 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(arg);
10452 return nativeResponseValue;
10454 // struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(const struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *NONNULL_PTR orig);
10456 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(orig: bigint): bigint {
10457 if(!isWasmInitialized) {
10458 throw new Error("initializeWasm() must be awaited first!");
10460 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(orig);
10461 return nativeResponseValue;
10463 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
10465 export function CResult_NoneLightningErrorZ_ok(): bigint {
10466 if(!isWasmInitialized) {
10467 throw new Error("initializeWasm() must be awaited first!");
10469 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_ok();
10470 return nativeResponseValue;
10472 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
10474 export function CResult_NoneLightningErrorZ_err(e: bigint): bigint {
10475 if(!isWasmInitialized) {
10476 throw new Error("initializeWasm() must be awaited first!");
10478 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_err(e);
10479 return nativeResponseValue;
10481 // bool CResult_NoneLightningErrorZ_is_ok(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR o);
10483 export function CResult_NoneLightningErrorZ_is_ok(o: bigint): boolean {
10484 if(!isWasmInitialized) {
10485 throw new Error("initializeWasm() must be awaited first!");
10487 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_is_ok(o);
10488 return nativeResponseValue;
10490 // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
10492 export function CResult_NoneLightningErrorZ_free(_res: bigint): void {
10493 if(!isWasmInitialized) {
10494 throw new Error("initializeWasm() must be awaited first!");
10496 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_free(_res);
10497 // debug statements here
10499 // uint64_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg);
10501 export function CResult_NoneLightningErrorZ_clone_ptr(arg: bigint): bigint {
10502 if(!isWasmInitialized) {
10503 throw new Error("initializeWasm() must be awaited first!");
10505 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone_ptr(arg);
10506 return nativeResponseValue;
10508 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
10510 export function CResult_NoneLightningErrorZ_clone(orig: bigint): bigint {
10511 if(!isWasmInitialized) {
10512 throw new Error("initializeWasm() must be awaited first!");
10514 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone(orig);
10515 return nativeResponseValue;
10517 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_ok(struct LDKChannelUpdateInfo o);
10519 export function CResult_ChannelUpdateInfoDecodeErrorZ_ok(o: bigint): bigint {
10520 if(!isWasmInitialized) {
10521 throw new Error("initializeWasm() must be awaited first!");
10523 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok(o);
10524 return nativeResponseValue;
10526 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_err(struct LDKDecodeError e);
10528 export function CResult_ChannelUpdateInfoDecodeErrorZ_err(e: bigint): bigint {
10529 if(!isWasmInitialized) {
10530 throw new Error("initializeWasm() must be awaited first!");
10532 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_err(e);
10533 return nativeResponseValue;
10535 // bool CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR o);
10537 export function CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o: bigint): boolean {
10538 if(!isWasmInitialized) {
10539 throw new Error("initializeWasm() must be awaited first!");
10541 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o);
10542 return nativeResponseValue;
10544 // void CResult_ChannelUpdateInfoDecodeErrorZ_free(struct LDKCResult_ChannelUpdateInfoDecodeErrorZ _res);
10546 export function CResult_ChannelUpdateInfoDecodeErrorZ_free(_res: bigint): void {
10547 if(!isWasmInitialized) {
10548 throw new Error("initializeWasm() must be awaited first!");
10550 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_free(_res);
10551 // debug statements here
10553 // uint64_t CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR arg);
10555 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10556 if(!isWasmInitialized) {
10557 throw new Error("initializeWasm() must be awaited first!");
10559 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg);
10560 return nativeResponseValue;
10562 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR orig);
10564 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig: bigint): bigint {
10565 if(!isWasmInitialized) {
10566 throw new Error("initializeWasm() must be awaited first!");
10568 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig);
10569 return nativeResponseValue;
10571 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
10573 export function CResult_ChannelInfoDecodeErrorZ_ok(o: bigint): bigint {
10574 if(!isWasmInitialized) {
10575 throw new Error("initializeWasm() must be awaited first!");
10577 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_ok(o);
10578 return nativeResponseValue;
10580 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
10582 export function CResult_ChannelInfoDecodeErrorZ_err(e: bigint): bigint {
10583 if(!isWasmInitialized) {
10584 throw new Error("initializeWasm() must be awaited first!");
10586 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_err(e);
10587 return nativeResponseValue;
10589 // bool CResult_ChannelInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR o);
10591 export function CResult_ChannelInfoDecodeErrorZ_is_ok(o: bigint): boolean {
10592 if(!isWasmInitialized) {
10593 throw new Error("initializeWasm() must be awaited first!");
10595 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_is_ok(o);
10596 return nativeResponseValue;
10598 // void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
10600 export function CResult_ChannelInfoDecodeErrorZ_free(_res: bigint): void {
10601 if(!isWasmInitialized) {
10602 throw new Error("initializeWasm() must be awaited first!");
10604 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_free(_res);
10605 // debug statements here
10607 // uint64_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg);
10609 export function CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10610 if(!isWasmInitialized) {
10611 throw new Error("initializeWasm() must be awaited first!");
10613 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg);
10614 return nativeResponseValue;
10616 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
10618 export function CResult_ChannelInfoDecodeErrorZ_clone(orig: bigint): bigint {
10619 if(!isWasmInitialized) {
10620 throw new Error("initializeWasm() must be awaited first!");
10622 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone(orig);
10623 return nativeResponseValue;
10625 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
10627 export function CResult_RoutingFeesDecodeErrorZ_ok(o: bigint): bigint {
10628 if(!isWasmInitialized) {
10629 throw new Error("initializeWasm() must be awaited first!");
10631 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_ok(o);
10632 return nativeResponseValue;
10634 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
10636 export function CResult_RoutingFeesDecodeErrorZ_err(e: bigint): bigint {
10637 if(!isWasmInitialized) {
10638 throw new Error("initializeWasm() must be awaited first!");
10640 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_err(e);
10641 return nativeResponseValue;
10643 // bool CResult_RoutingFeesDecodeErrorZ_is_ok(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR o);
10645 export function CResult_RoutingFeesDecodeErrorZ_is_ok(o: bigint): boolean {
10646 if(!isWasmInitialized) {
10647 throw new Error("initializeWasm() must be awaited first!");
10649 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_is_ok(o);
10650 return nativeResponseValue;
10652 // void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
10654 export function CResult_RoutingFeesDecodeErrorZ_free(_res: bigint): void {
10655 if(!isWasmInitialized) {
10656 throw new Error("initializeWasm() must be awaited first!");
10658 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_free(_res);
10659 // debug statements here
10661 // uint64_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg);
10663 export function CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10664 if(!isWasmInitialized) {
10665 throw new Error("initializeWasm() must be awaited first!");
10667 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg);
10668 return nativeResponseValue;
10670 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
10672 export function CResult_RoutingFeesDecodeErrorZ_clone(orig: bigint): bigint {
10673 if(!isWasmInitialized) {
10674 throw new Error("initializeWasm() must be awaited first!");
10676 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone(orig);
10677 return nativeResponseValue;
10679 // void CVec_NetAddressZ_free(struct LDKCVec_NetAddressZ _res);
10681 export function CVec_NetAddressZ_free(_res: number): void {
10682 if(!isWasmInitialized) {
10683 throw new Error("initializeWasm() must be awaited first!");
10685 const nativeResponseValue = wasm.TS_CVec_NetAddressZ_free(_res);
10686 // debug statements here
10688 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
10690 export function CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o: bigint): bigint {
10691 if(!isWasmInitialized) {
10692 throw new Error("initializeWasm() must be awaited first!");
10694 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o);
10695 return nativeResponseValue;
10697 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
10699 export function CResult_NodeAnnouncementInfoDecodeErrorZ_err(e: bigint): bigint {
10700 if(!isWasmInitialized) {
10701 throw new Error("initializeWasm() must be awaited first!");
10703 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(e);
10704 return nativeResponseValue;
10706 // bool CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR o);
10708 export function CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o: bigint): boolean {
10709 if(!isWasmInitialized) {
10710 throw new Error("initializeWasm() must be awaited first!");
10712 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o);
10713 return nativeResponseValue;
10715 // void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
10717 export function CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res: bigint): void {
10718 if(!isWasmInitialized) {
10719 throw new Error("initializeWasm() must be awaited first!");
10721 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res);
10722 // debug statements here
10724 // uint64_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg);
10726 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10727 if(!isWasmInitialized) {
10728 throw new Error("initializeWasm() must be awaited first!");
10730 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg);
10731 return nativeResponseValue;
10733 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
10735 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: bigint): bigint {
10736 if(!isWasmInitialized) {
10737 throw new Error("initializeWasm() must be awaited first!");
10739 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig);
10740 return nativeResponseValue;
10742 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_ok(struct LDKNodeAlias o);
10744 export function CResult_NodeAliasDecodeErrorZ_ok(o: bigint): bigint {
10745 if(!isWasmInitialized) {
10746 throw new Error("initializeWasm() must be awaited first!");
10748 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_ok(o);
10749 return nativeResponseValue;
10751 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_err(struct LDKDecodeError e);
10753 export function CResult_NodeAliasDecodeErrorZ_err(e: bigint): bigint {
10754 if(!isWasmInitialized) {
10755 throw new Error("initializeWasm() must be awaited first!");
10757 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_err(e);
10758 return nativeResponseValue;
10760 // bool CResult_NodeAliasDecodeErrorZ_is_ok(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR o);
10762 export function CResult_NodeAliasDecodeErrorZ_is_ok(o: bigint): boolean {
10763 if(!isWasmInitialized) {
10764 throw new Error("initializeWasm() must be awaited first!");
10766 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_is_ok(o);
10767 return nativeResponseValue;
10769 // void CResult_NodeAliasDecodeErrorZ_free(struct LDKCResult_NodeAliasDecodeErrorZ _res);
10771 export function CResult_NodeAliasDecodeErrorZ_free(_res: bigint): void {
10772 if(!isWasmInitialized) {
10773 throw new Error("initializeWasm() must be awaited first!");
10775 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_free(_res);
10776 // debug statements here
10778 // uint64_t CResult_NodeAliasDecodeErrorZ_clone_ptr(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR arg);
10780 export function CResult_NodeAliasDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10781 if(!isWasmInitialized) {
10782 throw new Error("initializeWasm() must be awaited first!");
10784 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone_ptr(arg);
10785 return nativeResponseValue;
10787 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_clone(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR orig);
10789 export function CResult_NodeAliasDecodeErrorZ_clone(orig: bigint): bigint {
10790 if(!isWasmInitialized) {
10791 throw new Error("initializeWasm() must be awaited first!");
10793 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone(orig);
10794 return nativeResponseValue;
10796 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_ok(struct LDKNodeInfo o);
10798 export function CResult_NodeInfoDecodeErrorZ_ok(o: bigint): bigint {
10799 if(!isWasmInitialized) {
10800 throw new Error("initializeWasm() must be awaited first!");
10802 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_ok(o);
10803 return nativeResponseValue;
10805 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
10807 export function CResult_NodeInfoDecodeErrorZ_err(e: bigint): bigint {
10808 if(!isWasmInitialized) {
10809 throw new Error("initializeWasm() must be awaited first!");
10811 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_err(e);
10812 return nativeResponseValue;
10814 // bool CResult_NodeInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR o);
10816 export function CResult_NodeInfoDecodeErrorZ_is_ok(o: bigint): boolean {
10817 if(!isWasmInitialized) {
10818 throw new Error("initializeWasm() must be awaited first!");
10820 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_is_ok(o);
10821 return nativeResponseValue;
10823 // void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
10825 export function CResult_NodeInfoDecodeErrorZ_free(_res: bigint): void {
10826 if(!isWasmInitialized) {
10827 throw new Error("initializeWasm() must be awaited first!");
10829 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_free(_res);
10830 // debug statements here
10832 // uint64_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg);
10834 export function CResult_NodeInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10835 if(!isWasmInitialized) {
10836 throw new Error("initializeWasm() must be awaited first!");
10838 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(arg);
10839 return nativeResponseValue;
10841 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
10843 export function CResult_NodeInfoDecodeErrorZ_clone(orig: bigint): bigint {
10844 if(!isWasmInitialized) {
10845 throw new Error("initializeWasm() must be awaited first!");
10847 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone(orig);
10848 return nativeResponseValue;
10850 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
10852 export function CResult_NetworkGraphDecodeErrorZ_ok(o: bigint): bigint {
10853 if(!isWasmInitialized) {
10854 throw new Error("initializeWasm() must be awaited first!");
10856 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_ok(o);
10857 return nativeResponseValue;
10859 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
10861 export function CResult_NetworkGraphDecodeErrorZ_err(e: bigint): bigint {
10862 if(!isWasmInitialized) {
10863 throw new Error("initializeWasm() must be awaited first!");
10865 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_err(e);
10866 return nativeResponseValue;
10868 // bool CResult_NetworkGraphDecodeErrorZ_is_ok(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR o);
10870 export function CResult_NetworkGraphDecodeErrorZ_is_ok(o: bigint): boolean {
10871 if(!isWasmInitialized) {
10872 throw new Error("initializeWasm() must be awaited first!");
10874 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_is_ok(o);
10875 return nativeResponseValue;
10877 // void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
10879 export function CResult_NetworkGraphDecodeErrorZ_free(_res: bigint): void {
10880 if(!isWasmInitialized) {
10881 throw new Error("initializeWasm() must be awaited first!");
10883 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_free(_res);
10884 // debug statements here
10886 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_some(struct LDKCVec_NetAddressZ o);
10888 export function COption_CVec_NetAddressZZ_some(o: number): bigint {
10889 if(!isWasmInitialized) {
10890 throw new Error("initializeWasm() must be awaited first!");
10892 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_some(o);
10893 return nativeResponseValue;
10895 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_none(void);
10897 export function COption_CVec_NetAddressZZ_none(): bigint {
10898 if(!isWasmInitialized) {
10899 throw new Error("initializeWasm() must be awaited first!");
10901 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_none();
10902 return nativeResponseValue;
10904 // void COption_CVec_NetAddressZZ_free(struct LDKCOption_CVec_NetAddressZZ _res);
10906 export function COption_CVec_NetAddressZZ_free(_res: bigint): void {
10907 if(!isWasmInitialized) {
10908 throw new Error("initializeWasm() must be awaited first!");
10910 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_free(_res);
10911 // debug statements here
10913 // uint64_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg);
10915 export function COption_CVec_NetAddressZZ_clone_ptr(arg: bigint): bigint {
10916 if(!isWasmInitialized) {
10917 throw new Error("initializeWasm() must be awaited first!");
10919 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone_ptr(arg);
10920 return nativeResponseValue;
10922 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_clone(const struct LDKCOption_CVec_NetAddressZZ *NONNULL_PTR orig);
10924 export function COption_CVec_NetAddressZZ_clone(orig: bigint): bigint {
10925 if(!isWasmInitialized) {
10926 throw new Error("initializeWasm() must be awaited first!");
10928 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone(orig);
10929 return nativeResponseValue;
10931 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKDelayedPaymentOutputDescriptor o);
10933 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
10934 if(!isWasmInitialized) {
10935 throw new Error("initializeWasm() must be awaited first!");
10937 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o);
10938 return nativeResponseValue;
10940 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
10942 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
10943 if(!isWasmInitialized) {
10944 throw new Error("initializeWasm() must be awaited first!");
10946 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e);
10947 return nativeResponseValue;
10949 // bool CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
10951 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
10952 if(!isWasmInitialized) {
10953 throw new Error("initializeWasm() must be awaited first!");
10955 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
10956 return nativeResponseValue;
10958 // void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res);
10960 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
10961 if(!isWasmInitialized) {
10962 throw new Error("initializeWasm() must be awaited first!");
10964 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res);
10965 // debug statements here
10967 // uint64_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
10969 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10970 if(!isWasmInitialized) {
10971 throw new Error("initializeWasm() must be awaited first!");
10973 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
10974 return nativeResponseValue;
10976 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
10978 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
10979 if(!isWasmInitialized) {
10980 throw new Error("initializeWasm() must be awaited first!");
10982 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig);
10983 return nativeResponseValue;
10985 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKStaticPaymentOutputDescriptor o);
10987 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
10988 if(!isWasmInitialized) {
10989 throw new Error("initializeWasm() must be awaited first!");
10991 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o);
10992 return nativeResponseValue;
10994 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
10996 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
10997 if(!isWasmInitialized) {
10998 throw new Error("initializeWasm() must be awaited first!");
11000 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e);
11001 return nativeResponseValue;
11003 // bool CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
11005 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
11006 if(!isWasmInitialized) {
11007 throw new Error("initializeWasm() must be awaited first!");
11009 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
11010 return nativeResponseValue;
11012 // void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res);
11014 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
11015 if(!isWasmInitialized) {
11016 throw new Error("initializeWasm() must be awaited first!");
11018 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res);
11019 // debug statements here
11021 // uint64_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
11023 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11024 if(!isWasmInitialized) {
11025 throw new Error("initializeWasm() must be awaited first!");
11027 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
11028 return nativeResponseValue;
11030 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
11032 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
11033 if(!isWasmInitialized) {
11034 throw new Error("initializeWasm() must be awaited first!");
11036 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig);
11037 return nativeResponseValue;
11039 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
11041 export function CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
11042 if(!isWasmInitialized) {
11043 throw new Error("initializeWasm() must be awaited first!");
11045 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o);
11046 return nativeResponseValue;
11048 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
11050 export function CResult_SpendableOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
11051 if(!isWasmInitialized) {
11052 throw new Error("initializeWasm() must be awaited first!");
11054 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(e);
11055 return nativeResponseValue;
11057 // bool CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
11059 export function CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
11060 if(!isWasmInitialized) {
11061 throw new Error("initializeWasm() must be awaited first!");
11063 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o);
11064 return nativeResponseValue;
11066 // void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
11068 export function CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
11069 if(!isWasmInitialized) {
11070 throw new Error("initializeWasm() must be awaited first!");
11072 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res);
11073 // debug statements here
11075 // uint64_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
11077 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11078 if(!isWasmInitialized) {
11079 throw new Error("initializeWasm() must be awaited first!");
11081 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg);
11082 return nativeResponseValue;
11084 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
11086 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
11087 if(!isWasmInitialized) {
11088 throw new Error("initializeWasm() must be awaited first!");
11090 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig);
11091 return nativeResponseValue;
11093 // void CVec_PaymentPreimageZ_free(struct LDKCVec_PaymentPreimageZ _res);
11095 export function CVec_PaymentPreimageZ_free(_res: number): void {
11096 if(!isWasmInitialized) {
11097 throw new Error("initializeWasm() must be awaited first!");
11099 const nativeResponseValue = wasm.TS_CVec_PaymentPreimageZ_free(_res);
11100 // debug statements here
11102 // uint64_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg);
11104 export function C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg: bigint): bigint {
11105 if(!isWasmInitialized) {
11106 throw new Error("initializeWasm() must be awaited first!");
11108 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg);
11109 return nativeResponseValue;
11111 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_clone(const struct LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR orig);
11113 export function C2Tuple_SignatureCVec_SignatureZZ_clone(orig: bigint): bigint {
11114 if(!isWasmInitialized) {
11115 throw new Error("initializeWasm() must be awaited first!");
11117 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone(orig);
11118 return nativeResponseValue;
11120 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_new(struct LDKSignature a, struct LDKCVec_SignatureZ b);
11122 export function C2Tuple_SignatureCVec_SignatureZZ_new(a: number, b: number): bigint {
11123 if(!isWasmInitialized) {
11124 throw new Error("initializeWasm() must be awaited first!");
11126 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_new(a, b);
11127 return nativeResponseValue;
11129 // void C2Tuple_SignatureCVec_SignatureZZ_free(struct LDKC2Tuple_SignatureCVec_SignatureZZ _res);
11131 export function C2Tuple_SignatureCVec_SignatureZZ_free(_res: bigint): void {
11132 if(!isWasmInitialized) {
11133 throw new Error("initializeWasm() must be awaited first!");
11135 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_free(_res);
11136 // debug statements here
11138 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(struct LDKC2Tuple_SignatureCVec_SignatureZZ o);
11140 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o: bigint): bigint {
11141 if(!isWasmInitialized) {
11142 throw new Error("initializeWasm() must be awaited first!");
11144 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o);
11145 return nativeResponseValue;
11147 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(void);
11149 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(): bigint {
11150 if(!isWasmInitialized) {
11151 throw new Error("initializeWasm() must be awaited first!");
11153 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
11154 return nativeResponseValue;
11156 // bool CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR o);
11158 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o: bigint): boolean {
11159 if(!isWasmInitialized) {
11160 throw new Error("initializeWasm() must be awaited first!");
11162 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o);
11163 return nativeResponseValue;
11165 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res);
11167 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res: bigint): void {
11168 if(!isWasmInitialized) {
11169 throw new Error("initializeWasm() must be awaited first!");
11171 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res);
11172 // debug statements here
11174 // uint64_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg);
11176 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg: bigint): bigint {
11177 if(!isWasmInitialized) {
11178 throw new Error("initializeWasm() must be awaited first!");
11180 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg);
11181 return nativeResponseValue;
11183 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR orig);
11185 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig: bigint): bigint {
11186 if(!isWasmInitialized) {
11187 throw new Error("initializeWasm() must be awaited first!");
11189 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig);
11190 return nativeResponseValue;
11192 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_ok(struct LDKSignature o);
11194 export function CResult_SignatureNoneZ_ok(o: number): bigint {
11195 if(!isWasmInitialized) {
11196 throw new Error("initializeWasm() must be awaited first!");
11198 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_ok(o);
11199 return nativeResponseValue;
11201 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_err(void);
11203 export function CResult_SignatureNoneZ_err(): bigint {
11204 if(!isWasmInitialized) {
11205 throw new Error("initializeWasm() must be awaited first!");
11207 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_err();
11208 return nativeResponseValue;
11210 // bool CResult_SignatureNoneZ_is_ok(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR o);
11212 export function CResult_SignatureNoneZ_is_ok(o: bigint): boolean {
11213 if(!isWasmInitialized) {
11214 throw new Error("initializeWasm() must be awaited first!");
11216 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_is_ok(o);
11217 return nativeResponseValue;
11219 // void CResult_SignatureNoneZ_free(struct LDKCResult_SignatureNoneZ _res);
11221 export function CResult_SignatureNoneZ_free(_res: bigint): void {
11222 if(!isWasmInitialized) {
11223 throw new Error("initializeWasm() must be awaited first!");
11225 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_free(_res);
11226 // debug statements here
11228 // uint64_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg);
11230 export function CResult_SignatureNoneZ_clone_ptr(arg: bigint): bigint {
11231 if(!isWasmInitialized) {
11232 throw new Error("initializeWasm() must be awaited first!");
11234 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone_ptr(arg);
11235 return nativeResponseValue;
11237 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_clone(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR orig);
11239 export function CResult_SignatureNoneZ_clone(orig: bigint): bigint {
11240 if(!isWasmInitialized) {
11241 throw new Error("initializeWasm() must be awaited first!");
11243 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone(orig);
11244 return nativeResponseValue;
11246 // uint64_t C2Tuple_SignatureSignatureZ_clone_ptr(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR arg);
11248 export function C2Tuple_SignatureSignatureZ_clone_ptr(arg: bigint): bigint {
11249 if(!isWasmInitialized) {
11250 throw new Error("initializeWasm() must be awaited first!");
11252 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_clone_ptr(arg);
11253 return nativeResponseValue;
11255 // struct LDKC2Tuple_SignatureSignatureZ C2Tuple_SignatureSignatureZ_clone(const struct LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR orig);
11257 export function C2Tuple_SignatureSignatureZ_clone(orig: bigint): bigint {
11258 if(!isWasmInitialized) {
11259 throw new Error("initializeWasm() must be awaited first!");
11261 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_clone(orig);
11262 return nativeResponseValue;
11264 // struct LDKC2Tuple_SignatureSignatureZ C2Tuple_SignatureSignatureZ_new(struct LDKSignature a, struct LDKSignature b);
11266 export function C2Tuple_SignatureSignatureZ_new(a: number, b: number): bigint {
11267 if(!isWasmInitialized) {
11268 throw new Error("initializeWasm() must be awaited first!");
11270 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_new(a, b);
11271 return nativeResponseValue;
11273 // void C2Tuple_SignatureSignatureZ_free(struct LDKC2Tuple_SignatureSignatureZ _res);
11275 export function C2Tuple_SignatureSignatureZ_free(_res: bigint): void {
11276 if(!isWasmInitialized) {
11277 throw new Error("initializeWasm() must be awaited first!");
11279 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_free(_res);
11280 // debug statements here
11282 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_ok(struct LDKC2Tuple_SignatureSignatureZ o);
11284 export function CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o: bigint): bigint {
11285 if(!isWasmInitialized) {
11286 throw new Error("initializeWasm() must be awaited first!");
11288 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o);
11289 return nativeResponseValue;
11291 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_err(void);
11293 export function CResult_C2Tuple_SignatureSignatureZNoneZ_err(): bigint {
11294 if(!isWasmInitialized) {
11295 throw new Error("initializeWasm() must be awaited first!");
11297 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_err();
11298 return nativeResponseValue;
11300 // bool CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR o);
11302 export function CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o: bigint): boolean {
11303 if(!isWasmInitialized) {
11304 throw new Error("initializeWasm() must be awaited first!");
11306 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o);
11307 return nativeResponseValue;
11309 // void CResult_C2Tuple_SignatureSignatureZNoneZ_free(struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ _res);
11311 export function CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res: bigint): void {
11312 if(!isWasmInitialized) {
11313 throw new Error("initializeWasm() must be awaited first!");
11315 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res);
11316 // debug statements here
11318 // uint64_t CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR arg);
11320 export function CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg: bigint): bigint {
11321 if(!isWasmInitialized) {
11322 throw new Error("initializeWasm() must be awaited first!");
11324 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg);
11325 return nativeResponseValue;
11327 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR orig);
11329 export function CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig: bigint): bigint {
11330 if(!isWasmInitialized) {
11331 throw new Error("initializeWasm() must be awaited first!");
11333 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig);
11334 return nativeResponseValue;
11336 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_ok(struct LDKSecretKey o);
11338 export function CResult_SecretKeyNoneZ_ok(o: number): bigint {
11339 if(!isWasmInitialized) {
11340 throw new Error("initializeWasm() must be awaited first!");
11342 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_ok(o);
11343 return nativeResponseValue;
11345 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_err(void);
11347 export function CResult_SecretKeyNoneZ_err(): bigint {
11348 if(!isWasmInitialized) {
11349 throw new Error("initializeWasm() must be awaited first!");
11351 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_err();
11352 return nativeResponseValue;
11354 // bool CResult_SecretKeyNoneZ_is_ok(const struct LDKCResult_SecretKeyNoneZ *NONNULL_PTR o);
11356 export function CResult_SecretKeyNoneZ_is_ok(o: bigint): boolean {
11357 if(!isWasmInitialized) {
11358 throw new Error("initializeWasm() must be awaited first!");
11360 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_is_ok(o);
11361 return nativeResponseValue;
11363 // void CResult_SecretKeyNoneZ_free(struct LDKCResult_SecretKeyNoneZ _res);
11365 export function CResult_SecretKeyNoneZ_free(_res: bigint): void {
11366 if(!isWasmInitialized) {
11367 throw new Error("initializeWasm() must be awaited first!");
11369 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_free(_res);
11370 // debug statements here
11372 // uint64_t CResult_SecretKeyNoneZ_clone_ptr(LDKCResult_SecretKeyNoneZ *NONNULL_PTR arg);
11374 export function CResult_SecretKeyNoneZ_clone_ptr(arg: bigint): bigint {
11375 if(!isWasmInitialized) {
11376 throw new Error("initializeWasm() must be awaited first!");
11378 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_clone_ptr(arg);
11379 return nativeResponseValue;
11381 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_clone(const struct LDKCResult_SecretKeyNoneZ *NONNULL_PTR orig);
11383 export function CResult_SecretKeyNoneZ_clone(orig: bigint): bigint {
11384 if(!isWasmInitialized) {
11385 throw new Error("initializeWasm() must be awaited first!");
11387 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_clone(orig);
11388 return nativeResponseValue;
11390 // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_ok(struct LDKPublicKey o);
11392 export function CResult_PublicKeyNoneZ_ok(o: number): bigint {
11393 if(!isWasmInitialized) {
11394 throw new Error("initializeWasm() must be awaited first!");
11396 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_ok(o);
11397 return nativeResponseValue;
11399 // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_err(void);
11401 export function CResult_PublicKeyNoneZ_err(): bigint {
11402 if(!isWasmInitialized) {
11403 throw new Error("initializeWasm() must be awaited first!");
11405 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_err();
11406 return nativeResponseValue;
11408 // bool CResult_PublicKeyNoneZ_is_ok(const struct LDKCResult_PublicKeyNoneZ *NONNULL_PTR o);
11410 export function CResult_PublicKeyNoneZ_is_ok(o: bigint): boolean {
11411 if(!isWasmInitialized) {
11412 throw new Error("initializeWasm() must be awaited first!");
11414 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_is_ok(o);
11415 return nativeResponseValue;
11417 // void CResult_PublicKeyNoneZ_free(struct LDKCResult_PublicKeyNoneZ _res);
11419 export function CResult_PublicKeyNoneZ_free(_res: bigint): void {
11420 if(!isWasmInitialized) {
11421 throw new Error("initializeWasm() must be awaited first!");
11423 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_free(_res);
11424 // debug statements here
11426 // uint64_t CResult_PublicKeyNoneZ_clone_ptr(LDKCResult_PublicKeyNoneZ *NONNULL_PTR arg);
11428 export function CResult_PublicKeyNoneZ_clone_ptr(arg: bigint): bigint {
11429 if(!isWasmInitialized) {
11430 throw new Error("initializeWasm() must be awaited first!");
11432 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_clone_ptr(arg);
11433 return nativeResponseValue;
11435 // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_clone(const struct LDKCResult_PublicKeyNoneZ *NONNULL_PTR orig);
11437 export function CResult_PublicKeyNoneZ_clone(orig: bigint): bigint {
11438 if(!isWasmInitialized) {
11439 throw new Error("initializeWasm() must be awaited first!");
11441 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_clone(orig);
11442 return nativeResponseValue;
11444 // struct LDKCOption_ScalarZ COption_ScalarZ_some(struct LDKBigEndianScalar o);
11446 export function COption_ScalarZ_some(o: bigint): bigint {
11447 if(!isWasmInitialized) {
11448 throw new Error("initializeWasm() must be awaited first!");
11450 const nativeResponseValue = wasm.TS_COption_ScalarZ_some(o);
11451 return nativeResponseValue;
11453 // struct LDKCOption_ScalarZ COption_ScalarZ_none(void);
11455 export function COption_ScalarZ_none(): bigint {
11456 if(!isWasmInitialized) {
11457 throw new Error("initializeWasm() must be awaited first!");
11459 const nativeResponseValue = wasm.TS_COption_ScalarZ_none();
11460 return nativeResponseValue;
11462 // void COption_ScalarZ_free(struct LDKCOption_ScalarZ _res);
11464 export function COption_ScalarZ_free(_res: bigint): void {
11465 if(!isWasmInitialized) {
11466 throw new Error("initializeWasm() must be awaited first!");
11468 const nativeResponseValue = wasm.TS_COption_ScalarZ_free(_res);
11469 // debug statements here
11471 // struct LDKCResult_SharedSecretNoneZ CResult_SharedSecretNoneZ_ok(struct LDKThirtyTwoBytes o);
11473 export function CResult_SharedSecretNoneZ_ok(o: number): bigint {
11474 if(!isWasmInitialized) {
11475 throw new Error("initializeWasm() must be awaited first!");
11477 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_ok(o);
11478 return nativeResponseValue;
11480 // struct LDKCResult_SharedSecretNoneZ CResult_SharedSecretNoneZ_err(void);
11482 export function CResult_SharedSecretNoneZ_err(): bigint {
11483 if(!isWasmInitialized) {
11484 throw new Error("initializeWasm() must be awaited first!");
11486 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_err();
11487 return nativeResponseValue;
11489 // bool CResult_SharedSecretNoneZ_is_ok(const struct LDKCResult_SharedSecretNoneZ *NONNULL_PTR o);
11491 export function CResult_SharedSecretNoneZ_is_ok(o: bigint): boolean {
11492 if(!isWasmInitialized) {
11493 throw new Error("initializeWasm() must be awaited first!");
11495 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_is_ok(o);
11496 return nativeResponseValue;
11498 // void CResult_SharedSecretNoneZ_free(struct LDKCResult_SharedSecretNoneZ _res);
11500 export function CResult_SharedSecretNoneZ_free(_res: bigint): void {
11501 if(!isWasmInitialized) {
11502 throw new Error("initializeWasm() must be awaited first!");
11504 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_free(_res);
11505 // debug statements here
11507 // uint64_t CResult_SharedSecretNoneZ_clone_ptr(LDKCResult_SharedSecretNoneZ *NONNULL_PTR arg);
11509 export function CResult_SharedSecretNoneZ_clone_ptr(arg: bigint): bigint {
11510 if(!isWasmInitialized) {
11511 throw new Error("initializeWasm() must be awaited first!");
11513 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_clone_ptr(arg);
11514 return nativeResponseValue;
11516 // struct LDKCResult_SharedSecretNoneZ CResult_SharedSecretNoneZ_clone(const struct LDKCResult_SharedSecretNoneZ *NONNULL_PTR orig);
11518 export function CResult_SharedSecretNoneZ_clone(orig: bigint): bigint {
11519 if(!isWasmInitialized) {
11520 throw new Error("initializeWasm() must be awaited first!");
11522 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_clone(orig);
11523 return nativeResponseValue;
11525 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_ok(struct LDKSign o);
11527 export function CResult_SignDecodeErrorZ_ok(o: bigint): bigint {
11528 if(!isWasmInitialized) {
11529 throw new Error("initializeWasm() must be awaited first!");
11531 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_ok(o);
11532 return nativeResponseValue;
11534 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_err(struct LDKDecodeError e);
11536 export function CResult_SignDecodeErrorZ_err(e: bigint): bigint {
11537 if(!isWasmInitialized) {
11538 throw new Error("initializeWasm() must be awaited first!");
11540 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_err(e);
11541 return nativeResponseValue;
11543 // bool CResult_SignDecodeErrorZ_is_ok(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR o);
11545 export function CResult_SignDecodeErrorZ_is_ok(o: bigint): boolean {
11546 if(!isWasmInitialized) {
11547 throw new Error("initializeWasm() must be awaited first!");
11549 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_is_ok(o);
11550 return nativeResponseValue;
11552 // void CResult_SignDecodeErrorZ_free(struct LDKCResult_SignDecodeErrorZ _res);
11554 export function CResult_SignDecodeErrorZ_free(_res: bigint): void {
11555 if(!isWasmInitialized) {
11556 throw new Error("initializeWasm() must be awaited first!");
11558 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_free(_res);
11559 // debug statements here
11561 // uint64_t CResult_SignDecodeErrorZ_clone_ptr(LDKCResult_SignDecodeErrorZ *NONNULL_PTR arg);
11563 export function CResult_SignDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11564 if(!isWasmInitialized) {
11565 throw new Error("initializeWasm() must be awaited first!");
11567 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone_ptr(arg);
11568 return nativeResponseValue;
11570 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_clone(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR orig);
11572 export function CResult_SignDecodeErrorZ_clone(orig: bigint): bigint {
11573 if(!isWasmInitialized) {
11574 throw new Error("initializeWasm() must be awaited first!");
11576 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone(orig);
11577 return nativeResponseValue;
11579 // void CVec_u5Z_free(struct LDKCVec_u5Z _res);
11581 export function CVec_u5Z_free(_res: number): void {
11582 if(!isWasmInitialized) {
11583 throw new Error("initializeWasm() must be awaited first!");
11585 const nativeResponseValue = wasm.TS_CVec_u5Z_free(_res);
11586 // debug statements here
11588 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_ok(struct LDKRecoverableSignature o);
11590 export function CResult_RecoverableSignatureNoneZ_ok(o: number): bigint {
11591 if(!isWasmInitialized) {
11592 throw new Error("initializeWasm() must be awaited first!");
11594 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_ok(o);
11595 return nativeResponseValue;
11597 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_err(void);
11599 export function CResult_RecoverableSignatureNoneZ_err(): bigint {
11600 if(!isWasmInitialized) {
11601 throw new Error("initializeWasm() must be awaited first!");
11603 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_err();
11604 return nativeResponseValue;
11606 // bool CResult_RecoverableSignatureNoneZ_is_ok(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR o);
11608 export function CResult_RecoverableSignatureNoneZ_is_ok(o: bigint): boolean {
11609 if(!isWasmInitialized) {
11610 throw new Error("initializeWasm() must be awaited first!");
11612 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_is_ok(o);
11613 return nativeResponseValue;
11615 // void CResult_RecoverableSignatureNoneZ_free(struct LDKCResult_RecoverableSignatureNoneZ _res);
11617 export function CResult_RecoverableSignatureNoneZ_free(_res: bigint): void {
11618 if(!isWasmInitialized) {
11619 throw new Error("initializeWasm() must be awaited first!");
11621 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_free(_res);
11622 // debug statements here
11624 // uint64_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg);
11626 export function CResult_RecoverableSignatureNoneZ_clone_ptr(arg: bigint): bigint {
11627 if(!isWasmInitialized) {
11628 throw new Error("initializeWasm() must be awaited first!");
11630 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone_ptr(arg);
11631 return nativeResponseValue;
11633 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_clone(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR orig);
11635 export function CResult_RecoverableSignatureNoneZ_clone(orig: bigint): bigint {
11636 if(!isWasmInitialized) {
11637 throw new Error("initializeWasm() must be awaited first!");
11639 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone(orig);
11640 return nativeResponseValue;
11642 // void CVec_u8Z_free(struct LDKCVec_u8Z _res);
11644 export function CVec_u8Z_free(_res: number): void {
11645 if(!isWasmInitialized) {
11646 throw new Error("initializeWasm() must be awaited first!");
11648 const nativeResponseValue = wasm.TS_CVec_u8Z_free(_res);
11649 // debug statements here
11651 // void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
11653 export function CVec_CVec_u8ZZ_free(_res: number): void {
11654 if(!isWasmInitialized) {
11655 throw new Error("initializeWasm() must be awaited first!");
11657 const nativeResponseValue = wasm.TS_CVec_CVec_u8ZZ_free(_res);
11658 // debug statements here
11660 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_ok(struct LDKCVec_CVec_u8ZZ o);
11662 export function CResult_CVec_CVec_u8ZZNoneZ_ok(o: number): bigint {
11663 if(!isWasmInitialized) {
11664 throw new Error("initializeWasm() must be awaited first!");
11666 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_ok(o);
11667 return nativeResponseValue;
11669 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
11671 export function CResult_CVec_CVec_u8ZZNoneZ_err(): bigint {
11672 if(!isWasmInitialized) {
11673 throw new Error("initializeWasm() must be awaited first!");
11675 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_err();
11676 return nativeResponseValue;
11678 // bool CResult_CVec_CVec_u8ZZNoneZ_is_ok(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR o);
11680 export function CResult_CVec_CVec_u8ZZNoneZ_is_ok(o: bigint): boolean {
11681 if(!isWasmInitialized) {
11682 throw new Error("initializeWasm() must be awaited first!");
11684 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(o);
11685 return nativeResponseValue;
11687 // void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
11689 export function CResult_CVec_CVec_u8ZZNoneZ_free(_res: bigint): void {
11690 if(!isWasmInitialized) {
11691 throw new Error("initializeWasm() must be awaited first!");
11693 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_free(_res);
11694 // debug statements here
11696 // uint64_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg);
11698 export function CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg: bigint): bigint {
11699 if(!isWasmInitialized) {
11700 throw new Error("initializeWasm() must be awaited first!");
11702 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg);
11703 return nativeResponseValue;
11705 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
11707 export function CResult_CVec_CVec_u8ZZNoneZ_clone(orig: bigint): bigint {
11708 if(!isWasmInitialized) {
11709 throw new Error("initializeWasm() must be awaited first!");
11711 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone(orig);
11712 return nativeResponseValue;
11714 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
11716 export function CResult_InMemorySignerDecodeErrorZ_ok(o: bigint): bigint {
11717 if(!isWasmInitialized) {
11718 throw new Error("initializeWasm() must be awaited first!");
11720 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_ok(o);
11721 return nativeResponseValue;
11723 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
11725 export function CResult_InMemorySignerDecodeErrorZ_err(e: bigint): bigint {
11726 if(!isWasmInitialized) {
11727 throw new Error("initializeWasm() must be awaited first!");
11729 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_err(e);
11730 return nativeResponseValue;
11732 // bool CResult_InMemorySignerDecodeErrorZ_is_ok(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR o);
11734 export function CResult_InMemorySignerDecodeErrorZ_is_ok(o: bigint): boolean {
11735 if(!isWasmInitialized) {
11736 throw new Error("initializeWasm() must be awaited first!");
11738 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_is_ok(o);
11739 return nativeResponseValue;
11741 // void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
11743 export function CResult_InMemorySignerDecodeErrorZ_free(_res: bigint): void {
11744 if(!isWasmInitialized) {
11745 throw new Error("initializeWasm() must be awaited first!");
11747 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_free(_res);
11748 // debug statements here
11750 // uint64_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg);
11752 export function CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11753 if(!isWasmInitialized) {
11754 throw new Error("initializeWasm() must be awaited first!");
11756 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg);
11757 return nativeResponseValue;
11759 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
11761 export function CResult_InMemorySignerDecodeErrorZ_clone(orig: bigint): bigint {
11762 if(!isWasmInitialized) {
11763 throw new Error("initializeWasm() must be awaited first!");
11765 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone(orig);
11766 return nativeResponseValue;
11768 // void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
11770 export function CVec_TxOutZ_free(_res: number): void {
11771 if(!isWasmInitialized) {
11772 throw new Error("initializeWasm() must be awaited first!");
11774 const nativeResponseValue = wasm.TS_CVec_TxOutZ_free(_res);
11775 // debug statements here
11777 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
11779 export function CResult_TransactionNoneZ_ok(o: number): bigint {
11780 if(!isWasmInitialized) {
11781 throw new Error("initializeWasm() must be awaited first!");
11783 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_ok(o);
11784 return nativeResponseValue;
11786 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
11788 export function CResult_TransactionNoneZ_err(): bigint {
11789 if(!isWasmInitialized) {
11790 throw new Error("initializeWasm() must be awaited first!");
11792 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_err();
11793 return nativeResponseValue;
11795 // bool CResult_TransactionNoneZ_is_ok(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR o);
11797 export function CResult_TransactionNoneZ_is_ok(o: bigint): boolean {
11798 if(!isWasmInitialized) {
11799 throw new Error("initializeWasm() must be awaited first!");
11801 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_is_ok(o);
11802 return nativeResponseValue;
11804 // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
11806 export function CResult_TransactionNoneZ_free(_res: bigint): void {
11807 if(!isWasmInitialized) {
11808 throw new Error("initializeWasm() must be awaited first!");
11810 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_free(_res);
11811 // debug statements here
11813 // uint64_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg);
11815 export function CResult_TransactionNoneZ_clone_ptr(arg: bigint): bigint {
11816 if(!isWasmInitialized) {
11817 throw new Error("initializeWasm() must be awaited first!");
11819 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone_ptr(arg);
11820 return nativeResponseValue;
11822 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_clone(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR orig);
11824 export function CResult_TransactionNoneZ_clone(orig: bigint): bigint {
11825 if(!isWasmInitialized) {
11826 throw new Error("initializeWasm() must be awaited first!");
11828 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone(orig);
11829 return nativeResponseValue;
11831 // struct LDKCOption_u16Z COption_u16Z_some(uint16_t o);
11833 export function COption_u16Z_some(o: number): bigint {
11834 if(!isWasmInitialized) {
11835 throw new Error("initializeWasm() must be awaited first!");
11837 const nativeResponseValue = wasm.TS_COption_u16Z_some(o);
11838 return nativeResponseValue;
11840 // struct LDKCOption_u16Z COption_u16Z_none(void);
11842 export function COption_u16Z_none(): bigint {
11843 if(!isWasmInitialized) {
11844 throw new Error("initializeWasm() must be awaited first!");
11846 const nativeResponseValue = wasm.TS_COption_u16Z_none();
11847 return nativeResponseValue;
11849 // void COption_u16Z_free(struct LDKCOption_u16Z _res);
11851 export function COption_u16Z_free(_res: bigint): void {
11852 if(!isWasmInitialized) {
11853 throw new Error("initializeWasm() must be awaited first!");
11855 const nativeResponseValue = wasm.TS_COption_u16Z_free(_res);
11856 // debug statements here
11858 // uint64_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg);
11860 export function COption_u16Z_clone_ptr(arg: bigint): bigint {
11861 if(!isWasmInitialized) {
11862 throw new Error("initializeWasm() must be awaited first!");
11864 const nativeResponseValue = wasm.TS_COption_u16Z_clone_ptr(arg);
11865 return nativeResponseValue;
11867 // struct LDKCOption_u16Z COption_u16Z_clone(const struct LDKCOption_u16Z *NONNULL_PTR orig);
11869 export function COption_u16Z_clone(orig: bigint): bigint {
11870 if(!isWasmInitialized) {
11871 throw new Error("initializeWasm() must be awaited first!");
11873 const nativeResponseValue = wasm.TS_COption_u16Z_clone(orig);
11874 return nativeResponseValue;
11876 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
11878 export function CResult_NoneAPIErrorZ_ok(): bigint {
11879 if(!isWasmInitialized) {
11880 throw new Error("initializeWasm() must be awaited first!");
11882 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_ok();
11883 return nativeResponseValue;
11885 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
11887 export function CResult_NoneAPIErrorZ_err(e: bigint): bigint {
11888 if(!isWasmInitialized) {
11889 throw new Error("initializeWasm() must be awaited first!");
11891 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_err(e);
11892 return nativeResponseValue;
11894 // bool CResult_NoneAPIErrorZ_is_ok(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR o);
11896 export function CResult_NoneAPIErrorZ_is_ok(o: bigint): boolean {
11897 if(!isWasmInitialized) {
11898 throw new Error("initializeWasm() must be awaited first!");
11900 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_is_ok(o);
11901 return nativeResponseValue;
11903 // void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
11905 export function CResult_NoneAPIErrorZ_free(_res: bigint): void {
11906 if(!isWasmInitialized) {
11907 throw new Error("initializeWasm() must be awaited first!");
11909 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_free(_res);
11910 // debug statements here
11912 // uint64_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg);
11914 export function CResult_NoneAPIErrorZ_clone_ptr(arg: bigint): bigint {
11915 if(!isWasmInitialized) {
11916 throw new Error("initializeWasm() must be awaited first!");
11918 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone_ptr(arg);
11919 return nativeResponseValue;
11921 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
11923 export function CResult_NoneAPIErrorZ_clone(orig: bigint): bigint {
11924 if(!isWasmInitialized) {
11925 throw new Error("initializeWasm() must be awaited first!");
11927 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone(orig);
11928 return nativeResponseValue;
11930 // void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
11932 export function CVec_CResult_NoneAPIErrorZZ_free(_res: number): void {
11933 if(!isWasmInitialized) {
11934 throw new Error("initializeWasm() must be awaited first!");
11936 const nativeResponseValue = wasm.TS_CVec_CResult_NoneAPIErrorZZ_free(_res);
11937 // debug statements here
11939 // void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
11941 export function CVec_APIErrorZ_free(_res: number): void {
11942 if(!isWasmInitialized) {
11943 throw new Error("initializeWasm() must be awaited first!");
11945 const nativeResponseValue = wasm.TS_CVec_APIErrorZ_free(_res);
11946 // debug statements here
11948 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_ok(struct LDKThirtyTwoBytes o);
11950 export function CResult__u832APIErrorZ_ok(o: number): bigint {
11951 if(!isWasmInitialized) {
11952 throw new Error("initializeWasm() must be awaited first!");
11954 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_ok(o);
11955 return nativeResponseValue;
11957 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_err(struct LDKAPIError e);
11959 export function CResult__u832APIErrorZ_err(e: bigint): bigint {
11960 if(!isWasmInitialized) {
11961 throw new Error("initializeWasm() must be awaited first!");
11963 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_err(e);
11964 return nativeResponseValue;
11966 // bool CResult__u832APIErrorZ_is_ok(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR o);
11968 export function CResult__u832APIErrorZ_is_ok(o: bigint): boolean {
11969 if(!isWasmInitialized) {
11970 throw new Error("initializeWasm() must be awaited first!");
11972 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_is_ok(o);
11973 return nativeResponseValue;
11975 // void CResult__u832APIErrorZ_free(struct LDKCResult__u832APIErrorZ _res);
11977 export function CResult__u832APIErrorZ_free(_res: bigint): void {
11978 if(!isWasmInitialized) {
11979 throw new Error("initializeWasm() must be awaited first!");
11981 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_free(_res);
11982 // debug statements here
11984 // uint64_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg);
11986 export function CResult__u832APIErrorZ_clone_ptr(arg: bigint): bigint {
11987 if(!isWasmInitialized) {
11988 throw new Error("initializeWasm() must be awaited first!");
11990 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone_ptr(arg);
11991 return nativeResponseValue;
11993 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_clone(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR orig);
11995 export function CResult__u832APIErrorZ_clone(orig: bigint): bigint {
11996 if(!isWasmInitialized) {
11997 throw new Error("initializeWasm() must be awaited first!");
11999 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone(orig);
12000 return nativeResponseValue;
12002 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_ok(struct LDKThirtyTwoBytes o);
12004 export function CResult_PaymentIdPaymentSendFailureZ_ok(o: number): bigint {
12005 if(!isWasmInitialized) {
12006 throw new Error("initializeWasm() must be awaited first!");
12008 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_ok(o);
12009 return nativeResponseValue;
12011 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
12013 export function CResult_PaymentIdPaymentSendFailureZ_err(e: bigint): bigint {
12014 if(!isWasmInitialized) {
12015 throw new Error("initializeWasm() must be awaited first!");
12017 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_err(e);
12018 return nativeResponseValue;
12020 // bool CResult_PaymentIdPaymentSendFailureZ_is_ok(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR o);
12022 export function CResult_PaymentIdPaymentSendFailureZ_is_ok(o: bigint): boolean {
12023 if(!isWasmInitialized) {
12024 throw new Error("initializeWasm() must be awaited first!");
12026 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_is_ok(o);
12027 return nativeResponseValue;
12029 // void CResult_PaymentIdPaymentSendFailureZ_free(struct LDKCResult_PaymentIdPaymentSendFailureZ _res);
12031 export function CResult_PaymentIdPaymentSendFailureZ_free(_res: bigint): void {
12032 if(!isWasmInitialized) {
12033 throw new Error("initializeWasm() must be awaited first!");
12035 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_free(_res);
12036 // debug statements here
12038 // uint64_t CResult_PaymentIdPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR arg);
12040 export function CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
12041 if(!isWasmInitialized) {
12042 throw new Error("initializeWasm() must be awaited first!");
12044 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg);
12045 return nativeResponseValue;
12047 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_clone(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR orig);
12049 export function CResult_PaymentIdPaymentSendFailureZ_clone(orig: bigint): bigint {
12050 if(!isWasmInitialized) {
12051 throw new Error("initializeWasm() must be awaited first!");
12053 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone(orig);
12054 return nativeResponseValue;
12056 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
12058 export function CResult_NonePaymentSendFailureZ_ok(): bigint {
12059 if(!isWasmInitialized) {
12060 throw new Error("initializeWasm() must be awaited first!");
12062 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_ok();
12063 return nativeResponseValue;
12065 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
12067 export function CResult_NonePaymentSendFailureZ_err(e: bigint): bigint {
12068 if(!isWasmInitialized) {
12069 throw new Error("initializeWasm() must be awaited first!");
12071 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_err(e);
12072 return nativeResponseValue;
12074 // bool CResult_NonePaymentSendFailureZ_is_ok(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR o);
12076 export function CResult_NonePaymentSendFailureZ_is_ok(o: bigint): boolean {
12077 if(!isWasmInitialized) {
12078 throw new Error("initializeWasm() must be awaited first!");
12080 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_is_ok(o);
12081 return nativeResponseValue;
12083 // void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
12085 export function CResult_NonePaymentSendFailureZ_free(_res: bigint): void {
12086 if(!isWasmInitialized) {
12087 throw new Error("initializeWasm() must be awaited first!");
12089 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_free(_res);
12090 // debug statements here
12092 // uint64_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg);
12094 export function CResult_NonePaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
12095 if(!isWasmInitialized) {
12096 throw new Error("initializeWasm() must be awaited first!");
12098 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone_ptr(arg);
12099 return nativeResponseValue;
12101 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
12103 export function CResult_NonePaymentSendFailureZ_clone(orig: bigint): bigint {
12104 if(!isWasmInitialized) {
12105 throw new Error("initializeWasm() must be awaited first!");
12107 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone(orig);
12108 return nativeResponseValue;
12110 // uint64_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg);
12112 export function C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg: bigint): bigint {
12113 if(!isWasmInitialized) {
12114 throw new Error("initializeWasm() must be awaited first!");
12116 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg);
12117 return nativeResponseValue;
12119 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_clone(const struct LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR orig);
12121 export function C2Tuple_PaymentHashPaymentIdZ_clone(orig: bigint): bigint {
12122 if(!isWasmInitialized) {
12123 throw new Error("initializeWasm() must be awaited first!");
12125 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone(orig);
12126 return nativeResponseValue;
12128 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
12130 export function C2Tuple_PaymentHashPaymentIdZ_new(a: number, b: number): bigint {
12131 if(!isWasmInitialized) {
12132 throw new Error("initializeWasm() must be awaited first!");
12134 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_new(a, b);
12135 return nativeResponseValue;
12137 // void C2Tuple_PaymentHashPaymentIdZ_free(struct LDKC2Tuple_PaymentHashPaymentIdZ _res);
12139 export function C2Tuple_PaymentHashPaymentIdZ_free(_res: bigint): void {
12140 if(!isWasmInitialized) {
12141 throw new Error("initializeWasm() must be awaited first!");
12143 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_free(_res);
12144 // debug statements here
12146 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(struct LDKC2Tuple_PaymentHashPaymentIdZ o);
12148 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o: bigint): bigint {
12149 if(!isWasmInitialized) {
12150 throw new Error("initializeWasm() must be awaited first!");
12152 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o);
12153 return nativeResponseValue;
12155 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
12157 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e: bigint): bigint {
12158 if(!isWasmInitialized) {
12159 throw new Error("initializeWasm() must be awaited first!");
12161 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e);
12162 return nativeResponseValue;
12164 // bool CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR o);
12166 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o: bigint): boolean {
12167 if(!isWasmInitialized) {
12168 throw new Error("initializeWasm() must be awaited first!");
12170 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o);
12171 return nativeResponseValue;
12173 // void CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ _res);
12175 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res: bigint): void {
12176 if(!isWasmInitialized) {
12177 throw new Error("initializeWasm() must be awaited first!");
12179 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res);
12180 // debug statements here
12182 // uint64_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg);
12184 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
12185 if(!isWasmInitialized) {
12186 throw new Error("initializeWasm() must be awaited first!");
12188 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg);
12189 return nativeResponseValue;
12191 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR orig);
12193 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig: bigint): bigint {
12194 if(!isWasmInitialized) {
12195 throw new Error("initializeWasm() must be awaited first!");
12197 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig);
12198 return nativeResponseValue;
12200 // void CVec_ThirtyTwoBytesZ_free(struct LDKCVec_ThirtyTwoBytesZ _res);
12202 export function CVec_ThirtyTwoBytesZ_free(_res: number): void {
12203 if(!isWasmInitialized) {
12204 throw new Error("initializeWasm() must be awaited first!");
12206 const nativeResponseValue = wasm.TS_CVec_ThirtyTwoBytesZ_free(_res);
12207 // debug statements here
12209 // uint64_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg);
12211 export function C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg: bigint): bigint {
12212 if(!isWasmInitialized) {
12213 throw new Error("initializeWasm() must be awaited first!");
12215 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg);
12216 return nativeResponseValue;
12218 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_clone(const struct LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR orig);
12220 export function C2Tuple_PaymentHashPaymentSecretZ_clone(orig: bigint): bigint {
12221 if(!isWasmInitialized) {
12222 throw new Error("initializeWasm() must be awaited first!");
12224 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone(orig);
12225 return nativeResponseValue;
12227 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
12229 export function C2Tuple_PaymentHashPaymentSecretZ_new(a: number, b: number): bigint {
12230 if(!isWasmInitialized) {
12231 throw new Error("initializeWasm() must be awaited first!");
12233 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_new(a, b);
12234 return nativeResponseValue;
12236 // void C2Tuple_PaymentHashPaymentSecretZ_free(struct LDKC2Tuple_PaymentHashPaymentSecretZ _res);
12238 export function C2Tuple_PaymentHashPaymentSecretZ_free(_res: bigint): void {
12239 if(!isWasmInitialized) {
12240 throw new Error("initializeWasm() must be awaited first!");
12242 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_free(_res);
12243 // debug statements here
12245 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
12247 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o: bigint): bigint {
12248 if(!isWasmInitialized) {
12249 throw new Error("initializeWasm() must be awaited first!");
12251 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o);
12252 return nativeResponseValue;
12254 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(void);
12256 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(): bigint {
12257 if(!isWasmInitialized) {
12258 throw new Error("initializeWasm() must be awaited first!");
12260 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err();
12261 return nativeResponseValue;
12263 // bool CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR o);
12265 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o: bigint): boolean {
12266 if(!isWasmInitialized) {
12267 throw new Error("initializeWasm() must be awaited first!");
12269 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o);
12270 return nativeResponseValue;
12272 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ _res);
12274 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res: bigint): void {
12275 if(!isWasmInitialized) {
12276 throw new Error("initializeWasm() must be awaited first!");
12278 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res);
12279 // debug statements here
12281 // uint64_t CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR arg);
12283 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg: bigint): bigint {
12284 if(!isWasmInitialized) {
12285 throw new Error("initializeWasm() must be awaited first!");
12287 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg);
12288 return nativeResponseValue;
12290 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR orig);
12292 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig: bigint): bigint {
12293 if(!isWasmInitialized) {
12294 throw new Error("initializeWasm() must be awaited first!");
12296 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig);
12297 return nativeResponseValue;
12299 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
12301 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o: bigint): bigint {
12302 if(!isWasmInitialized) {
12303 throw new Error("initializeWasm() must be awaited first!");
12305 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o);
12306 return nativeResponseValue;
12308 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(struct LDKAPIError e);
12310 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e: bigint): bigint {
12311 if(!isWasmInitialized) {
12312 throw new Error("initializeWasm() must be awaited first!");
12314 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e);
12315 return nativeResponseValue;
12317 // bool CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR o);
12319 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o: bigint): boolean {
12320 if(!isWasmInitialized) {
12321 throw new Error("initializeWasm() must be awaited first!");
12323 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o);
12324 return nativeResponseValue;
12326 // void CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ _res);
12328 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res: bigint): void {
12329 if(!isWasmInitialized) {
12330 throw new Error("initializeWasm() must be awaited first!");
12332 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res);
12333 // debug statements here
12335 // uint64_t CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR arg);
12337 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg: bigint): bigint {
12338 if(!isWasmInitialized) {
12339 throw new Error("initializeWasm() must be awaited first!");
12341 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg);
12342 return nativeResponseValue;
12344 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR orig);
12346 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig: bigint): bigint {
12347 if(!isWasmInitialized) {
12348 throw new Error("initializeWasm() must be awaited first!");
12350 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig);
12351 return nativeResponseValue;
12353 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_ok(struct LDKThirtyTwoBytes o);
12355 export function CResult_PaymentSecretNoneZ_ok(o: number): bigint {
12356 if(!isWasmInitialized) {
12357 throw new Error("initializeWasm() must be awaited first!");
12359 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_ok(o);
12360 return nativeResponseValue;
12362 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_err(void);
12364 export function CResult_PaymentSecretNoneZ_err(): bigint {
12365 if(!isWasmInitialized) {
12366 throw new Error("initializeWasm() must be awaited first!");
12368 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_err();
12369 return nativeResponseValue;
12371 // bool CResult_PaymentSecretNoneZ_is_ok(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR o);
12373 export function CResult_PaymentSecretNoneZ_is_ok(o: bigint): boolean {
12374 if(!isWasmInitialized) {
12375 throw new Error("initializeWasm() must be awaited first!");
12377 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_is_ok(o);
12378 return nativeResponseValue;
12380 // void CResult_PaymentSecretNoneZ_free(struct LDKCResult_PaymentSecretNoneZ _res);
12382 export function CResult_PaymentSecretNoneZ_free(_res: bigint): void {
12383 if(!isWasmInitialized) {
12384 throw new Error("initializeWasm() must be awaited first!");
12386 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_free(_res);
12387 // debug statements here
12389 // uint64_t CResult_PaymentSecretNoneZ_clone_ptr(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR arg);
12391 export function CResult_PaymentSecretNoneZ_clone_ptr(arg: bigint): bigint {
12392 if(!isWasmInitialized) {
12393 throw new Error("initializeWasm() must be awaited first!");
12395 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone_ptr(arg);
12396 return nativeResponseValue;
12398 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_clone(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR orig);
12400 export function CResult_PaymentSecretNoneZ_clone(orig: bigint): bigint {
12401 if(!isWasmInitialized) {
12402 throw new Error("initializeWasm() must be awaited first!");
12404 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone(orig);
12405 return nativeResponseValue;
12407 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
12409 export function CResult_PaymentSecretAPIErrorZ_ok(o: number): bigint {
12410 if(!isWasmInitialized) {
12411 throw new Error("initializeWasm() must be awaited first!");
12413 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_ok(o);
12414 return nativeResponseValue;
12416 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_err(struct LDKAPIError e);
12418 export function CResult_PaymentSecretAPIErrorZ_err(e: bigint): bigint {
12419 if(!isWasmInitialized) {
12420 throw new Error("initializeWasm() must be awaited first!");
12422 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_err(e);
12423 return nativeResponseValue;
12425 // bool CResult_PaymentSecretAPIErrorZ_is_ok(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR o);
12427 export function CResult_PaymentSecretAPIErrorZ_is_ok(o: bigint): boolean {
12428 if(!isWasmInitialized) {
12429 throw new Error("initializeWasm() must be awaited first!");
12431 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_is_ok(o);
12432 return nativeResponseValue;
12434 // void CResult_PaymentSecretAPIErrorZ_free(struct LDKCResult_PaymentSecretAPIErrorZ _res);
12436 export function CResult_PaymentSecretAPIErrorZ_free(_res: bigint): void {
12437 if(!isWasmInitialized) {
12438 throw new Error("initializeWasm() must be awaited first!");
12440 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_free(_res);
12441 // debug statements here
12443 // uint64_t CResult_PaymentSecretAPIErrorZ_clone_ptr(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR arg);
12445 export function CResult_PaymentSecretAPIErrorZ_clone_ptr(arg: bigint): bigint {
12446 if(!isWasmInitialized) {
12447 throw new Error("initializeWasm() must be awaited first!");
12449 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone_ptr(arg);
12450 return nativeResponseValue;
12452 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_clone(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR orig);
12454 export function CResult_PaymentSecretAPIErrorZ_clone(orig: bigint): bigint {
12455 if(!isWasmInitialized) {
12456 throw new Error("initializeWasm() must be awaited first!");
12458 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone(orig);
12459 return nativeResponseValue;
12461 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
12463 export function CResult_PaymentPreimageAPIErrorZ_ok(o: number): bigint {
12464 if(!isWasmInitialized) {
12465 throw new Error("initializeWasm() must be awaited first!");
12467 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_ok(o);
12468 return nativeResponseValue;
12470 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_err(struct LDKAPIError e);
12472 export function CResult_PaymentPreimageAPIErrorZ_err(e: bigint): bigint {
12473 if(!isWasmInitialized) {
12474 throw new Error("initializeWasm() must be awaited first!");
12476 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_err(e);
12477 return nativeResponseValue;
12479 // bool CResult_PaymentPreimageAPIErrorZ_is_ok(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR o);
12481 export function CResult_PaymentPreimageAPIErrorZ_is_ok(o: bigint): boolean {
12482 if(!isWasmInitialized) {
12483 throw new Error("initializeWasm() must be awaited first!");
12485 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_is_ok(o);
12486 return nativeResponseValue;
12488 // void CResult_PaymentPreimageAPIErrorZ_free(struct LDKCResult_PaymentPreimageAPIErrorZ _res);
12490 export function CResult_PaymentPreimageAPIErrorZ_free(_res: bigint): void {
12491 if(!isWasmInitialized) {
12492 throw new Error("initializeWasm() must be awaited first!");
12494 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_free(_res);
12495 // debug statements here
12497 // uint64_t CResult_PaymentPreimageAPIErrorZ_clone_ptr(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR arg);
12499 export function CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg: bigint): bigint {
12500 if(!isWasmInitialized) {
12501 throw new Error("initializeWasm() must be awaited first!");
12503 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg);
12504 return nativeResponseValue;
12506 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_clone(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR orig);
12508 export function CResult_PaymentPreimageAPIErrorZ_clone(orig: bigint): bigint {
12509 if(!isWasmInitialized) {
12510 throw new Error("initializeWasm() must be awaited first!");
12512 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone(orig);
12513 return nativeResponseValue;
12515 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(struct LDKCounterpartyForwardingInfo o);
12517 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o: bigint): bigint {
12518 if(!isWasmInitialized) {
12519 throw new Error("initializeWasm() must be awaited first!");
12521 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o);
12522 return nativeResponseValue;
12524 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_err(struct LDKDecodeError e);
12526 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e: bigint): bigint {
12527 if(!isWasmInitialized) {
12528 throw new Error("initializeWasm() must be awaited first!");
12530 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e);
12531 return nativeResponseValue;
12533 // bool CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR o);
12535 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o: bigint): boolean {
12536 if(!isWasmInitialized) {
12537 throw new Error("initializeWasm() must be awaited first!");
12539 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o);
12540 return nativeResponseValue;
12542 // void CResult_CounterpartyForwardingInfoDecodeErrorZ_free(struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ _res);
12544 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res: bigint): void {
12545 if(!isWasmInitialized) {
12546 throw new Error("initializeWasm() must be awaited first!");
12548 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res);
12549 // debug statements here
12551 // uint64_t CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR arg);
12553 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12554 if(!isWasmInitialized) {
12555 throw new Error("initializeWasm() must be awaited first!");
12557 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg);
12558 return nativeResponseValue;
12560 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR orig);
12562 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig: bigint): bigint {
12563 if(!isWasmInitialized) {
12564 throw new Error("initializeWasm() must be awaited first!");
12566 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig);
12567 return nativeResponseValue;
12569 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_ok(struct LDKChannelCounterparty o);
12571 export function CResult_ChannelCounterpartyDecodeErrorZ_ok(o: bigint): bigint {
12572 if(!isWasmInitialized) {
12573 throw new Error("initializeWasm() must be awaited first!");
12575 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_ok(o);
12576 return nativeResponseValue;
12578 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_err(struct LDKDecodeError e);
12580 export function CResult_ChannelCounterpartyDecodeErrorZ_err(e: bigint): bigint {
12581 if(!isWasmInitialized) {
12582 throw new Error("initializeWasm() must be awaited first!");
12584 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_err(e);
12585 return nativeResponseValue;
12587 // bool CResult_ChannelCounterpartyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR o);
12589 export function CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o: bigint): boolean {
12590 if(!isWasmInitialized) {
12591 throw new Error("initializeWasm() must be awaited first!");
12593 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o);
12594 return nativeResponseValue;
12596 // void CResult_ChannelCounterpartyDecodeErrorZ_free(struct LDKCResult_ChannelCounterpartyDecodeErrorZ _res);
12598 export function CResult_ChannelCounterpartyDecodeErrorZ_free(_res: bigint): void {
12599 if(!isWasmInitialized) {
12600 throw new Error("initializeWasm() must be awaited first!");
12602 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_free(_res);
12603 // debug statements here
12605 // uint64_t CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR arg);
12607 export function CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12608 if(!isWasmInitialized) {
12609 throw new Error("initializeWasm() must be awaited first!");
12611 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg);
12612 return nativeResponseValue;
12614 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_clone(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR orig);
12616 export function CResult_ChannelCounterpartyDecodeErrorZ_clone(orig: bigint): bigint {
12617 if(!isWasmInitialized) {
12618 throw new Error("initializeWasm() must be awaited first!");
12620 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone(orig);
12621 return nativeResponseValue;
12623 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_ok(struct LDKChannelDetails o);
12625 export function CResult_ChannelDetailsDecodeErrorZ_ok(o: bigint): bigint {
12626 if(!isWasmInitialized) {
12627 throw new Error("initializeWasm() must be awaited first!");
12629 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_ok(o);
12630 return nativeResponseValue;
12632 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_err(struct LDKDecodeError e);
12634 export function CResult_ChannelDetailsDecodeErrorZ_err(e: bigint): bigint {
12635 if(!isWasmInitialized) {
12636 throw new Error("initializeWasm() must be awaited first!");
12638 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_err(e);
12639 return nativeResponseValue;
12641 // bool CResult_ChannelDetailsDecodeErrorZ_is_ok(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR o);
12643 export function CResult_ChannelDetailsDecodeErrorZ_is_ok(o: bigint): boolean {
12644 if(!isWasmInitialized) {
12645 throw new Error("initializeWasm() must be awaited first!");
12647 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_is_ok(o);
12648 return nativeResponseValue;
12650 // void CResult_ChannelDetailsDecodeErrorZ_free(struct LDKCResult_ChannelDetailsDecodeErrorZ _res);
12652 export function CResult_ChannelDetailsDecodeErrorZ_free(_res: bigint): void {
12653 if(!isWasmInitialized) {
12654 throw new Error("initializeWasm() must be awaited first!");
12656 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_free(_res);
12657 // debug statements here
12659 // uint64_t CResult_ChannelDetailsDecodeErrorZ_clone_ptr(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR arg);
12661 export function CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12662 if(!isWasmInitialized) {
12663 throw new Error("initializeWasm() must be awaited first!");
12665 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg);
12666 return nativeResponseValue;
12668 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_clone(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR orig);
12670 export function CResult_ChannelDetailsDecodeErrorZ_clone(orig: bigint): bigint {
12671 if(!isWasmInitialized) {
12672 throw new Error("initializeWasm() must be awaited first!");
12674 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone(orig);
12675 return nativeResponseValue;
12677 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_ok(struct LDKPhantomRouteHints o);
12679 export function CResult_PhantomRouteHintsDecodeErrorZ_ok(o: bigint): bigint {
12680 if(!isWasmInitialized) {
12681 throw new Error("initializeWasm() must be awaited first!");
12683 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_ok(o);
12684 return nativeResponseValue;
12686 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_err(struct LDKDecodeError e);
12688 export function CResult_PhantomRouteHintsDecodeErrorZ_err(e: bigint): bigint {
12689 if(!isWasmInitialized) {
12690 throw new Error("initializeWasm() must be awaited first!");
12692 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_err(e);
12693 return nativeResponseValue;
12695 // bool CResult_PhantomRouteHintsDecodeErrorZ_is_ok(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR o);
12697 export function CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o: bigint): boolean {
12698 if(!isWasmInitialized) {
12699 throw new Error("initializeWasm() must be awaited first!");
12701 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o);
12702 return nativeResponseValue;
12704 // void CResult_PhantomRouteHintsDecodeErrorZ_free(struct LDKCResult_PhantomRouteHintsDecodeErrorZ _res);
12706 export function CResult_PhantomRouteHintsDecodeErrorZ_free(_res: bigint): void {
12707 if(!isWasmInitialized) {
12708 throw new Error("initializeWasm() must be awaited first!");
12710 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_free(_res);
12711 // debug statements here
12713 // uint64_t CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR arg);
12715 export function CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12716 if(!isWasmInitialized) {
12717 throw new Error("initializeWasm() must be awaited first!");
12719 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg);
12720 return nativeResponseValue;
12722 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_clone(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR orig);
12724 export function CResult_PhantomRouteHintsDecodeErrorZ_clone(orig: bigint): bigint {
12725 if(!isWasmInitialized) {
12726 throw new Error("initializeWasm() must be awaited first!");
12728 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone(orig);
12729 return nativeResponseValue;
12731 // void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
12733 export function CVec_ChannelMonitorZ_free(_res: number): void {
12734 if(!isWasmInitialized) {
12735 throw new Error("initializeWasm() must be awaited first!");
12737 const nativeResponseValue = wasm.TS_CVec_ChannelMonitorZ_free(_res);
12738 // debug statements here
12740 // struct LDKC2Tuple_BlockHashChannelManagerZ C2Tuple_BlockHashChannelManagerZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelManager b);
12742 export function C2Tuple_BlockHashChannelManagerZ_new(a: number, b: bigint): bigint {
12743 if(!isWasmInitialized) {
12744 throw new Error("initializeWasm() must be awaited first!");
12746 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_new(a, b);
12747 return nativeResponseValue;
12749 // void C2Tuple_BlockHashChannelManagerZ_free(struct LDKC2Tuple_BlockHashChannelManagerZ _res);
12751 export function C2Tuple_BlockHashChannelManagerZ_free(_res: bigint): void {
12752 if(!isWasmInitialized) {
12753 throw new Error("initializeWasm() must be awaited first!");
12755 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_free(_res);
12756 // debug statements here
12758 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelManagerZ o);
12760 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o: bigint): bigint {
12761 if(!isWasmInitialized) {
12762 throw new Error("initializeWasm() must be awaited first!");
12764 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o);
12765 return nativeResponseValue;
12767 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
12769 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e: bigint): bigint {
12770 if(!isWasmInitialized) {
12771 throw new Error("initializeWasm() must be awaited first!");
12773 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e);
12774 return nativeResponseValue;
12776 // bool CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR o);
12778 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o: bigint): boolean {
12779 if(!isWasmInitialized) {
12780 throw new Error("initializeWasm() must be awaited first!");
12782 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o);
12783 return nativeResponseValue;
12785 // void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res);
12787 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res: bigint): void {
12788 if(!isWasmInitialized) {
12789 throw new Error("initializeWasm() must be awaited first!");
12791 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res);
12792 // debug statements here
12794 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
12796 export function CResult_ChannelConfigDecodeErrorZ_ok(o: bigint): bigint {
12797 if(!isWasmInitialized) {
12798 throw new Error("initializeWasm() must be awaited first!");
12800 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_ok(o);
12801 return nativeResponseValue;
12803 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
12805 export function CResult_ChannelConfigDecodeErrorZ_err(e: bigint): bigint {
12806 if(!isWasmInitialized) {
12807 throw new Error("initializeWasm() must be awaited first!");
12809 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_err(e);
12810 return nativeResponseValue;
12812 // bool CResult_ChannelConfigDecodeErrorZ_is_ok(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR o);
12814 export function CResult_ChannelConfigDecodeErrorZ_is_ok(o: bigint): boolean {
12815 if(!isWasmInitialized) {
12816 throw new Error("initializeWasm() must be awaited first!");
12818 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_is_ok(o);
12819 return nativeResponseValue;
12821 // void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
12823 export function CResult_ChannelConfigDecodeErrorZ_free(_res: bigint): void {
12824 if(!isWasmInitialized) {
12825 throw new Error("initializeWasm() must be awaited first!");
12827 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_free(_res);
12828 // debug statements here
12830 // uint64_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg);
12832 export function CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12833 if(!isWasmInitialized) {
12834 throw new Error("initializeWasm() must be awaited first!");
12836 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg);
12837 return nativeResponseValue;
12839 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
12841 export function CResult_ChannelConfigDecodeErrorZ_clone(orig: bigint): bigint {
12842 if(!isWasmInitialized) {
12843 throw new Error("initializeWasm() must be awaited first!");
12845 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone(orig);
12846 return nativeResponseValue;
12848 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
12850 export function CResult_OutPointDecodeErrorZ_ok(o: bigint): bigint {
12851 if(!isWasmInitialized) {
12852 throw new Error("initializeWasm() must be awaited first!");
12854 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_ok(o);
12855 return nativeResponseValue;
12857 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
12859 export function CResult_OutPointDecodeErrorZ_err(e: bigint): bigint {
12860 if(!isWasmInitialized) {
12861 throw new Error("initializeWasm() must be awaited first!");
12863 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_err(e);
12864 return nativeResponseValue;
12866 // bool CResult_OutPointDecodeErrorZ_is_ok(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR o);
12868 export function CResult_OutPointDecodeErrorZ_is_ok(o: bigint): boolean {
12869 if(!isWasmInitialized) {
12870 throw new Error("initializeWasm() must be awaited first!");
12872 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_is_ok(o);
12873 return nativeResponseValue;
12875 // void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
12877 export function CResult_OutPointDecodeErrorZ_free(_res: bigint): void {
12878 if(!isWasmInitialized) {
12879 throw new Error("initializeWasm() must be awaited first!");
12881 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_free(_res);
12882 // debug statements here
12884 // uint64_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg);
12886 export function CResult_OutPointDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12887 if(!isWasmInitialized) {
12888 throw new Error("initializeWasm() must be awaited first!");
12890 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone_ptr(arg);
12891 return nativeResponseValue;
12893 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
12895 export function CResult_OutPointDecodeErrorZ_clone(orig: bigint): bigint {
12896 if(!isWasmInitialized) {
12897 throw new Error("initializeWasm() must be awaited first!");
12899 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone(orig);
12900 return nativeResponseValue;
12902 // struct LDKCOption_TypeZ COption_TypeZ_some(struct LDKType o);
12904 export function COption_TypeZ_some(o: bigint): bigint {
12905 if(!isWasmInitialized) {
12906 throw new Error("initializeWasm() must be awaited first!");
12908 const nativeResponseValue = wasm.TS_COption_TypeZ_some(o);
12909 return nativeResponseValue;
12911 // struct LDKCOption_TypeZ COption_TypeZ_none(void);
12913 export function COption_TypeZ_none(): bigint {
12914 if(!isWasmInitialized) {
12915 throw new Error("initializeWasm() must be awaited first!");
12917 const nativeResponseValue = wasm.TS_COption_TypeZ_none();
12918 return nativeResponseValue;
12920 // void COption_TypeZ_free(struct LDKCOption_TypeZ _res);
12922 export function COption_TypeZ_free(_res: bigint): void {
12923 if(!isWasmInitialized) {
12924 throw new Error("initializeWasm() must be awaited first!");
12926 const nativeResponseValue = wasm.TS_COption_TypeZ_free(_res);
12927 // debug statements here
12929 // uint64_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg);
12931 export function COption_TypeZ_clone_ptr(arg: bigint): bigint {
12932 if(!isWasmInitialized) {
12933 throw new Error("initializeWasm() must be awaited first!");
12935 const nativeResponseValue = wasm.TS_COption_TypeZ_clone_ptr(arg);
12936 return nativeResponseValue;
12938 // struct LDKCOption_TypeZ COption_TypeZ_clone(const struct LDKCOption_TypeZ *NONNULL_PTR orig);
12940 export function COption_TypeZ_clone(orig: bigint): bigint {
12941 if(!isWasmInitialized) {
12942 throw new Error("initializeWasm() must be awaited first!");
12944 const nativeResponseValue = wasm.TS_COption_TypeZ_clone(orig);
12945 return nativeResponseValue;
12947 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_ok(struct LDKCOption_TypeZ o);
12949 export function CResult_COption_TypeZDecodeErrorZ_ok(o: bigint): bigint {
12950 if(!isWasmInitialized) {
12951 throw new Error("initializeWasm() must be awaited first!");
12953 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_ok(o);
12954 return nativeResponseValue;
12956 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_err(struct LDKDecodeError e);
12958 export function CResult_COption_TypeZDecodeErrorZ_err(e: bigint): bigint {
12959 if(!isWasmInitialized) {
12960 throw new Error("initializeWasm() must be awaited first!");
12962 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_err(e);
12963 return nativeResponseValue;
12965 // bool CResult_COption_TypeZDecodeErrorZ_is_ok(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR o);
12967 export function CResult_COption_TypeZDecodeErrorZ_is_ok(o: bigint): boolean {
12968 if(!isWasmInitialized) {
12969 throw new Error("initializeWasm() must be awaited first!");
12971 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_is_ok(o);
12972 return nativeResponseValue;
12974 // void CResult_COption_TypeZDecodeErrorZ_free(struct LDKCResult_COption_TypeZDecodeErrorZ _res);
12976 export function CResult_COption_TypeZDecodeErrorZ_free(_res: bigint): void {
12977 if(!isWasmInitialized) {
12978 throw new Error("initializeWasm() must be awaited first!");
12980 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_free(_res);
12981 // debug statements here
12983 // uint64_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg);
12985 export function CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12986 if(!isWasmInitialized) {
12987 throw new Error("initializeWasm() must be awaited first!");
12989 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg);
12990 return nativeResponseValue;
12992 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_clone(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR orig);
12994 export function CResult_COption_TypeZDecodeErrorZ_clone(orig: bigint): bigint {
12995 if(!isWasmInitialized) {
12996 throw new Error("initializeWasm() must be awaited first!");
12998 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone(orig);
12999 return nativeResponseValue;
13001 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_ok(struct LDKThirtyTwoBytes o);
13003 export function CResult_PaymentIdPaymentErrorZ_ok(o: number): bigint {
13004 if(!isWasmInitialized) {
13005 throw new Error("initializeWasm() must be awaited first!");
13007 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_ok(o);
13008 return nativeResponseValue;
13010 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_err(struct LDKPaymentError e);
13012 export function CResult_PaymentIdPaymentErrorZ_err(e: bigint): bigint {
13013 if(!isWasmInitialized) {
13014 throw new Error("initializeWasm() must be awaited first!");
13016 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_err(e);
13017 return nativeResponseValue;
13019 // bool CResult_PaymentIdPaymentErrorZ_is_ok(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR o);
13021 export function CResult_PaymentIdPaymentErrorZ_is_ok(o: bigint): boolean {
13022 if(!isWasmInitialized) {
13023 throw new Error("initializeWasm() must be awaited first!");
13025 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_is_ok(o);
13026 return nativeResponseValue;
13028 // void CResult_PaymentIdPaymentErrorZ_free(struct LDKCResult_PaymentIdPaymentErrorZ _res);
13030 export function CResult_PaymentIdPaymentErrorZ_free(_res: bigint): void {
13031 if(!isWasmInitialized) {
13032 throw new Error("initializeWasm() must be awaited first!");
13034 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_free(_res);
13035 // debug statements here
13037 // uint64_t CResult_PaymentIdPaymentErrorZ_clone_ptr(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR arg);
13039 export function CResult_PaymentIdPaymentErrorZ_clone_ptr(arg: bigint): bigint {
13040 if(!isWasmInitialized) {
13041 throw new Error("initializeWasm() must be awaited first!");
13043 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone_ptr(arg);
13044 return nativeResponseValue;
13046 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_clone(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR orig);
13048 export function CResult_PaymentIdPaymentErrorZ_clone(orig: bigint): bigint {
13049 if(!isWasmInitialized) {
13050 throw new Error("initializeWasm() must be awaited first!");
13052 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone(orig);
13053 return nativeResponseValue;
13055 // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_ok(struct LDKInFlightHtlcs o);
13057 export function CResult_InFlightHtlcsDecodeErrorZ_ok(o: bigint): bigint {
13058 if(!isWasmInitialized) {
13059 throw new Error("initializeWasm() must be awaited first!");
13061 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_ok(o);
13062 return nativeResponseValue;
13064 // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_err(struct LDKDecodeError e);
13066 export function CResult_InFlightHtlcsDecodeErrorZ_err(e: bigint): bigint {
13067 if(!isWasmInitialized) {
13068 throw new Error("initializeWasm() must be awaited first!");
13070 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_err(e);
13071 return nativeResponseValue;
13073 // bool CResult_InFlightHtlcsDecodeErrorZ_is_ok(const struct LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR o);
13075 export function CResult_InFlightHtlcsDecodeErrorZ_is_ok(o: bigint): boolean {
13076 if(!isWasmInitialized) {
13077 throw new Error("initializeWasm() must be awaited first!");
13079 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_is_ok(o);
13080 return nativeResponseValue;
13082 // void CResult_InFlightHtlcsDecodeErrorZ_free(struct LDKCResult_InFlightHtlcsDecodeErrorZ _res);
13084 export function CResult_InFlightHtlcsDecodeErrorZ_free(_res: bigint): void {
13085 if(!isWasmInitialized) {
13086 throw new Error("initializeWasm() must be awaited first!");
13088 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_free(_res);
13089 // debug statements here
13091 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_ok(enum LDKSiPrefix o);
13093 export function CResult_SiPrefixParseErrorZ_ok(o: SiPrefix): bigint {
13094 if(!isWasmInitialized) {
13095 throw new Error("initializeWasm() must be awaited first!");
13097 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_ok(o);
13098 return nativeResponseValue;
13100 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_err(struct LDKParseError e);
13102 export function CResult_SiPrefixParseErrorZ_err(e: bigint): bigint {
13103 if(!isWasmInitialized) {
13104 throw new Error("initializeWasm() must be awaited first!");
13106 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_err(e);
13107 return nativeResponseValue;
13109 // bool CResult_SiPrefixParseErrorZ_is_ok(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR o);
13111 export function CResult_SiPrefixParseErrorZ_is_ok(o: bigint): boolean {
13112 if(!isWasmInitialized) {
13113 throw new Error("initializeWasm() must be awaited first!");
13115 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_is_ok(o);
13116 return nativeResponseValue;
13118 // void CResult_SiPrefixParseErrorZ_free(struct LDKCResult_SiPrefixParseErrorZ _res);
13120 export function CResult_SiPrefixParseErrorZ_free(_res: bigint): void {
13121 if(!isWasmInitialized) {
13122 throw new Error("initializeWasm() must be awaited first!");
13124 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_free(_res);
13125 // debug statements here
13127 // uint64_t CResult_SiPrefixParseErrorZ_clone_ptr(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR arg);
13129 export function CResult_SiPrefixParseErrorZ_clone_ptr(arg: bigint): bigint {
13130 if(!isWasmInitialized) {
13131 throw new Error("initializeWasm() must be awaited first!");
13133 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone_ptr(arg);
13134 return nativeResponseValue;
13136 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_clone(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR orig);
13138 export function CResult_SiPrefixParseErrorZ_clone(orig: bigint): bigint {
13139 if(!isWasmInitialized) {
13140 throw new Error("initializeWasm() must be awaited first!");
13142 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone(orig);
13143 return nativeResponseValue;
13145 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_ok(struct LDKInvoice o);
13147 export function CResult_InvoiceParseOrSemanticErrorZ_ok(o: bigint): bigint {
13148 if(!isWasmInitialized) {
13149 throw new Error("initializeWasm() must be awaited first!");
13151 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_ok(o);
13152 return nativeResponseValue;
13154 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_err(struct LDKParseOrSemanticError e);
13156 export function CResult_InvoiceParseOrSemanticErrorZ_err(e: bigint): bigint {
13157 if(!isWasmInitialized) {
13158 throw new Error("initializeWasm() must be awaited first!");
13160 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_err(e);
13161 return nativeResponseValue;
13163 // bool CResult_InvoiceParseOrSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR o);
13165 export function CResult_InvoiceParseOrSemanticErrorZ_is_ok(o: bigint): boolean {
13166 if(!isWasmInitialized) {
13167 throw new Error("initializeWasm() must be awaited first!");
13169 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_is_ok(o);
13170 return nativeResponseValue;
13172 // void CResult_InvoiceParseOrSemanticErrorZ_free(struct LDKCResult_InvoiceParseOrSemanticErrorZ _res);
13174 export function CResult_InvoiceParseOrSemanticErrorZ_free(_res: bigint): void {
13175 if(!isWasmInitialized) {
13176 throw new Error("initializeWasm() must be awaited first!");
13178 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_free(_res);
13179 // debug statements here
13181 // uint64_t CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR arg);
13183 export function CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg: bigint): bigint {
13184 if(!isWasmInitialized) {
13185 throw new Error("initializeWasm() must be awaited first!");
13187 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg);
13188 return nativeResponseValue;
13190 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_clone(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR orig);
13192 export function CResult_InvoiceParseOrSemanticErrorZ_clone(orig: bigint): bigint {
13193 if(!isWasmInitialized) {
13194 throw new Error("initializeWasm() must be awaited first!");
13196 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone(orig);
13197 return nativeResponseValue;
13199 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_ok(struct LDKSignedRawInvoice o);
13201 export function CResult_SignedRawInvoiceParseErrorZ_ok(o: bigint): bigint {
13202 if(!isWasmInitialized) {
13203 throw new Error("initializeWasm() must be awaited first!");
13205 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_ok(o);
13206 return nativeResponseValue;
13208 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_err(struct LDKParseError e);
13210 export function CResult_SignedRawInvoiceParseErrorZ_err(e: bigint): bigint {
13211 if(!isWasmInitialized) {
13212 throw new Error("initializeWasm() must be awaited first!");
13214 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_err(e);
13215 return nativeResponseValue;
13217 // bool CResult_SignedRawInvoiceParseErrorZ_is_ok(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR o);
13219 export function CResult_SignedRawInvoiceParseErrorZ_is_ok(o: bigint): boolean {
13220 if(!isWasmInitialized) {
13221 throw new Error("initializeWasm() must be awaited first!");
13223 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_is_ok(o);
13224 return nativeResponseValue;
13226 // void CResult_SignedRawInvoiceParseErrorZ_free(struct LDKCResult_SignedRawInvoiceParseErrorZ _res);
13228 export function CResult_SignedRawInvoiceParseErrorZ_free(_res: bigint): void {
13229 if(!isWasmInitialized) {
13230 throw new Error("initializeWasm() must be awaited first!");
13232 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_free(_res);
13233 // debug statements here
13235 // uint64_t CResult_SignedRawInvoiceParseErrorZ_clone_ptr(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR arg);
13237 export function CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg: bigint): bigint {
13238 if(!isWasmInitialized) {
13239 throw new Error("initializeWasm() must be awaited first!");
13241 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg);
13242 return nativeResponseValue;
13244 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_clone(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR orig);
13246 export function CResult_SignedRawInvoiceParseErrorZ_clone(orig: bigint): bigint {
13247 if(!isWasmInitialized) {
13248 throw new Error("initializeWasm() must be awaited first!");
13250 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone(orig);
13251 return nativeResponseValue;
13253 // uint64_t C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR arg);
13255 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg: bigint): bigint {
13256 if(!isWasmInitialized) {
13257 throw new Error("initializeWasm() must be awaited first!");
13259 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg);
13260 return nativeResponseValue;
13262 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(const struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR orig);
13264 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig: bigint): bigint {
13265 if(!isWasmInitialized) {
13266 throw new Error("initializeWasm() must be awaited first!");
13268 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig);
13269 return nativeResponseValue;
13271 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(struct LDKRawInvoice a, struct LDKThirtyTwoBytes b, struct LDKInvoiceSignature c);
13273 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a: bigint, b: number, c: bigint): bigint {
13274 if(!isWasmInitialized) {
13275 throw new Error("initializeWasm() must be awaited first!");
13277 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a, b, c);
13278 return nativeResponseValue;
13280 // void C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ _res);
13282 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res: bigint): void {
13283 if(!isWasmInitialized) {
13284 throw new Error("initializeWasm() must be awaited first!");
13286 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res);
13287 // debug statements here
13289 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_ok(struct LDKPayeePubKey o);
13291 export function CResult_PayeePubKeyErrorZ_ok(o: bigint): bigint {
13292 if(!isWasmInitialized) {
13293 throw new Error("initializeWasm() must be awaited first!");
13295 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_ok(o);
13296 return nativeResponseValue;
13298 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_err(enum LDKSecp256k1Error e);
13300 export function CResult_PayeePubKeyErrorZ_err(e: Secp256k1Error): bigint {
13301 if(!isWasmInitialized) {
13302 throw new Error("initializeWasm() must be awaited first!");
13304 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_err(e);
13305 return nativeResponseValue;
13307 // bool CResult_PayeePubKeyErrorZ_is_ok(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR o);
13309 export function CResult_PayeePubKeyErrorZ_is_ok(o: bigint): boolean {
13310 if(!isWasmInitialized) {
13311 throw new Error("initializeWasm() must be awaited first!");
13313 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_is_ok(o);
13314 return nativeResponseValue;
13316 // void CResult_PayeePubKeyErrorZ_free(struct LDKCResult_PayeePubKeyErrorZ _res);
13318 export function CResult_PayeePubKeyErrorZ_free(_res: bigint): void {
13319 if(!isWasmInitialized) {
13320 throw new Error("initializeWasm() must be awaited first!");
13322 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_free(_res);
13323 // debug statements here
13325 // uint64_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg);
13327 export function CResult_PayeePubKeyErrorZ_clone_ptr(arg: bigint): bigint {
13328 if(!isWasmInitialized) {
13329 throw new Error("initializeWasm() must be awaited first!");
13331 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone_ptr(arg);
13332 return nativeResponseValue;
13334 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_clone(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR orig);
13336 export function CResult_PayeePubKeyErrorZ_clone(orig: bigint): bigint {
13337 if(!isWasmInitialized) {
13338 throw new Error("initializeWasm() must be awaited first!");
13340 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone(orig);
13341 return nativeResponseValue;
13343 // void CVec_PrivateRouteZ_free(struct LDKCVec_PrivateRouteZ _res);
13345 export function CVec_PrivateRouteZ_free(_res: number): void {
13346 if(!isWasmInitialized) {
13347 throw new Error("initializeWasm() must be awaited first!");
13349 const nativeResponseValue = wasm.TS_CVec_PrivateRouteZ_free(_res);
13350 // debug statements here
13352 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_ok(struct LDKPositiveTimestamp o);
13354 export function CResult_PositiveTimestampCreationErrorZ_ok(o: bigint): bigint {
13355 if(!isWasmInitialized) {
13356 throw new Error("initializeWasm() must be awaited first!");
13358 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_ok(o);
13359 return nativeResponseValue;
13361 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_err(enum LDKCreationError e);
13363 export function CResult_PositiveTimestampCreationErrorZ_err(e: CreationError): bigint {
13364 if(!isWasmInitialized) {
13365 throw new Error("initializeWasm() must be awaited first!");
13367 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_err(e);
13368 return nativeResponseValue;
13370 // bool CResult_PositiveTimestampCreationErrorZ_is_ok(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR o);
13372 export function CResult_PositiveTimestampCreationErrorZ_is_ok(o: bigint): boolean {
13373 if(!isWasmInitialized) {
13374 throw new Error("initializeWasm() must be awaited first!");
13376 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_is_ok(o);
13377 return nativeResponseValue;
13379 // void CResult_PositiveTimestampCreationErrorZ_free(struct LDKCResult_PositiveTimestampCreationErrorZ _res);
13381 export function CResult_PositiveTimestampCreationErrorZ_free(_res: bigint): void {
13382 if(!isWasmInitialized) {
13383 throw new Error("initializeWasm() must be awaited first!");
13385 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_free(_res);
13386 // debug statements here
13388 // uint64_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg);
13390 export function CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg: bigint): bigint {
13391 if(!isWasmInitialized) {
13392 throw new Error("initializeWasm() must be awaited first!");
13394 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg);
13395 return nativeResponseValue;
13397 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_clone(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR orig);
13399 export function CResult_PositiveTimestampCreationErrorZ_clone(orig: bigint): bigint {
13400 if(!isWasmInitialized) {
13401 throw new Error("initializeWasm() must be awaited first!");
13403 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone(orig);
13404 return nativeResponseValue;
13406 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_ok(void);
13408 export function CResult_NoneSemanticErrorZ_ok(): bigint {
13409 if(!isWasmInitialized) {
13410 throw new Error("initializeWasm() must be awaited first!");
13412 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_ok();
13413 return nativeResponseValue;
13415 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_err(enum LDKSemanticError e);
13417 export function CResult_NoneSemanticErrorZ_err(e: SemanticError): bigint {
13418 if(!isWasmInitialized) {
13419 throw new Error("initializeWasm() must be awaited first!");
13421 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_err(e);
13422 return nativeResponseValue;
13424 // bool CResult_NoneSemanticErrorZ_is_ok(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR o);
13426 export function CResult_NoneSemanticErrorZ_is_ok(o: bigint): boolean {
13427 if(!isWasmInitialized) {
13428 throw new Error("initializeWasm() must be awaited first!");
13430 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_is_ok(o);
13431 return nativeResponseValue;
13433 // void CResult_NoneSemanticErrorZ_free(struct LDKCResult_NoneSemanticErrorZ _res);
13435 export function CResult_NoneSemanticErrorZ_free(_res: bigint): void {
13436 if(!isWasmInitialized) {
13437 throw new Error("initializeWasm() must be awaited first!");
13439 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_free(_res);
13440 // debug statements here
13442 // uint64_t CResult_NoneSemanticErrorZ_clone_ptr(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR arg);
13444 export function CResult_NoneSemanticErrorZ_clone_ptr(arg: bigint): bigint {
13445 if(!isWasmInitialized) {
13446 throw new Error("initializeWasm() must be awaited first!");
13448 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone_ptr(arg);
13449 return nativeResponseValue;
13451 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_clone(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR orig);
13453 export function CResult_NoneSemanticErrorZ_clone(orig: bigint): bigint {
13454 if(!isWasmInitialized) {
13455 throw new Error("initializeWasm() must be awaited first!");
13457 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone(orig);
13458 return nativeResponseValue;
13460 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_ok(struct LDKInvoice o);
13462 export function CResult_InvoiceSemanticErrorZ_ok(o: bigint): bigint {
13463 if(!isWasmInitialized) {
13464 throw new Error("initializeWasm() must be awaited first!");
13466 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_ok(o);
13467 return nativeResponseValue;
13469 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_err(enum LDKSemanticError e);
13471 export function CResult_InvoiceSemanticErrorZ_err(e: SemanticError): bigint {
13472 if(!isWasmInitialized) {
13473 throw new Error("initializeWasm() must be awaited first!");
13475 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_err(e);
13476 return nativeResponseValue;
13478 // bool CResult_InvoiceSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR o);
13480 export function CResult_InvoiceSemanticErrorZ_is_ok(o: bigint): boolean {
13481 if(!isWasmInitialized) {
13482 throw new Error("initializeWasm() must be awaited first!");
13484 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_is_ok(o);
13485 return nativeResponseValue;
13487 // void CResult_InvoiceSemanticErrorZ_free(struct LDKCResult_InvoiceSemanticErrorZ _res);
13489 export function CResult_InvoiceSemanticErrorZ_free(_res: bigint): void {
13490 if(!isWasmInitialized) {
13491 throw new Error("initializeWasm() must be awaited first!");
13493 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_free(_res);
13494 // debug statements here
13496 // uint64_t CResult_InvoiceSemanticErrorZ_clone_ptr(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR arg);
13498 export function CResult_InvoiceSemanticErrorZ_clone_ptr(arg: bigint): bigint {
13499 if(!isWasmInitialized) {
13500 throw new Error("initializeWasm() must be awaited first!");
13502 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone_ptr(arg);
13503 return nativeResponseValue;
13505 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_clone(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR orig);
13507 export function CResult_InvoiceSemanticErrorZ_clone(orig: bigint): bigint {
13508 if(!isWasmInitialized) {
13509 throw new Error("initializeWasm() must be awaited first!");
13511 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone(orig);
13512 return nativeResponseValue;
13514 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_ok(struct LDKDescription o);
13516 export function CResult_DescriptionCreationErrorZ_ok(o: bigint): bigint {
13517 if(!isWasmInitialized) {
13518 throw new Error("initializeWasm() must be awaited first!");
13520 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_ok(o);
13521 return nativeResponseValue;
13523 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_err(enum LDKCreationError e);
13525 export function CResult_DescriptionCreationErrorZ_err(e: CreationError): bigint {
13526 if(!isWasmInitialized) {
13527 throw new Error("initializeWasm() must be awaited first!");
13529 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_err(e);
13530 return nativeResponseValue;
13532 // bool CResult_DescriptionCreationErrorZ_is_ok(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR o);
13534 export function CResult_DescriptionCreationErrorZ_is_ok(o: bigint): boolean {
13535 if(!isWasmInitialized) {
13536 throw new Error("initializeWasm() must be awaited first!");
13538 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_is_ok(o);
13539 return nativeResponseValue;
13541 // void CResult_DescriptionCreationErrorZ_free(struct LDKCResult_DescriptionCreationErrorZ _res);
13543 export function CResult_DescriptionCreationErrorZ_free(_res: bigint): void {
13544 if(!isWasmInitialized) {
13545 throw new Error("initializeWasm() must be awaited first!");
13547 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_free(_res);
13548 // debug statements here
13550 // uint64_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg);
13552 export function CResult_DescriptionCreationErrorZ_clone_ptr(arg: bigint): bigint {
13553 if(!isWasmInitialized) {
13554 throw new Error("initializeWasm() must be awaited first!");
13556 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone_ptr(arg);
13557 return nativeResponseValue;
13559 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_clone(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR orig);
13561 export function CResult_DescriptionCreationErrorZ_clone(orig: bigint): bigint {
13562 if(!isWasmInitialized) {
13563 throw new Error("initializeWasm() must be awaited first!");
13565 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone(orig);
13566 return nativeResponseValue;
13568 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_ok(struct LDKPrivateRoute o);
13570 export function CResult_PrivateRouteCreationErrorZ_ok(o: bigint): bigint {
13571 if(!isWasmInitialized) {
13572 throw new Error("initializeWasm() must be awaited first!");
13574 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_ok(o);
13575 return nativeResponseValue;
13577 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_err(enum LDKCreationError e);
13579 export function CResult_PrivateRouteCreationErrorZ_err(e: CreationError): bigint {
13580 if(!isWasmInitialized) {
13581 throw new Error("initializeWasm() must be awaited first!");
13583 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_err(e);
13584 return nativeResponseValue;
13586 // bool CResult_PrivateRouteCreationErrorZ_is_ok(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR o);
13588 export function CResult_PrivateRouteCreationErrorZ_is_ok(o: bigint): boolean {
13589 if(!isWasmInitialized) {
13590 throw new Error("initializeWasm() must be awaited first!");
13592 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_is_ok(o);
13593 return nativeResponseValue;
13595 // void CResult_PrivateRouteCreationErrorZ_free(struct LDKCResult_PrivateRouteCreationErrorZ _res);
13597 export function CResult_PrivateRouteCreationErrorZ_free(_res: bigint): void {
13598 if(!isWasmInitialized) {
13599 throw new Error("initializeWasm() must be awaited first!");
13601 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_free(_res);
13602 // debug statements here
13604 // uint64_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg);
13606 export function CResult_PrivateRouteCreationErrorZ_clone_ptr(arg: bigint): bigint {
13607 if(!isWasmInitialized) {
13608 throw new Error("initializeWasm() must be awaited first!");
13610 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(arg);
13611 return nativeResponseValue;
13613 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_clone(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR orig);
13615 export function CResult_PrivateRouteCreationErrorZ_clone(orig: bigint): bigint {
13616 if(!isWasmInitialized) {
13617 throw new Error("initializeWasm() must be awaited first!");
13619 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone(orig);
13620 return nativeResponseValue;
13622 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_ok(struct LDKStr o);
13624 export function CResult_StringErrorZ_ok(o: number): bigint {
13625 if(!isWasmInitialized) {
13626 throw new Error("initializeWasm() must be awaited first!");
13628 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_ok(o);
13629 return nativeResponseValue;
13631 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_err(enum LDKSecp256k1Error e);
13633 export function CResult_StringErrorZ_err(e: Secp256k1Error): bigint {
13634 if(!isWasmInitialized) {
13635 throw new Error("initializeWasm() must be awaited first!");
13637 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_err(e);
13638 return nativeResponseValue;
13640 // bool CResult_StringErrorZ_is_ok(const struct LDKCResult_StringErrorZ *NONNULL_PTR o);
13642 export function CResult_StringErrorZ_is_ok(o: bigint): boolean {
13643 if(!isWasmInitialized) {
13644 throw new Error("initializeWasm() must be awaited first!");
13646 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_is_ok(o);
13647 return nativeResponseValue;
13649 // void CResult_StringErrorZ_free(struct LDKCResult_StringErrorZ _res);
13651 export function CResult_StringErrorZ_free(_res: bigint): void {
13652 if(!isWasmInitialized) {
13653 throw new Error("initializeWasm() must be awaited first!");
13655 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_free(_res);
13656 // debug statements here
13658 // uint64_t CResult_StringErrorZ_clone_ptr(LDKCResult_StringErrorZ *NONNULL_PTR arg);
13660 export function CResult_StringErrorZ_clone_ptr(arg: bigint): bigint {
13661 if(!isWasmInitialized) {
13662 throw new Error("initializeWasm() must be awaited first!");
13664 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_clone_ptr(arg);
13665 return nativeResponseValue;
13667 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_clone(const struct LDKCResult_StringErrorZ *NONNULL_PTR orig);
13669 export function CResult_StringErrorZ_clone(orig: bigint): bigint {
13670 if(!isWasmInitialized) {
13671 throw new Error("initializeWasm() must be awaited first!");
13673 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_clone(orig);
13674 return nativeResponseValue;
13676 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
13678 export function CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: bigint): bigint {
13679 if(!isWasmInitialized) {
13680 throw new Error("initializeWasm() must be awaited first!");
13682 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o);
13683 return nativeResponseValue;
13685 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
13687 export function CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: bigint): bigint {
13688 if(!isWasmInitialized) {
13689 throw new Error("initializeWasm() must be awaited first!");
13691 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(e);
13692 return nativeResponseValue;
13694 // bool CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR o);
13696 export function CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
13697 if(!isWasmInitialized) {
13698 throw new Error("initializeWasm() must be awaited first!");
13700 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o);
13701 return nativeResponseValue;
13703 // void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
13705 export function CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: bigint): void {
13706 if(!isWasmInitialized) {
13707 throw new Error("initializeWasm() must be awaited first!");
13709 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res);
13710 // debug statements here
13712 // uint64_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg);
13714 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13715 if(!isWasmInitialized) {
13716 throw new Error("initializeWasm() must be awaited first!");
13718 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg);
13719 return nativeResponseValue;
13721 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
13723 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: bigint): bigint {
13724 if(!isWasmInitialized) {
13725 throw new Error("initializeWasm() must be awaited first!");
13727 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig);
13728 return nativeResponseValue;
13730 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_some(struct LDKMonitorEvent o);
13732 export function COption_MonitorEventZ_some(o: bigint): bigint {
13733 if(!isWasmInitialized) {
13734 throw new Error("initializeWasm() must be awaited first!");
13736 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_some(o);
13737 return nativeResponseValue;
13739 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_none(void);
13741 export function COption_MonitorEventZ_none(): bigint {
13742 if(!isWasmInitialized) {
13743 throw new Error("initializeWasm() must be awaited first!");
13745 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_none();
13746 return nativeResponseValue;
13748 // void COption_MonitorEventZ_free(struct LDKCOption_MonitorEventZ _res);
13750 export function COption_MonitorEventZ_free(_res: bigint): void {
13751 if(!isWasmInitialized) {
13752 throw new Error("initializeWasm() must be awaited first!");
13754 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_free(_res);
13755 // debug statements here
13757 // uint64_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg);
13759 export function COption_MonitorEventZ_clone_ptr(arg: bigint): bigint {
13760 if(!isWasmInitialized) {
13761 throw new Error("initializeWasm() must be awaited first!");
13763 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone_ptr(arg);
13764 return nativeResponseValue;
13766 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_clone(const struct LDKCOption_MonitorEventZ *NONNULL_PTR orig);
13768 export function COption_MonitorEventZ_clone(orig: bigint): bigint {
13769 if(!isWasmInitialized) {
13770 throw new Error("initializeWasm() must be awaited first!");
13772 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone(orig);
13773 return nativeResponseValue;
13775 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_ok(struct LDKCOption_MonitorEventZ o);
13777 export function CResult_COption_MonitorEventZDecodeErrorZ_ok(o: bigint): bigint {
13778 if(!isWasmInitialized) {
13779 throw new Error("initializeWasm() must be awaited first!");
13781 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(o);
13782 return nativeResponseValue;
13784 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_err(struct LDKDecodeError e);
13786 export function CResult_COption_MonitorEventZDecodeErrorZ_err(e: bigint): bigint {
13787 if(!isWasmInitialized) {
13788 throw new Error("initializeWasm() must be awaited first!");
13790 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_err(e);
13791 return nativeResponseValue;
13793 // bool CResult_COption_MonitorEventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR o);
13795 export function CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o: bigint): boolean {
13796 if(!isWasmInitialized) {
13797 throw new Error("initializeWasm() must be awaited first!");
13799 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o);
13800 return nativeResponseValue;
13802 // void CResult_COption_MonitorEventZDecodeErrorZ_free(struct LDKCResult_COption_MonitorEventZDecodeErrorZ _res);
13804 export function CResult_COption_MonitorEventZDecodeErrorZ_free(_res: bigint): void {
13805 if(!isWasmInitialized) {
13806 throw new Error("initializeWasm() must be awaited first!");
13808 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_free(_res);
13809 // debug statements here
13811 // uint64_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg);
13813 export function CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13814 if(!isWasmInitialized) {
13815 throw new Error("initializeWasm() must be awaited first!");
13817 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg);
13818 return nativeResponseValue;
13820 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_clone(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR orig);
13822 export function CResult_COption_MonitorEventZDecodeErrorZ_clone(orig: bigint): bigint {
13823 if(!isWasmInitialized) {
13824 throw new Error("initializeWasm() must be awaited first!");
13826 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(orig);
13827 return nativeResponseValue;
13829 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
13831 export function CResult_HTLCUpdateDecodeErrorZ_ok(o: bigint): bigint {
13832 if(!isWasmInitialized) {
13833 throw new Error("initializeWasm() must be awaited first!");
13835 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_ok(o);
13836 return nativeResponseValue;
13838 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
13840 export function CResult_HTLCUpdateDecodeErrorZ_err(e: bigint): bigint {
13841 if(!isWasmInitialized) {
13842 throw new Error("initializeWasm() must be awaited first!");
13844 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_err(e);
13845 return nativeResponseValue;
13847 // bool CResult_HTLCUpdateDecodeErrorZ_is_ok(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR o);
13849 export function CResult_HTLCUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
13850 if(!isWasmInitialized) {
13851 throw new Error("initializeWasm() must be awaited first!");
13853 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(o);
13854 return nativeResponseValue;
13856 // void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
13858 export function CResult_HTLCUpdateDecodeErrorZ_free(_res: bigint): void {
13859 if(!isWasmInitialized) {
13860 throw new Error("initializeWasm() must be awaited first!");
13862 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_free(_res);
13863 // debug statements here
13865 // uint64_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg);
13867 export function CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13868 if(!isWasmInitialized) {
13869 throw new Error("initializeWasm() must be awaited first!");
13871 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg);
13872 return nativeResponseValue;
13874 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
13876 export function CResult_HTLCUpdateDecodeErrorZ_clone(orig: bigint): bigint {
13877 if(!isWasmInitialized) {
13878 throw new Error("initializeWasm() must be awaited first!");
13880 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone(orig);
13881 return nativeResponseValue;
13883 // uint64_t C2Tuple_OutPointScriptZ_clone_ptr(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR arg);
13885 export function C2Tuple_OutPointScriptZ_clone_ptr(arg: bigint): bigint {
13886 if(!isWasmInitialized) {
13887 throw new Error("initializeWasm() must be awaited first!");
13889 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone_ptr(arg);
13890 return nativeResponseValue;
13892 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_clone(const struct LDKC2Tuple_OutPointScriptZ *NONNULL_PTR orig);
13894 export function C2Tuple_OutPointScriptZ_clone(orig: bigint): bigint {
13895 if(!isWasmInitialized) {
13896 throw new Error("initializeWasm() must be awaited first!");
13898 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone(orig);
13899 return nativeResponseValue;
13901 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
13903 export function C2Tuple_OutPointScriptZ_new(a: bigint, b: number): bigint {
13904 if(!isWasmInitialized) {
13905 throw new Error("initializeWasm() must be awaited first!");
13907 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_new(a, b);
13908 return nativeResponseValue;
13910 // void C2Tuple_OutPointScriptZ_free(struct LDKC2Tuple_OutPointScriptZ _res);
13912 export function C2Tuple_OutPointScriptZ_free(_res: bigint): void {
13913 if(!isWasmInitialized) {
13914 throw new Error("initializeWasm() must be awaited first!");
13916 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_free(_res);
13917 // debug statements here
13919 // uint64_t C2Tuple_u32ScriptZ_clone_ptr(LDKC2Tuple_u32ScriptZ *NONNULL_PTR arg);
13921 export function C2Tuple_u32ScriptZ_clone_ptr(arg: bigint): bigint {
13922 if(!isWasmInitialized) {
13923 throw new Error("initializeWasm() must be awaited first!");
13925 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone_ptr(arg);
13926 return nativeResponseValue;
13928 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_clone(const struct LDKC2Tuple_u32ScriptZ *NONNULL_PTR orig);
13930 export function C2Tuple_u32ScriptZ_clone(orig: bigint): bigint {
13931 if(!isWasmInitialized) {
13932 throw new Error("initializeWasm() must be awaited first!");
13934 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone(orig);
13935 return nativeResponseValue;
13937 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_new(uint32_t a, struct LDKCVec_u8Z b);
13939 export function C2Tuple_u32ScriptZ_new(a: number, b: number): bigint {
13940 if(!isWasmInitialized) {
13941 throw new Error("initializeWasm() must be awaited first!");
13943 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_new(a, b);
13944 return nativeResponseValue;
13946 // void C2Tuple_u32ScriptZ_free(struct LDKC2Tuple_u32ScriptZ _res);
13948 export function C2Tuple_u32ScriptZ_free(_res: bigint): void {
13949 if(!isWasmInitialized) {
13950 throw new Error("initializeWasm() must be awaited first!");
13952 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_free(_res);
13953 // debug statements here
13955 // void CVec_C2Tuple_u32ScriptZZ_free(struct LDKCVec_C2Tuple_u32ScriptZZ _res);
13957 export function CVec_C2Tuple_u32ScriptZZ_free(_res: number): void {
13958 if(!isWasmInitialized) {
13959 throw new Error("initializeWasm() must be awaited first!");
13961 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32ScriptZZ_free(_res);
13962 // debug statements here
13964 // uint64_t C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR arg);
13966 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg: bigint): bigint {
13967 if(!isWasmInitialized) {
13968 throw new Error("initializeWasm() must be awaited first!");
13970 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg);
13971 return nativeResponseValue;
13973 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR orig);
13975 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig: bigint): bigint {
13976 if(!isWasmInitialized) {
13977 throw new Error("initializeWasm() must be awaited first!");
13979 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig);
13980 return nativeResponseValue;
13982 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32ScriptZZ b);
13984 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a: number, b: number): bigint {
13985 if(!isWasmInitialized) {
13986 throw new Error("initializeWasm() must be awaited first!");
13988 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a, b);
13989 return nativeResponseValue;
13991 // void C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res);
13993 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res: bigint): void {
13994 if(!isWasmInitialized) {
13995 throw new Error("initializeWasm() must be awaited first!");
13997 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res);
13998 // debug statements here
14000 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res);
14002 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res: number): void {
14003 if(!isWasmInitialized) {
14004 throw new Error("initializeWasm() must be awaited first!");
14006 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res);
14007 // debug statements here
14009 // void CVec_EventZ_free(struct LDKCVec_EventZ _res);
14011 export function CVec_EventZ_free(_res: number): void {
14012 if(!isWasmInitialized) {
14013 throw new Error("initializeWasm() must be awaited first!");
14015 const nativeResponseValue = wasm.TS_CVec_EventZ_free(_res);
14016 // debug statements here
14018 // void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
14020 export function CVec_TransactionZ_free(_res: number): void {
14021 if(!isWasmInitialized) {
14022 throw new Error("initializeWasm() must be awaited first!");
14024 const nativeResponseValue = wasm.TS_CVec_TransactionZ_free(_res);
14025 // debug statements here
14027 // uint64_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg);
14029 export function C2Tuple_u32TxOutZ_clone_ptr(arg: bigint): bigint {
14030 if(!isWasmInitialized) {
14031 throw new Error("initializeWasm() must be awaited first!");
14033 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone_ptr(arg);
14034 return nativeResponseValue;
14036 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
14038 export function C2Tuple_u32TxOutZ_clone(orig: bigint): bigint {
14039 if(!isWasmInitialized) {
14040 throw new Error("initializeWasm() must be awaited first!");
14042 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone(orig);
14043 return nativeResponseValue;
14045 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
14047 export function C2Tuple_u32TxOutZ_new(a: number, b: bigint): bigint {
14048 if(!isWasmInitialized) {
14049 throw new Error("initializeWasm() must be awaited first!");
14051 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_new(a, b);
14052 return nativeResponseValue;
14054 // void C2Tuple_u32TxOutZ_free(struct LDKC2Tuple_u32TxOutZ _res);
14056 export function C2Tuple_u32TxOutZ_free(_res: bigint): void {
14057 if(!isWasmInitialized) {
14058 throw new Error("initializeWasm() must be awaited first!");
14060 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_free(_res);
14061 // debug statements here
14063 // void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
14065 export function CVec_C2Tuple_u32TxOutZZ_free(_res: number): void {
14066 if(!isWasmInitialized) {
14067 throw new Error("initializeWasm() must be awaited first!");
14069 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32TxOutZZ_free(_res);
14070 // debug statements here
14072 // uint64_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg);
14074 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg: bigint): bigint {
14075 if(!isWasmInitialized) {
14076 throw new Error("initializeWasm() must be awaited first!");
14078 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg);
14079 return nativeResponseValue;
14081 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR orig);
14083 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig: bigint): bigint {
14084 if(!isWasmInitialized) {
14085 throw new Error("initializeWasm() must be awaited first!");
14087 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig);
14088 return nativeResponseValue;
14090 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
14092 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a: number, b: number): bigint {
14093 if(!isWasmInitialized) {
14094 throw new Error("initializeWasm() must be awaited first!");
14096 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a, b);
14097 return nativeResponseValue;
14099 // void C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res);
14101 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res: bigint): void {
14102 if(!isWasmInitialized) {
14103 throw new Error("initializeWasm() must be awaited first!");
14105 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res);
14106 // debug statements here
14108 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res);
14110 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res: number): void {
14111 if(!isWasmInitialized) {
14112 throw new Error("initializeWasm() must be awaited first!");
14114 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res);
14115 // debug statements here
14117 // void CVec_BalanceZ_free(struct LDKCVec_BalanceZ _res);
14119 export function CVec_BalanceZ_free(_res: number): void {
14120 if(!isWasmInitialized) {
14121 throw new Error("initializeWasm() must be awaited first!");
14123 const nativeResponseValue = wasm.TS_CVec_BalanceZ_free(_res);
14124 // debug statements here
14126 // uint64_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg);
14128 export function C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg: bigint): bigint {
14129 if(!isWasmInitialized) {
14130 throw new Error("initializeWasm() must be awaited first!");
14132 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg);
14133 return nativeResponseValue;
14135 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_clone(const struct LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR orig);
14137 export function C2Tuple_BlockHashChannelMonitorZ_clone(orig: bigint): bigint {
14138 if(!isWasmInitialized) {
14139 throw new Error("initializeWasm() must be awaited first!");
14141 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone(orig);
14142 return nativeResponseValue;
14144 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
14146 export function C2Tuple_BlockHashChannelMonitorZ_new(a: number, b: bigint): bigint {
14147 if(!isWasmInitialized) {
14148 throw new Error("initializeWasm() must be awaited first!");
14150 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_new(a, b);
14151 return nativeResponseValue;
14153 // void C2Tuple_BlockHashChannelMonitorZ_free(struct LDKC2Tuple_BlockHashChannelMonitorZ _res);
14155 export function C2Tuple_BlockHashChannelMonitorZ_free(_res: bigint): void {
14156 if(!isWasmInitialized) {
14157 throw new Error("initializeWasm() must be awaited first!");
14159 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_free(_res);
14160 // debug statements here
14162 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelMonitorZ o);
14164 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o: bigint): bigint {
14165 if(!isWasmInitialized) {
14166 throw new Error("initializeWasm() must be awaited first!");
14168 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o);
14169 return nativeResponseValue;
14171 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
14173 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e: bigint): bigint {
14174 if(!isWasmInitialized) {
14175 throw new Error("initializeWasm() must be awaited first!");
14177 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e);
14178 return nativeResponseValue;
14180 // bool CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR o);
14182 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o: bigint): boolean {
14183 if(!isWasmInitialized) {
14184 throw new Error("initializeWasm() must be awaited first!");
14186 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o);
14187 return nativeResponseValue;
14189 // void CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res);
14191 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res: bigint): void {
14192 if(!isWasmInitialized) {
14193 throw new Error("initializeWasm() must be awaited first!");
14195 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res);
14196 // debug statements here
14198 // uint64_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg);
14200 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14201 if(!isWasmInitialized) {
14202 throw new Error("initializeWasm() must be awaited first!");
14204 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg);
14205 return nativeResponseValue;
14207 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR orig);
14209 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig: bigint): bigint {
14210 if(!isWasmInitialized) {
14211 throw new Error("initializeWasm() must be awaited first!");
14213 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig);
14214 return nativeResponseValue;
14216 // uint64_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg);
14218 export function C2Tuple_PublicKeyTypeZ_clone_ptr(arg: bigint): bigint {
14219 if(!isWasmInitialized) {
14220 throw new Error("initializeWasm() must be awaited first!");
14222 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone_ptr(arg);
14223 return nativeResponseValue;
14225 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_clone(const struct LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR orig);
14227 export function C2Tuple_PublicKeyTypeZ_clone(orig: bigint): bigint {
14228 if(!isWasmInitialized) {
14229 throw new Error("initializeWasm() must be awaited first!");
14231 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone(orig);
14232 return nativeResponseValue;
14234 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_new(struct LDKPublicKey a, struct LDKType b);
14236 export function C2Tuple_PublicKeyTypeZ_new(a: number, b: bigint): bigint {
14237 if(!isWasmInitialized) {
14238 throw new Error("initializeWasm() must be awaited first!");
14240 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_new(a, b);
14241 return nativeResponseValue;
14243 // void C2Tuple_PublicKeyTypeZ_free(struct LDKC2Tuple_PublicKeyTypeZ _res);
14245 export function C2Tuple_PublicKeyTypeZ_free(_res: bigint): void {
14246 if(!isWasmInitialized) {
14247 throw new Error("initializeWasm() must be awaited first!");
14249 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_free(_res);
14250 // debug statements here
14252 // void CVec_C2Tuple_PublicKeyTypeZZ_free(struct LDKCVec_C2Tuple_PublicKeyTypeZZ _res);
14254 export function CVec_C2Tuple_PublicKeyTypeZZ_free(_res: number): void {
14255 if(!isWasmInitialized) {
14256 throw new Error("initializeWasm() must be awaited first!");
14258 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyTypeZZ_free(_res);
14259 // debug statements here
14261 // struct LDKCOption_CustomOnionMessageContentsZ COption_CustomOnionMessageContentsZ_some(struct LDKCustomOnionMessageContents o);
14263 export function COption_CustomOnionMessageContentsZ_some(o: bigint): bigint {
14264 if(!isWasmInitialized) {
14265 throw new Error("initializeWasm() must be awaited first!");
14267 const nativeResponseValue = wasm.TS_COption_CustomOnionMessageContentsZ_some(o);
14268 return nativeResponseValue;
14270 // struct LDKCOption_CustomOnionMessageContentsZ COption_CustomOnionMessageContentsZ_none(void);
14272 export function COption_CustomOnionMessageContentsZ_none(): bigint {
14273 if(!isWasmInitialized) {
14274 throw new Error("initializeWasm() must be awaited first!");
14276 const nativeResponseValue = wasm.TS_COption_CustomOnionMessageContentsZ_none();
14277 return nativeResponseValue;
14279 // void COption_CustomOnionMessageContentsZ_free(struct LDKCOption_CustomOnionMessageContentsZ _res);
14281 export function COption_CustomOnionMessageContentsZ_free(_res: bigint): void {
14282 if(!isWasmInitialized) {
14283 throw new Error("initializeWasm() must be awaited first!");
14285 const nativeResponseValue = wasm.TS_COption_CustomOnionMessageContentsZ_free(_res);
14286 // debug statements here
14288 // uint64_t COption_CustomOnionMessageContentsZ_clone_ptr(LDKCOption_CustomOnionMessageContentsZ *NONNULL_PTR arg);
14290 export function COption_CustomOnionMessageContentsZ_clone_ptr(arg: bigint): bigint {
14291 if(!isWasmInitialized) {
14292 throw new Error("initializeWasm() must be awaited first!");
14294 const nativeResponseValue = wasm.TS_COption_CustomOnionMessageContentsZ_clone_ptr(arg);
14295 return nativeResponseValue;
14297 // struct LDKCOption_CustomOnionMessageContentsZ COption_CustomOnionMessageContentsZ_clone(const struct LDKCOption_CustomOnionMessageContentsZ *NONNULL_PTR orig);
14299 export function COption_CustomOnionMessageContentsZ_clone(orig: bigint): bigint {
14300 if(!isWasmInitialized) {
14301 throw new Error("initializeWasm() must be awaited first!");
14303 const nativeResponseValue = wasm.TS_COption_CustomOnionMessageContentsZ_clone(orig);
14304 return nativeResponseValue;
14306 // struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok(struct LDKCOption_CustomOnionMessageContentsZ o);
14308 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok(o: bigint): bigint {
14309 if(!isWasmInitialized) {
14310 throw new Error("initializeWasm() must be awaited first!");
14312 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok(o);
14313 return nativeResponseValue;
14315 // struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_err(struct LDKDecodeError e);
14317 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_err(e: bigint): bigint {
14318 if(!isWasmInitialized) {
14319 throw new Error("initializeWasm() must be awaited first!");
14321 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_err(e);
14322 return nativeResponseValue;
14324 // bool CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_is_ok(const struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR o);
14326 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_is_ok(o: bigint): boolean {
14327 if(!isWasmInitialized) {
14328 throw new Error("initializeWasm() must be awaited first!");
14330 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_is_ok(o);
14331 return nativeResponseValue;
14333 // void CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ _res);
14335 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(_res: bigint): void {
14336 if(!isWasmInitialized) {
14337 throw new Error("initializeWasm() must be awaited first!");
14339 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(_res);
14340 // debug statements here
14342 // uint64_t CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR arg);
14344 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14345 if(!isWasmInitialized) {
14346 throw new Error("initializeWasm() must be awaited first!");
14348 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr(arg);
14349 return nativeResponseValue;
14351 // struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone(const struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR orig);
14353 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone(orig: bigint): bigint {
14354 if(!isWasmInitialized) {
14355 throw new Error("initializeWasm() must be awaited first!");
14357 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone(orig);
14358 return nativeResponseValue;
14360 // struct LDKCOption_NetAddressZ COption_NetAddressZ_some(struct LDKNetAddress o);
14362 export function COption_NetAddressZ_some(o: bigint): bigint {
14363 if(!isWasmInitialized) {
14364 throw new Error("initializeWasm() must be awaited first!");
14366 const nativeResponseValue = wasm.TS_COption_NetAddressZ_some(o);
14367 return nativeResponseValue;
14369 // struct LDKCOption_NetAddressZ COption_NetAddressZ_none(void);
14371 export function COption_NetAddressZ_none(): bigint {
14372 if(!isWasmInitialized) {
14373 throw new Error("initializeWasm() must be awaited first!");
14375 const nativeResponseValue = wasm.TS_COption_NetAddressZ_none();
14376 return nativeResponseValue;
14378 // void COption_NetAddressZ_free(struct LDKCOption_NetAddressZ _res);
14380 export function COption_NetAddressZ_free(_res: bigint): void {
14381 if(!isWasmInitialized) {
14382 throw new Error("initializeWasm() must be awaited first!");
14384 const nativeResponseValue = wasm.TS_COption_NetAddressZ_free(_res);
14385 // debug statements here
14387 // uint64_t COption_NetAddressZ_clone_ptr(LDKCOption_NetAddressZ *NONNULL_PTR arg);
14389 export function COption_NetAddressZ_clone_ptr(arg: bigint): bigint {
14390 if(!isWasmInitialized) {
14391 throw new Error("initializeWasm() must be awaited first!");
14393 const nativeResponseValue = wasm.TS_COption_NetAddressZ_clone_ptr(arg);
14394 return nativeResponseValue;
14396 // struct LDKCOption_NetAddressZ COption_NetAddressZ_clone(const struct LDKCOption_NetAddressZ *NONNULL_PTR orig);
14398 export function COption_NetAddressZ_clone(orig: bigint): bigint {
14399 if(!isWasmInitialized) {
14400 throw new Error("initializeWasm() must be awaited first!");
14402 const nativeResponseValue = wasm.TS_COption_NetAddressZ_clone(orig);
14403 return nativeResponseValue;
14405 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
14407 export function CResult_CVec_u8ZPeerHandleErrorZ_ok(o: number): bigint {
14408 if(!isWasmInitialized) {
14409 throw new Error("initializeWasm() must be awaited first!");
14411 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(o);
14412 return nativeResponseValue;
14414 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
14416 export function CResult_CVec_u8ZPeerHandleErrorZ_err(e: bigint): bigint {
14417 if(!isWasmInitialized) {
14418 throw new Error("initializeWasm() must be awaited first!");
14420 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_err(e);
14421 return nativeResponseValue;
14423 // bool CResult_CVec_u8ZPeerHandleErrorZ_is_ok(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR o);
14425 export function CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o: bigint): boolean {
14426 if(!isWasmInitialized) {
14427 throw new Error("initializeWasm() must be awaited first!");
14429 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o);
14430 return nativeResponseValue;
14432 // void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
14434 export function CResult_CVec_u8ZPeerHandleErrorZ_free(_res: bigint): void {
14435 if(!isWasmInitialized) {
14436 throw new Error("initializeWasm() must be awaited first!");
14438 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_free(_res);
14439 // debug statements here
14441 // uint64_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg);
14443 export function CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
14444 if(!isWasmInitialized) {
14445 throw new Error("initializeWasm() must be awaited first!");
14447 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg);
14448 return nativeResponseValue;
14450 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
14452 export function CResult_CVec_u8ZPeerHandleErrorZ_clone(orig: bigint): bigint {
14453 if(!isWasmInitialized) {
14454 throw new Error("initializeWasm() must be awaited first!");
14456 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(orig);
14457 return nativeResponseValue;
14459 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
14461 export function CResult_NonePeerHandleErrorZ_ok(): bigint {
14462 if(!isWasmInitialized) {
14463 throw new Error("initializeWasm() must be awaited first!");
14465 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_ok();
14466 return nativeResponseValue;
14468 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
14470 export function CResult_NonePeerHandleErrorZ_err(e: bigint): bigint {
14471 if(!isWasmInitialized) {
14472 throw new Error("initializeWasm() must be awaited first!");
14474 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_err(e);
14475 return nativeResponseValue;
14477 // bool CResult_NonePeerHandleErrorZ_is_ok(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR o);
14479 export function CResult_NonePeerHandleErrorZ_is_ok(o: bigint): boolean {
14480 if(!isWasmInitialized) {
14481 throw new Error("initializeWasm() must be awaited first!");
14483 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_is_ok(o);
14484 return nativeResponseValue;
14486 // void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
14488 export function CResult_NonePeerHandleErrorZ_free(_res: bigint): void {
14489 if(!isWasmInitialized) {
14490 throw new Error("initializeWasm() must be awaited first!");
14492 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_free(_res);
14493 // debug statements here
14495 // uint64_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg);
14497 export function CResult_NonePeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
14498 if(!isWasmInitialized) {
14499 throw new Error("initializeWasm() must be awaited first!");
14501 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone_ptr(arg);
14502 return nativeResponseValue;
14504 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
14506 export function CResult_NonePeerHandleErrorZ_clone(orig: bigint): bigint {
14507 if(!isWasmInitialized) {
14508 throw new Error("initializeWasm() must be awaited first!");
14510 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone(orig);
14511 return nativeResponseValue;
14513 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
14515 export function CResult_boolPeerHandleErrorZ_ok(o: boolean): bigint {
14516 if(!isWasmInitialized) {
14517 throw new Error("initializeWasm() must be awaited first!");
14519 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_ok(o);
14520 return nativeResponseValue;
14522 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
14524 export function CResult_boolPeerHandleErrorZ_err(e: bigint): bigint {
14525 if(!isWasmInitialized) {
14526 throw new Error("initializeWasm() must be awaited first!");
14528 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_err(e);
14529 return nativeResponseValue;
14531 // bool CResult_boolPeerHandleErrorZ_is_ok(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR o);
14533 export function CResult_boolPeerHandleErrorZ_is_ok(o: bigint): boolean {
14534 if(!isWasmInitialized) {
14535 throw new Error("initializeWasm() must be awaited first!");
14537 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_is_ok(o);
14538 return nativeResponseValue;
14540 // void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
14542 export function CResult_boolPeerHandleErrorZ_free(_res: bigint): void {
14543 if(!isWasmInitialized) {
14544 throw new Error("initializeWasm() must be awaited first!");
14546 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_free(_res);
14547 // debug statements here
14549 // uint64_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg);
14551 export function CResult_boolPeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
14552 if(!isWasmInitialized) {
14553 throw new Error("initializeWasm() must be awaited first!");
14555 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone_ptr(arg);
14556 return nativeResponseValue;
14558 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
14560 export function CResult_boolPeerHandleErrorZ_clone(orig: bigint): bigint {
14561 if(!isWasmInitialized) {
14562 throw new Error("initializeWasm() must be awaited first!");
14564 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone(orig);
14565 return nativeResponseValue;
14567 // struct LDKCResult_NoneSendErrorZ CResult_NoneSendErrorZ_ok(void);
14569 export function CResult_NoneSendErrorZ_ok(): bigint {
14570 if(!isWasmInitialized) {
14571 throw new Error("initializeWasm() must be awaited first!");
14573 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_ok();
14574 return nativeResponseValue;
14576 // struct LDKCResult_NoneSendErrorZ CResult_NoneSendErrorZ_err(struct LDKSendError e);
14578 export function CResult_NoneSendErrorZ_err(e: bigint): bigint {
14579 if(!isWasmInitialized) {
14580 throw new Error("initializeWasm() must be awaited first!");
14582 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_err(e);
14583 return nativeResponseValue;
14585 // bool CResult_NoneSendErrorZ_is_ok(const struct LDKCResult_NoneSendErrorZ *NONNULL_PTR o);
14587 export function CResult_NoneSendErrorZ_is_ok(o: bigint): boolean {
14588 if(!isWasmInitialized) {
14589 throw new Error("initializeWasm() must be awaited first!");
14591 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_is_ok(o);
14592 return nativeResponseValue;
14594 // void CResult_NoneSendErrorZ_free(struct LDKCResult_NoneSendErrorZ _res);
14596 export function CResult_NoneSendErrorZ_free(_res: bigint): void {
14597 if(!isWasmInitialized) {
14598 throw new Error("initializeWasm() must be awaited first!");
14600 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_free(_res);
14601 // debug statements here
14603 // struct LDKCResult_u32GraphSyncErrorZ CResult_u32GraphSyncErrorZ_ok(uint32_t o);
14605 export function CResult_u32GraphSyncErrorZ_ok(o: number): bigint {
14606 if(!isWasmInitialized) {
14607 throw new Error("initializeWasm() must be awaited first!");
14609 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_ok(o);
14610 return nativeResponseValue;
14612 // struct LDKCResult_u32GraphSyncErrorZ CResult_u32GraphSyncErrorZ_err(struct LDKGraphSyncError e);
14614 export function CResult_u32GraphSyncErrorZ_err(e: bigint): bigint {
14615 if(!isWasmInitialized) {
14616 throw new Error("initializeWasm() must be awaited first!");
14618 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_err(e);
14619 return nativeResponseValue;
14621 // bool CResult_u32GraphSyncErrorZ_is_ok(const struct LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR o);
14623 export function CResult_u32GraphSyncErrorZ_is_ok(o: bigint): boolean {
14624 if(!isWasmInitialized) {
14625 throw new Error("initializeWasm() must be awaited first!");
14627 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_is_ok(o);
14628 return nativeResponseValue;
14630 // void CResult_u32GraphSyncErrorZ_free(struct LDKCResult_u32GraphSyncErrorZ _res);
14632 export function CResult_u32GraphSyncErrorZ_free(_res: bigint): void {
14633 if(!isWasmInitialized) {
14634 throw new Error("initializeWasm() must be awaited first!");
14636 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_free(_res);
14637 // debug statements here
14639 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_ok(void);
14641 export function CResult_NoneErrorZ_ok(): bigint {
14642 if(!isWasmInitialized) {
14643 throw new Error("initializeWasm() must be awaited first!");
14645 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_ok();
14646 return nativeResponseValue;
14648 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_err(enum LDKIOError e);
14650 export function CResult_NoneErrorZ_err(e: IOError): bigint {
14651 if(!isWasmInitialized) {
14652 throw new Error("initializeWasm() must be awaited first!");
14654 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_err(e);
14655 return nativeResponseValue;
14657 // bool CResult_NoneErrorZ_is_ok(const struct LDKCResult_NoneErrorZ *NONNULL_PTR o);
14659 export function CResult_NoneErrorZ_is_ok(o: bigint): boolean {
14660 if(!isWasmInitialized) {
14661 throw new Error("initializeWasm() must be awaited first!");
14663 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_is_ok(o);
14664 return nativeResponseValue;
14666 // void CResult_NoneErrorZ_free(struct LDKCResult_NoneErrorZ _res);
14668 export function CResult_NoneErrorZ_free(_res: bigint): void {
14669 if(!isWasmInitialized) {
14670 throw new Error("initializeWasm() must be awaited first!");
14672 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_free(_res);
14673 // debug statements here
14675 // uint64_t CResult_NoneErrorZ_clone_ptr(LDKCResult_NoneErrorZ *NONNULL_PTR arg);
14677 export function CResult_NoneErrorZ_clone_ptr(arg: bigint): bigint {
14678 if(!isWasmInitialized) {
14679 throw new Error("initializeWasm() must be awaited first!");
14681 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone_ptr(arg);
14682 return nativeResponseValue;
14684 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_clone(const struct LDKCResult_NoneErrorZ *NONNULL_PTR orig);
14686 export function CResult_NoneErrorZ_clone(orig: bigint): bigint {
14687 if(!isWasmInitialized) {
14688 throw new Error("initializeWasm() must be awaited first!");
14690 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone(orig);
14691 return nativeResponseValue;
14693 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_ok(struct LDKNetAddress o);
14695 export function CResult_NetAddressDecodeErrorZ_ok(o: bigint): bigint {
14696 if(!isWasmInitialized) {
14697 throw new Error("initializeWasm() must be awaited first!");
14699 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_ok(o);
14700 return nativeResponseValue;
14702 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_err(struct LDKDecodeError e);
14704 export function CResult_NetAddressDecodeErrorZ_err(e: bigint): bigint {
14705 if(!isWasmInitialized) {
14706 throw new Error("initializeWasm() must be awaited first!");
14708 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_err(e);
14709 return nativeResponseValue;
14711 // bool CResult_NetAddressDecodeErrorZ_is_ok(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR o);
14713 export function CResult_NetAddressDecodeErrorZ_is_ok(o: bigint): boolean {
14714 if(!isWasmInitialized) {
14715 throw new Error("initializeWasm() must be awaited first!");
14717 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_is_ok(o);
14718 return nativeResponseValue;
14720 // void CResult_NetAddressDecodeErrorZ_free(struct LDKCResult_NetAddressDecodeErrorZ _res);
14722 export function CResult_NetAddressDecodeErrorZ_free(_res: bigint): void {
14723 if(!isWasmInitialized) {
14724 throw new Error("initializeWasm() must be awaited first!");
14726 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_free(_res);
14727 // debug statements here
14729 // uint64_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg);
14731 export function CResult_NetAddressDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14732 if(!isWasmInitialized) {
14733 throw new Error("initializeWasm() must be awaited first!");
14735 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone_ptr(arg);
14736 return nativeResponseValue;
14738 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_clone(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR orig);
14740 export function CResult_NetAddressDecodeErrorZ_clone(orig: bigint): bigint {
14741 if(!isWasmInitialized) {
14742 throw new Error("initializeWasm() must be awaited first!");
14744 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone(orig);
14745 return nativeResponseValue;
14747 // void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
14749 export function CVec_UpdateAddHTLCZ_free(_res: number): void {
14750 if(!isWasmInitialized) {
14751 throw new Error("initializeWasm() must be awaited first!");
14753 const nativeResponseValue = wasm.TS_CVec_UpdateAddHTLCZ_free(_res);
14754 // debug statements here
14756 // void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
14758 export function CVec_UpdateFulfillHTLCZ_free(_res: number): void {
14759 if(!isWasmInitialized) {
14760 throw new Error("initializeWasm() must be awaited first!");
14762 const nativeResponseValue = wasm.TS_CVec_UpdateFulfillHTLCZ_free(_res);
14763 // debug statements here
14765 // void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
14767 export function CVec_UpdateFailHTLCZ_free(_res: number): void {
14768 if(!isWasmInitialized) {
14769 throw new Error("initializeWasm() must be awaited first!");
14771 const nativeResponseValue = wasm.TS_CVec_UpdateFailHTLCZ_free(_res);
14772 // debug statements here
14774 // void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
14776 export function CVec_UpdateFailMalformedHTLCZ_free(_res: number): void {
14777 if(!isWasmInitialized) {
14778 throw new Error("initializeWasm() must be awaited first!");
14780 const nativeResponseValue = wasm.TS_CVec_UpdateFailMalformedHTLCZ_free(_res);
14781 // debug statements here
14783 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
14785 export function CResult_AcceptChannelDecodeErrorZ_ok(o: bigint): bigint {
14786 if(!isWasmInitialized) {
14787 throw new Error("initializeWasm() must be awaited first!");
14789 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_ok(o);
14790 return nativeResponseValue;
14792 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
14794 export function CResult_AcceptChannelDecodeErrorZ_err(e: bigint): bigint {
14795 if(!isWasmInitialized) {
14796 throw new Error("initializeWasm() must be awaited first!");
14798 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_err(e);
14799 return nativeResponseValue;
14801 // bool CResult_AcceptChannelDecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR o);
14803 export function CResult_AcceptChannelDecodeErrorZ_is_ok(o: bigint): boolean {
14804 if(!isWasmInitialized) {
14805 throw new Error("initializeWasm() must be awaited first!");
14807 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_is_ok(o);
14808 return nativeResponseValue;
14810 // void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
14812 export function CResult_AcceptChannelDecodeErrorZ_free(_res: bigint): void {
14813 if(!isWasmInitialized) {
14814 throw new Error("initializeWasm() must be awaited first!");
14816 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_free(_res);
14817 // debug statements here
14819 // uint64_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg);
14821 export function CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14822 if(!isWasmInitialized) {
14823 throw new Error("initializeWasm() must be awaited first!");
14825 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg);
14826 return nativeResponseValue;
14828 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
14830 export function CResult_AcceptChannelDecodeErrorZ_clone(orig: bigint): bigint {
14831 if(!isWasmInitialized) {
14832 throw new Error("initializeWasm() must be awaited first!");
14834 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone(orig);
14835 return nativeResponseValue;
14837 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
14839 export function CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: bigint): bigint {
14840 if(!isWasmInitialized) {
14841 throw new Error("initializeWasm() must be awaited first!");
14843 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(o);
14844 return nativeResponseValue;
14846 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
14848 export function CResult_AnnouncementSignaturesDecodeErrorZ_err(e: bigint): bigint {
14849 if(!isWasmInitialized) {
14850 throw new Error("initializeWasm() must be awaited first!");
14852 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(e);
14853 return nativeResponseValue;
14855 // bool CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR o);
14857 export function CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o: bigint): boolean {
14858 if(!isWasmInitialized) {
14859 throw new Error("initializeWasm() must be awaited first!");
14861 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o);
14862 return nativeResponseValue;
14864 // void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
14866 export function CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: bigint): void {
14867 if(!isWasmInitialized) {
14868 throw new Error("initializeWasm() must be awaited first!");
14870 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(_res);
14871 // debug statements here
14873 // uint64_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg);
14875 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14876 if(!isWasmInitialized) {
14877 throw new Error("initializeWasm() must be awaited first!");
14879 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg);
14880 return nativeResponseValue;
14882 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
14884 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: bigint): bigint {
14885 if(!isWasmInitialized) {
14886 throw new Error("initializeWasm() must be awaited first!");
14888 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig);
14889 return nativeResponseValue;
14891 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
14893 export function CResult_ChannelReestablishDecodeErrorZ_ok(o: bigint): bigint {
14894 if(!isWasmInitialized) {
14895 throw new Error("initializeWasm() must be awaited first!");
14897 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_ok(o);
14898 return nativeResponseValue;
14900 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
14902 export function CResult_ChannelReestablishDecodeErrorZ_err(e: bigint): bigint {
14903 if(!isWasmInitialized) {
14904 throw new Error("initializeWasm() must be awaited first!");
14906 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_err(e);
14907 return nativeResponseValue;
14909 // bool CResult_ChannelReestablishDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR o);
14911 export function CResult_ChannelReestablishDecodeErrorZ_is_ok(o: bigint): boolean {
14912 if(!isWasmInitialized) {
14913 throw new Error("initializeWasm() must be awaited first!");
14915 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(o);
14916 return nativeResponseValue;
14918 // void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
14920 export function CResult_ChannelReestablishDecodeErrorZ_free(_res: bigint): void {
14921 if(!isWasmInitialized) {
14922 throw new Error("initializeWasm() must be awaited first!");
14924 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_free(_res);
14925 // debug statements here
14927 // uint64_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg);
14929 export function CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14930 if(!isWasmInitialized) {
14931 throw new Error("initializeWasm() must be awaited first!");
14933 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg);
14934 return nativeResponseValue;
14936 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
14938 export function CResult_ChannelReestablishDecodeErrorZ_clone(orig: bigint): bigint {
14939 if(!isWasmInitialized) {
14940 throw new Error("initializeWasm() must be awaited first!");
14942 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone(orig);
14943 return nativeResponseValue;
14945 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
14947 export function CResult_ClosingSignedDecodeErrorZ_ok(o: bigint): bigint {
14948 if(!isWasmInitialized) {
14949 throw new Error("initializeWasm() must be awaited first!");
14951 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_ok(o);
14952 return nativeResponseValue;
14954 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
14956 export function CResult_ClosingSignedDecodeErrorZ_err(e: bigint): bigint {
14957 if(!isWasmInitialized) {
14958 throw new Error("initializeWasm() must be awaited first!");
14960 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_err(e);
14961 return nativeResponseValue;
14963 // bool CResult_ClosingSignedDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR o);
14965 export function CResult_ClosingSignedDecodeErrorZ_is_ok(o: bigint): boolean {
14966 if(!isWasmInitialized) {
14967 throw new Error("initializeWasm() must be awaited first!");
14969 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_is_ok(o);
14970 return nativeResponseValue;
14972 // void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
14974 export function CResult_ClosingSignedDecodeErrorZ_free(_res: bigint): void {
14975 if(!isWasmInitialized) {
14976 throw new Error("initializeWasm() must be awaited first!");
14978 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_free(_res);
14979 // debug statements here
14981 // uint64_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg);
14983 export function CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14984 if(!isWasmInitialized) {
14985 throw new Error("initializeWasm() must be awaited first!");
14987 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg);
14988 return nativeResponseValue;
14990 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
14992 export function CResult_ClosingSignedDecodeErrorZ_clone(orig: bigint): bigint {
14993 if(!isWasmInitialized) {
14994 throw new Error("initializeWasm() must be awaited first!");
14996 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone(orig);
14997 return nativeResponseValue;
14999 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(struct LDKClosingSignedFeeRange o);
15001 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o: bigint): bigint {
15002 if(!isWasmInitialized) {
15003 throw new Error("initializeWasm() must be awaited first!");
15005 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o);
15006 return nativeResponseValue;
15008 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_err(struct LDKDecodeError e);
15010 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e: bigint): bigint {
15011 if(!isWasmInitialized) {
15012 throw new Error("initializeWasm() must be awaited first!");
15014 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e);
15015 return nativeResponseValue;
15017 // bool CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR o);
15019 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o: bigint): boolean {
15020 if(!isWasmInitialized) {
15021 throw new Error("initializeWasm() must be awaited first!");
15023 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o);
15024 return nativeResponseValue;
15026 // void CResult_ClosingSignedFeeRangeDecodeErrorZ_free(struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res);
15028 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res: bigint): void {
15029 if(!isWasmInitialized) {
15030 throw new Error("initializeWasm() must be awaited first!");
15032 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res);
15033 // debug statements here
15035 // uint64_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg);
15037 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15038 if(!isWasmInitialized) {
15039 throw new Error("initializeWasm() must be awaited first!");
15041 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg);
15042 return nativeResponseValue;
15044 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR orig);
15046 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig: bigint): bigint {
15047 if(!isWasmInitialized) {
15048 throw new Error("initializeWasm() must be awaited first!");
15050 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig);
15051 return nativeResponseValue;
15053 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
15055 export function CResult_CommitmentSignedDecodeErrorZ_ok(o: bigint): bigint {
15056 if(!isWasmInitialized) {
15057 throw new Error("initializeWasm() must be awaited first!");
15059 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_ok(o);
15060 return nativeResponseValue;
15062 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
15064 export function CResult_CommitmentSignedDecodeErrorZ_err(e: bigint): bigint {
15065 if(!isWasmInitialized) {
15066 throw new Error("initializeWasm() must be awaited first!");
15068 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_err(e);
15069 return nativeResponseValue;
15071 // bool CResult_CommitmentSignedDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR o);
15073 export function CResult_CommitmentSignedDecodeErrorZ_is_ok(o: bigint): boolean {
15074 if(!isWasmInitialized) {
15075 throw new Error("initializeWasm() must be awaited first!");
15077 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(o);
15078 return nativeResponseValue;
15080 // void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
15082 export function CResult_CommitmentSignedDecodeErrorZ_free(_res: bigint): void {
15083 if(!isWasmInitialized) {
15084 throw new Error("initializeWasm() must be awaited first!");
15086 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_free(_res);
15087 // debug statements here
15089 // uint64_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg);
15091 export function CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15092 if(!isWasmInitialized) {
15093 throw new Error("initializeWasm() must be awaited first!");
15095 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg);
15096 return nativeResponseValue;
15098 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
15100 export function CResult_CommitmentSignedDecodeErrorZ_clone(orig: bigint): bigint {
15101 if(!isWasmInitialized) {
15102 throw new Error("initializeWasm() must be awaited first!");
15104 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone(orig);
15105 return nativeResponseValue;
15107 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
15109 export function CResult_FundingCreatedDecodeErrorZ_ok(o: bigint): bigint {
15110 if(!isWasmInitialized) {
15111 throw new Error("initializeWasm() must be awaited first!");
15113 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_ok(o);
15114 return nativeResponseValue;
15116 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
15118 export function CResult_FundingCreatedDecodeErrorZ_err(e: bigint): bigint {
15119 if(!isWasmInitialized) {
15120 throw new Error("initializeWasm() must be awaited first!");
15122 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_err(e);
15123 return nativeResponseValue;
15125 // bool CResult_FundingCreatedDecodeErrorZ_is_ok(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR o);
15127 export function CResult_FundingCreatedDecodeErrorZ_is_ok(o: bigint): boolean {
15128 if(!isWasmInitialized) {
15129 throw new Error("initializeWasm() must be awaited first!");
15131 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_is_ok(o);
15132 return nativeResponseValue;
15134 // void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
15136 export function CResult_FundingCreatedDecodeErrorZ_free(_res: bigint): void {
15137 if(!isWasmInitialized) {
15138 throw new Error("initializeWasm() must be awaited first!");
15140 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_free(_res);
15141 // debug statements here
15143 // uint64_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg);
15145 export function CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15146 if(!isWasmInitialized) {
15147 throw new Error("initializeWasm() must be awaited first!");
15149 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg);
15150 return nativeResponseValue;
15152 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
15154 export function CResult_FundingCreatedDecodeErrorZ_clone(orig: bigint): bigint {
15155 if(!isWasmInitialized) {
15156 throw new Error("initializeWasm() must be awaited first!");
15158 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone(orig);
15159 return nativeResponseValue;
15161 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
15163 export function CResult_FundingSignedDecodeErrorZ_ok(o: bigint): bigint {
15164 if(!isWasmInitialized) {
15165 throw new Error("initializeWasm() must be awaited first!");
15167 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_ok(o);
15168 return nativeResponseValue;
15170 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
15172 export function CResult_FundingSignedDecodeErrorZ_err(e: bigint): bigint {
15173 if(!isWasmInitialized) {
15174 throw new Error("initializeWasm() must be awaited first!");
15176 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_err(e);
15177 return nativeResponseValue;
15179 // bool CResult_FundingSignedDecodeErrorZ_is_ok(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR o);
15181 export function CResult_FundingSignedDecodeErrorZ_is_ok(o: bigint): boolean {
15182 if(!isWasmInitialized) {
15183 throw new Error("initializeWasm() must be awaited first!");
15185 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_is_ok(o);
15186 return nativeResponseValue;
15188 // void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
15190 export function CResult_FundingSignedDecodeErrorZ_free(_res: bigint): void {
15191 if(!isWasmInitialized) {
15192 throw new Error("initializeWasm() must be awaited first!");
15194 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_free(_res);
15195 // debug statements here
15197 // uint64_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg);
15199 export function CResult_FundingSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15200 if(!isWasmInitialized) {
15201 throw new Error("initializeWasm() must be awaited first!");
15203 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(arg);
15204 return nativeResponseValue;
15206 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
15208 export function CResult_FundingSignedDecodeErrorZ_clone(orig: bigint): bigint {
15209 if(!isWasmInitialized) {
15210 throw new Error("initializeWasm() must be awaited first!");
15212 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone(orig);
15213 return nativeResponseValue;
15215 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_ok(struct LDKChannelReady o);
15217 export function CResult_ChannelReadyDecodeErrorZ_ok(o: bigint): bigint {
15218 if(!isWasmInitialized) {
15219 throw new Error("initializeWasm() must be awaited first!");
15221 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_ok(o);
15222 return nativeResponseValue;
15224 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_err(struct LDKDecodeError e);
15226 export function CResult_ChannelReadyDecodeErrorZ_err(e: bigint): bigint {
15227 if(!isWasmInitialized) {
15228 throw new Error("initializeWasm() must be awaited first!");
15230 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_err(e);
15231 return nativeResponseValue;
15233 // bool CResult_ChannelReadyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR o);
15235 export function CResult_ChannelReadyDecodeErrorZ_is_ok(o: bigint): boolean {
15236 if(!isWasmInitialized) {
15237 throw new Error("initializeWasm() must be awaited first!");
15239 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_is_ok(o);
15240 return nativeResponseValue;
15242 // void CResult_ChannelReadyDecodeErrorZ_free(struct LDKCResult_ChannelReadyDecodeErrorZ _res);
15244 export function CResult_ChannelReadyDecodeErrorZ_free(_res: bigint): void {
15245 if(!isWasmInitialized) {
15246 throw new Error("initializeWasm() must be awaited first!");
15248 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_free(_res);
15249 // debug statements here
15251 // uint64_t CResult_ChannelReadyDecodeErrorZ_clone_ptr(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR arg);
15253 export function CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15254 if(!isWasmInitialized) {
15255 throw new Error("initializeWasm() must be awaited first!");
15257 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg);
15258 return nativeResponseValue;
15260 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_clone(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR orig);
15262 export function CResult_ChannelReadyDecodeErrorZ_clone(orig: bigint): bigint {
15263 if(!isWasmInitialized) {
15264 throw new Error("initializeWasm() must be awaited first!");
15266 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone(orig);
15267 return nativeResponseValue;
15269 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
15271 export function CResult_InitDecodeErrorZ_ok(o: bigint): bigint {
15272 if(!isWasmInitialized) {
15273 throw new Error("initializeWasm() must be awaited first!");
15275 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_ok(o);
15276 return nativeResponseValue;
15278 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
15280 export function CResult_InitDecodeErrorZ_err(e: bigint): bigint {
15281 if(!isWasmInitialized) {
15282 throw new Error("initializeWasm() must be awaited first!");
15284 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_err(e);
15285 return nativeResponseValue;
15287 // bool CResult_InitDecodeErrorZ_is_ok(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR o);
15289 export function CResult_InitDecodeErrorZ_is_ok(o: bigint): boolean {
15290 if(!isWasmInitialized) {
15291 throw new Error("initializeWasm() must be awaited first!");
15293 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_is_ok(o);
15294 return nativeResponseValue;
15296 // void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
15298 export function CResult_InitDecodeErrorZ_free(_res: bigint): void {
15299 if(!isWasmInitialized) {
15300 throw new Error("initializeWasm() must be awaited first!");
15302 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_free(_res);
15303 // debug statements here
15305 // uint64_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg);
15307 export function CResult_InitDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15308 if(!isWasmInitialized) {
15309 throw new Error("initializeWasm() must be awaited first!");
15311 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone_ptr(arg);
15312 return nativeResponseValue;
15314 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
15316 export function CResult_InitDecodeErrorZ_clone(orig: bigint): bigint {
15317 if(!isWasmInitialized) {
15318 throw new Error("initializeWasm() must be awaited first!");
15320 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone(orig);
15321 return nativeResponseValue;
15323 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
15325 export function CResult_OpenChannelDecodeErrorZ_ok(o: bigint): bigint {
15326 if(!isWasmInitialized) {
15327 throw new Error("initializeWasm() must be awaited first!");
15329 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_ok(o);
15330 return nativeResponseValue;
15332 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
15334 export function CResult_OpenChannelDecodeErrorZ_err(e: bigint): bigint {
15335 if(!isWasmInitialized) {
15336 throw new Error("initializeWasm() must be awaited first!");
15338 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_err(e);
15339 return nativeResponseValue;
15341 // bool CResult_OpenChannelDecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR o);
15343 export function CResult_OpenChannelDecodeErrorZ_is_ok(o: bigint): boolean {
15344 if(!isWasmInitialized) {
15345 throw new Error("initializeWasm() must be awaited first!");
15347 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_is_ok(o);
15348 return nativeResponseValue;
15350 // void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
15352 export function CResult_OpenChannelDecodeErrorZ_free(_res: bigint): void {
15353 if(!isWasmInitialized) {
15354 throw new Error("initializeWasm() must be awaited first!");
15356 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_free(_res);
15357 // debug statements here
15359 // uint64_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg);
15361 export function CResult_OpenChannelDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15362 if(!isWasmInitialized) {
15363 throw new Error("initializeWasm() must be awaited first!");
15365 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(arg);
15366 return nativeResponseValue;
15368 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
15370 export function CResult_OpenChannelDecodeErrorZ_clone(orig: bigint): bigint {
15371 if(!isWasmInitialized) {
15372 throw new Error("initializeWasm() must be awaited first!");
15374 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone(orig);
15375 return nativeResponseValue;
15377 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
15379 export function CResult_RevokeAndACKDecodeErrorZ_ok(o: bigint): bigint {
15380 if(!isWasmInitialized) {
15381 throw new Error("initializeWasm() must be awaited first!");
15383 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_ok(o);
15384 return nativeResponseValue;
15386 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
15388 export function CResult_RevokeAndACKDecodeErrorZ_err(e: bigint): bigint {
15389 if(!isWasmInitialized) {
15390 throw new Error("initializeWasm() must be awaited first!");
15392 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_err(e);
15393 return nativeResponseValue;
15395 // bool CResult_RevokeAndACKDecodeErrorZ_is_ok(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR o);
15397 export function CResult_RevokeAndACKDecodeErrorZ_is_ok(o: bigint): boolean {
15398 if(!isWasmInitialized) {
15399 throw new Error("initializeWasm() must be awaited first!");
15401 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(o);
15402 return nativeResponseValue;
15404 // void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
15406 export function CResult_RevokeAndACKDecodeErrorZ_free(_res: bigint): void {
15407 if(!isWasmInitialized) {
15408 throw new Error("initializeWasm() must be awaited first!");
15410 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_free(_res);
15411 // debug statements here
15413 // uint64_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg);
15415 export function CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15416 if(!isWasmInitialized) {
15417 throw new Error("initializeWasm() must be awaited first!");
15419 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg);
15420 return nativeResponseValue;
15422 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
15424 export function CResult_RevokeAndACKDecodeErrorZ_clone(orig: bigint): bigint {
15425 if(!isWasmInitialized) {
15426 throw new Error("initializeWasm() must be awaited first!");
15428 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone(orig);
15429 return nativeResponseValue;
15431 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
15433 export function CResult_ShutdownDecodeErrorZ_ok(o: bigint): bigint {
15434 if(!isWasmInitialized) {
15435 throw new Error("initializeWasm() must be awaited first!");
15437 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_ok(o);
15438 return nativeResponseValue;
15440 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
15442 export function CResult_ShutdownDecodeErrorZ_err(e: bigint): bigint {
15443 if(!isWasmInitialized) {
15444 throw new Error("initializeWasm() must be awaited first!");
15446 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_err(e);
15447 return nativeResponseValue;
15449 // bool CResult_ShutdownDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR o);
15451 export function CResult_ShutdownDecodeErrorZ_is_ok(o: bigint): boolean {
15452 if(!isWasmInitialized) {
15453 throw new Error("initializeWasm() must be awaited first!");
15455 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_is_ok(o);
15456 return nativeResponseValue;
15458 // void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
15460 export function CResult_ShutdownDecodeErrorZ_free(_res: bigint): void {
15461 if(!isWasmInitialized) {
15462 throw new Error("initializeWasm() must be awaited first!");
15464 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_free(_res);
15465 // debug statements here
15467 // uint64_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg);
15469 export function CResult_ShutdownDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15470 if(!isWasmInitialized) {
15471 throw new Error("initializeWasm() must be awaited first!");
15473 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone_ptr(arg);
15474 return nativeResponseValue;
15476 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
15478 export function CResult_ShutdownDecodeErrorZ_clone(orig: bigint): bigint {
15479 if(!isWasmInitialized) {
15480 throw new Error("initializeWasm() must be awaited first!");
15482 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone(orig);
15483 return nativeResponseValue;
15485 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
15487 export function CResult_UpdateFailHTLCDecodeErrorZ_ok(o: bigint): bigint {
15488 if(!isWasmInitialized) {
15489 throw new Error("initializeWasm() must be awaited first!");
15491 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(o);
15492 return nativeResponseValue;
15494 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
15496 export function CResult_UpdateFailHTLCDecodeErrorZ_err(e: bigint): bigint {
15497 if(!isWasmInitialized) {
15498 throw new Error("initializeWasm() must be awaited first!");
15500 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_err(e);
15501 return nativeResponseValue;
15503 // bool CResult_UpdateFailHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR o);
15505 export function CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
15506 if(!isWasmInitialized) {
15507 throw new Error("initializeWasm() must be awaited first!");
15509 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o);
15510 return nativeResponseValue;
15512 // void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
15514 export function CResult_UpdateFailHTLCDecodeErrorZ_free(_res: bigint): void {
15515 if(!isWasmInitialized) {
15516 throw new Error("initializeWasm() must be awaited first!");
15518 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_free(_res);
15519 // debug statements here
15521 // uint64_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg);
15523 export function CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15524 if(!isWasmInitialized) {
15525 throw new Error("initializeWasm() must be awaited first!");
15527 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg);
15528 return nativeResponseValue;
15530 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
15532 export function CResult_UpdateFailHTLCDecodeErrorZ_clone(orig: bigint): bigint {
15533 if(!isWasmInitialized) {
15534 throw new Error("initializeWasm() must be awaited first!");
15536 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(orig);
15537 return nativeResponseValue;
15539 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
15541 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o: bigint): bigint {
15542 if(!isWasmInitialized) {
15543 throw new Error("initializeWasm() must be awaited first!");
15545 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o);
15546 return nativeResponseValue;
15548 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
15550 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e: bigint): bigint {
15551 if(!isWasmInitialized) {
15552 throw new Error("initializeWasm() must be awaited first!");
15554 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e);
15555 return nativeResponseValue;
15557 // bool CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR o);
15559 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
15560 if(!isWasmInitialized) {
15561 throw new Error("initializeWasm() must be awaited first!");
15563 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o);
15564 return nativeResponseValue;
15566 // void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
15568 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res: bigint): void {
15569 if(!isWasmInitialized) {
15570 throw new Error("initializeWasm() must be awaited first!");
15572 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res);
15573 // debug statements here
15575 // uint64_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg);
15577 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15578 if(!isWasmInitialized) {
15579 throw new Error("initializeWasm() must be awaited first!");
15581 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg);
15582 return nativeResponseValue;
15584 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
15586 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig: bigint): bigint {
15587 if(!isWasmInitialized) {
15588 throw new Error("initializeWasm() must be awaited first!");
15590 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig);
15591 return nativeResponseValue;
15593 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
15595 export function CResult_UpdateFeeDecodeErrorZ_ok(o: bigint): bigint {
15596 if(!isWasmInitialized) {
15597 throw new Error("initializeWasm() must be awaited first!");
15599 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_ok(o);
15600 return nativeResponseValue;
15602 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
15604 export function CResult_UpdateFeeDecodeErrorZ_err(e: bigint): bigint {
15605 if(!isWasmInitialized) {
15606 throw new Error("initializeWasm() must be awaited first!");
15608 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_err(e);
15609 return nativeResponseValue;
15611 // bool CResult_UpdateFeeDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR o);
15613 export function CResult_UpdateFeeDecodeErrorZ_is_ok(o: bigint): boolean {
15614 if(!isWasmInitialized) {
15615 throw new Error("initializeWasm() must be awaited first!");
15617 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_is_ok(o);
15618 return nativeResponseValue;
15620 // void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
15622 export function CResult_UpdateFeeDecodeErrorZ_free(_res: bigint): void {
15623 if(!isWasmInitialized) {
15624 throw new Error("initializeWasm() must be awaited first!");
15626 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_free(_res);
15627 // debug statements here
15629 // uint64_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg);
15631 export function CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15632 if(!isWasmInitialized) {
15633 throw new Error("initializeWasm() must be awaited first!");
15635 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg);
15636 return nativeResponseValue;
15638 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
15640 export function CResult_UpdateFeeDecodeErrorZ_clone(orig: bigint): bigint {
15641 if(!isWasmInitialized) {
15642 throw new Error("initializeWasm() must be awaited first!");
15644 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone(orig);
15645 return nativeResponseValue;
15647 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
15649 export function CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o: bigint): bigint {
15650 if(!isWasmInitialized) {
15651 throw new Error("initializeWasm() must be awaited first!");
15653 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o);
15654 return nativeResponseValue;
15656 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
15658 export function CResult_UpdateFulfillHTLCDecodeErrorZ_err(e: bigint): bigint {
15659 if(!isWasmInitialized) {
15660 throw new Error("initializeWasm() must be awaited first!");
15662 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(e);
15663 return nativeResponseValue;
15665 // bool CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR o);
15667 export function CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
15668 if(!isWasmInitialized) {
15669 throw new Error("initializeWasm() must be awaited first!");
15671 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o);
15672 return nativeResponseValue;
15674 // void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
15676 export function CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res: bigint): void {
15677 if(!isWasmInitialized) {
15678 throw new Error("initializeWasm() must be awaited first!");
15680 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res);
15681 // debug statements here
15683 // uint64_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg);
15685 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15686 if(!isWasmInitialized) {
15687 throw new Error("initializeWasm() must be awaited first!");
15689 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg);
15690 return nativeResponseValue;
15692 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
15694 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig: bigint): bigint {
15695 if(!isWasmInitialized) {
15696 throw new Error("initializeWasm() must be awaited first!");
15698 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig);
15699 return nativeResponseValue;
15701 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
15703 export function CResult_UpdateAddHTLCDecodeErrorZ_ok(o: bigint): bigint {
15704 if(!isWasmInitialized) {
15705 throw new Error("initializeWasm() must be awaited first!");
15707 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(o);
15708 return nativeResponseValue;
15710 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
15712 export function CResult_UpdateAddHTLCDecodeErrorZ_err(e: bigint): bigint {
15713 if(!isWasmInitialized) {
15714 throw new Error("initializeWasm() must be awaited first!");
15716 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_err(e);
15717 return nativeResponseValue;
15719 // bool CResult_UpdateAddHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR o);
15721 export function CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
15722 if(!isWasmInitialized) {
15723 throw new Error("initializeWasm() must be awaited first!");
15725 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o);
15726 return nativeResponseValue;
15728 // void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
15730 export function CResult_UpdateAddHTLCDecodeErrorZ_free(_res: bigint): void {
15731 if(!isWasmInitialized) {
15732 throw new Error("initializeWasm() must be awaited first!");
15734 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_free(_res);
15735 // debug statements here
15737 // uint64_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg);
15739 export function CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15740 if(!isWasmInitialized) {
15741 throw new Error("initializeWasm() must be awaited first!");
15743 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg);
15744 return nativeResponseValue;
15746 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
15748 export function CResult_UpdateAddHTLCDecodeErrorZ_clone(orig: bigint): bigint {
15749 if(!isWasmInitialized) {
15750 throw new Error("initializeWasm() must be awaited first!");
15752 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(orig);
15753 return nativeResponseValue;
15755 // struct LDKCResult_OnionMessageDecodeErrorZ CResult_OnionMessageDecodeErrorZ_ok(struct LDKOnionMessage o);
15757 export function CResult_OnionMessageDecodeErrorZ_ok(o: bigint): bigint {
15758 if(!isWasmInitialized) {
15759 throw new Error("initializeWasm() must be awaited first!");
15761 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_ok(o);
15762 return nativeResponseValue;
15764 // struct LDKCResult_OnionMessageDecodeErrorZ CResult_OnionMessageDecodeErrorZ_err(struct LDKDecodeError e);
15766 export function CResult_OnionMessageDecodeErrorZ_err(e: bigint): bigint {
15767 if(!isWasmInitialized) {
15768 throw new Error("initializeWasm() must be awaited first!");
15770 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_err(e);
15771 return nativeResponseValue;
15773 // bool CResult_OnionMessageDecodeErrorZ_is_ok(const struct LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR o);
15775 export function CResult_OnionMessageDecodeErrorZ_is_ok(o: bigint): boolean {
15776 if(!isWasmInitialized) {
15777 throw new Error("initializeWasm() must be awaited first!");
15779 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_is_ok(o);
15780 return nativeResponseValue;
15782 // void CResult_OnionMessageDecodeErrorZ_free(struct LDKCResult_OnionMessageDecodeErrorZ _res);
15784 export function CResult_OnionMessageDecodeErrorZ_free(_res: bigint): void {
15785 if(!isWasmInitialized) {
15786 throw new Error("initializeWasm() must be awaited first!");
15788 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_free(_res);
15789 // debug statements here
15791 // uint64_t CResult_OnionMessageDecodeErrorZ_clone_ptr(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR arg);
15793 export function CResult_OnionMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15794 if(!isWasmInitialized) {
15795 throw new Error("initializeWasm() must be awaited first!");
15797 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_clone_ptr(arg);
15798 return nativeResponseValue;
15800 // struct LDKCResult_OnionMessageDecodeErrorZ CResult_OnionMessageDecodeErrorZ_clone(const struct LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR orig);
15802 export function CResult_OnionMessageDecodeErrorZ_clone(orig: bigint): bigint {
15803 if(!isWasmInitialized) {
15804 throw new Error("initializeWasm() must be awaited first!");
15806 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_clone(orig);
15807 return nativeResponseValue;
15809 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
15811 export function CResult_PingDecodeErrorZ_ok(o: bigint): bigint {
15812 if(!isWasmInitialized) {
15813 throw new Error("initializeWasm() must be awaited first!");
15815 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_ok(o);
15816 return nativeResponseValue;
15818 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
15820 export function CResult_PingDecodeErrorZ_err(e: bigint): bigint {
15821 if(!isWasmInitialized) {
15822 throw new Error("initializeWasm() must be awaited first!");
15824 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_err(e);
15825 return nativeResponseValue;
15827 // bool CResult_PingDecodeErrorZ_is_ok(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR o);
15829 export function CResult_PingDecodeErrorZ_is_ok(o: bigint): boolean {
15830 if(!isWasmInitialized) {
15831 throw new Error("initializeWasm() must be awaited first!");
15833 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_is_ok(o);
15834 return nativeResponseValue;
15836 // void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
15838 export function CResult_PingDecodeErrorZ_free(_res: bigint): void {
15839 if(!isWasmInitialized) {
15840 throw new Error("initializeWasm() must be awaited first!");
15842 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_free(_res);
15843 // debug statements here
15845 // uint64_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg);
15847 export function CResult_PingDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15848 if(!isWasmInitialized) {
15849 throw new Error("initializeWasm() must be awaited first!");
15851 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone_ptr(arg);
15852 return nativeResponseValue;
15854 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
15856 export function CResult_PingDecodeErrorZ_clone(orig: bigint): bigint {
15857 if(!isWasmInitialized) {
15858 throw new Error("initializeWasm() must be awaited first!");
15860 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone(orig);
15861 return nativeResponseValue;
15863 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
15865 export function CResult_PongDecodeErrorZ_ok(o: bigint): bigint {
15866 if(!isWasmInitialized) {
15867 throw new Error("initializeWasm() must be awaited first!");
15869 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_ok(o);
15870 return nativeResponseValue;
15872 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
15874 export function CResult_PongDecodeErrorZ_err(e: bigint): bigint {
15875 if(!isWasmInitialized) {
15876 throw new Error("initializeWasm() must be awaited first!");
15878 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_err(e);
15879 return nativeResponseValue;
15881 // bool CResult_PongDecodeErrorZ_is_ok(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR o);
15883 export function CResult_PongDecodeErrorZ_is_ok(o: bigint): boolean {
15884 if(!isWasmInitialized) {
15885 throw new Error("initializeWasm() must be awaited first!");
15887 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_is_ok(o);
15888 return nativeResponseValue;
15890 // void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
15892 export function CResult_PongDecodeErrorZ_free(_res: bigint): void {
15893 if(!isWasmInitialized) {
15894 throw new Error("initializeWasm() must be awaited first!");
15896 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_free(_res);
15897 // debug statements here
15899 // uint64_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg);
15901 export function CResult_PongDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15902 if(!isWasmInitialized) {
15903 throw new Error("initializeWasm() must be awaited first!");
15905 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone_ptr(arg);
15906 return nativeResponseValue;
15908 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
15910 export function CResult_PongDecodeErrorZ_clone(orig: bigint): bigint {
15911 if(!isWasmInitialized) {
15912 throw new Error("initializeWasm() must be awaited first!");
15914 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone(orig);
15915 return nativeResponseValue;
15917 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
15919 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
15920 if(!isWasmInitialized) {
15921 throw new Error("initializeWasm() must be awaited first!");
15923 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o);
15924 return nativeResponseValue;
15926 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
15928 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e: bigint): bigint {
15929 if(!isWasmInitialized) {
15930 throw new Error("initializeWasm() must be awaited first!");
15932 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e);
15933 return nativeResponseValue;
15935 // bool CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
15937 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
15938 if(!isWasmInitialized) {
15939 throw new Error("initializeWasm() must be awaited first!");
15941 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o);
15942 return nativeResponseValue;
15944 // void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
15946 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res: bigint): void {
15947 if(!isWasmInitialized) {
15948 throw new Error("initializeWasm() must be awaited first!");
15950 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res);
15951 // debug statements here
15953 // uint64_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
15955 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15956 if(!isWasmInitialized) {
15957 throw new Error("initializeWasm() must be awaited first!");
15959 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
15960 return nativeResponseValue;
15962 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
15964 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
15965 if(!isWasmInitialized) {
15966 throw new Error("initializeWasm() must be awaited first!");
15968 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig);
15969 return nativeResponseValue;
15971 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
15973 export function CResult_ChannelAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
15974 if(!isWasmInitialized) {
15975 throw new Error("initializeWasm() must be awaited first!");
15977 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(o);
15978 return nativeResponseValue;
15980 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
15982 export function CResult_ChannelAnnouncementDecodeErrorZ_err(e: bigint): bigint {
15983 if(!isWasmInitialized) {
15984 throw new Error("initializeWasm() must be awaited first!");
15986 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_err(e);
15987 return nativeResponseValue;
15989 // bool CResult_ChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
15991 export function CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
15992 if(!isWasmInitialized) {
15993 throw new Error("initializeWasm() must be awaited first!");
15995 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o);
15996 return nativeResponseValue;
15998 // void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
16000 export function CResult_ChannelAnnouncementDecodeErrorZ_free(_res: bigint): void {
16001 if(!isWasmInitialized) {
16002 throw new Error("initializeWasm() must be awaited first!");
16004 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_free(_res);
16005 // debug statements here
16007 // uint64_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
16009 export function CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16010 if(!isWasmInitialized) {
16011 throw new Error("initializeWasm() must be awaited first!");
16013 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
16014 return nativeResponseValue;
16016 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
16018 export function CResult_ChannelAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
16019 if(!isWasmInitialized) {
16020 throw new Error("initializeWasm() must be awaited first!");
16022 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(orig);
16023 return nativeResponseValue;
16025 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
16027 export function CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o: bigint): bigint {
16028 if(!isWasmInitialized) {
16029 throw new Error("initializeWasm() must be awaited first!");
16031 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o);
16032 return nativeResponseValue;
16034 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
16036 export function CResult_UnsignedChannelUpdateDecodeErrorZ_err(e: bigint): bigint {
16037 if(!isWasmInitialized) {
16038 throw new Error("initializeWasm() must be awaited first!");
16040 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(e);
16041 return nativeResponseValue;
16043 // bool CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR o);
16045 export function CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
16046 if(!isWasmInitialized) {
16047 throw new Error("initializeWasm() must be awaited first!");
16049 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o);
16050 return nativeResponseValue;
16052 // void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
16054 export function CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res: bigint): void {
16055 if(!isWasmInitialized) {
16056 throw new Error("initializeWasm() must be awaited first!");
16058 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res);
16059 // debug statements here
16061 // uint64_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
16063 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16064 if(!isWasmInitialized) {
16065 throw new Error("initializeWasm() must be awaited first!");
16067 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg);
16068 return nativeResponseValue;
16070 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
16072 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig: bigint): bigint {
16073 if(!isWasmInitialized) {
16074 throw new Error("initializeWasm() must be awaited first!");
16076 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig);
16077 return nativeResponseValue;
16079 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
16081 export function CResult_ChannelUpdateDecodeErrorZ_ok(o: bigint): bigint {
16082 if(!isWasmInitialized) {
16083 throw new Error("initializeWasm() must be awaited first!");
16085 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_ok(o);
16086 return nativeResponseValue;
16088 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
16090 export function CResult_ChannelUpdateDecodeErrorZ_err(e: bigint): bigint {
16091 if(!isWasmInitialized) {
16092 throw new Error("initializeWasm() must be awaited first!");
16094 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_err(e);
16095 return nativeResponseValue;
16097 // bool CResult_ChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR o);
16099 export function CResult_ChannelUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
16100 if(!isWasmInitialized) {
16101 throw new Error("initializeWasm() must be awaited first!");
16103 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(o);
16104 return nativeResponseValue;
16106 // void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
16108 export function CResult_ChannelUpdateDecodeErrorZ_free(_res: bigint): void {
16109 if(!isWasmInitialized) {
16110 throw new Error("initializeWasm() must be awaited first!");
16112 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_free(_res);
16113 // debug statements here
16115 // uint64_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
16117 export function CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16118 if(!isWasmInitialized) {
16119 throw new Error("initializeWasm() must be awaited first!");
16121 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg);
16122 return nativeResponseValue;
16124 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
16126 export function CResult_ChannelUpdateDecodeErrorZ_clone(orig: bigint): bigint {
16127 if(!isWasmInitialized) {
16128 throw new Error("initializeWasm() must be awaited first!");
16130 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone(orig);
16131 return nativeResponseValue;
16133 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
16135 export function CResult_ErrorMessageDecodeErrorZ_ok(o: bigint): bigint {
16136 if(!isWasmInitialized) {
16137 throw new Error("initializeWasm() must be awaited first!");
16139 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_ok(o);
16140 return nativeResponseValue;
16142 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
16144 export function CResult_ErrorMessageDecodeErrorZ_err(e: bigint): bigint {
16145 if(!isWasmInitialized) {
16146 throw new Error("initializeWasm() must be awaited first!");
16148 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_err(e);
16149 return nativeResponseValue;
16151 // bool CResult_ErrorMessageDecodeErrorZ_is_ok(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR o);
16153 export function CResult_ErrorMessageDecodeErrorZ_is_ok(o: bigint): boolean {
16154 if(!isWasmInitialized) {
16155 throw new Error("initializeWasm() must be awaited first!");
16157 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_is_ok(o);
16158 return nativeResponseValue;
16160 // void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
16162 export function CResult_ErrorMessageDecodeErrorZ_free(_res: bigint): void {
16163 if(!isWasmInitialized) {
16164 throw new Error("initializeWasm() must be awaited first!");
16166 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_free(_res);
16167 // debug statements here
16169 // uint64_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg);
16171 export function CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16172 if(!isWasmInitialized) {
16173 throw new Error("initializeWasm() must be awaited first!");
16175 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg);
16176 return nativeResponseValue;
16178 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
16180 export function CResult_ErrorMessageDecodeErrorZ_clone(orig: bigint): bigint {
16181 if(!isWasmInitialized) {
16182 throw new Error("initializeWasm() must be awaited first!");
16184 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone(orig);
16185 return nativeResponseValue;
16187 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_ok(struct LDKWarningMessage o);
16189 export function CResult_WarningMessageDecodeErrorZ_ok(o: bigint): bigint {
16190 if(!isWasmInitialized) {
16191 throw new Error("initializeWasm() must be awaited first!");
16193 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_ok(o);
16194 return nativeResponseValue;
16196 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_err(struct LDKDecodeError e);
16198 export function CResult_WarningMessageDecodeErrorZ_err(e: bigint): bigint {
16199 if(!isWasmInitialized) {
16200 throw new Error("initializeWasm() must be awaited first!");
16202 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_err(e);
16203 return nativeResponseValue;
16205 // bool CResult_WarningMessageDecodeErrorZ_is_ok(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR o);
16207 export function CResult_WarningMessageDecodeErrorZ_is_ok(o: bigint): boolean {
16208 if(!isWasmInitialized) {
16209 throw new Error("initializeWasm() must be awaited first!");
16211 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_is_ok(o);
16212 return nativeResponseValue;
16214 // void CResult_WarningMessageDecodeErrorZ_free(struct LDKCResult_WarningMessageDecodeErrorZ _res);
16216 export function CResult_WarningMessageDecodeErrorZ_free(_res: bigint): void {
16217 if(!isWasmInitialized) {
16218 throw new Error("initializeWasm() must be awaited first!");
16220 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_free(_res);
16221 // debug statements here
16223 // uint64_t CResult_WarningMessageDecodeErrorZ_clone_ptr(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR arg);
16225 export function CResult_WarningMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16226 if(!isWasmInitialized) {
16227 throw new Error("initializeWasm() must be awaited first!");
16229 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone_ptr(arg);
16230 return nativeResponseValue;
16232 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_clone(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR orig);
16234 export function CResult_WarningMessageDecodeErrorZ_clone(orig: bigint): bigint {
16235 if(!isWasmInitialized) {
16236 throw new Error("initializeWasm() must be awaited first!");
16238 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone(orig);
16239 return nativeResponseValue;
16241 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
16243 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
16244 if(!isWasmInitialized) {
16245 throw new Error("initializeWasm() must be awaited first!");
16247 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o);
16248 return nativeResponseValue;
16250 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
16252 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e: bigint): bigint {
16253 if(!isWasmInitialized) {
16254 throw new Error("initializeWasm() must be awaited first!");
16256 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e);
16257 return nativeResponseValue;
16259 // bool CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
16261 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
16262 if(!isWasmInitialized) {
16263 throw new Error("initializeWasm() must be awaited first!");
16265 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o);
16266 return nativeResponseValue;
16268 // void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
16270 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res: bigint): void {
16271 if(!isWasmInitialized) {
16272 throw new Error("initializeWasm() must be awaited first!");
16274 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res);
16275 // debug statements here
16277 // uint64_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
16279 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16280 if(!isWasmInitialized) {
16281 throw new Error("initializeWasm() must be awaited first!");
16283 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg);
16284 return nativeResponseValue;
16286 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
16288 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
16289 if(!isWasmInitialized) {
16290 throw new Error("initializeWasm() must be awaited first!");
16292 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig);
16293 return nativeResponseValue;
16295 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
16297 export function CResult_NodeAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
16298 if(!isWasmInitialized) {
16299 throw new Error("initializeWasm() must be awaited first!");
16301 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_ok(o);
16302 return nativeResponseValue;
16304 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
16306 export function CResult_NodeAnnouncementDecodeErrorZ_err(e: bigint): bigint {
16307 if(!isWasmInitialized) {
16308 throw new Error("initializeWasm() must be awaited first!");
16310 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_err(e);
16311 return nativeResponseValue;
16313 // bool CResult_NodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
16315 export function CResult_NodeAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
16316 if(!isWasmInitialized) {
16317 throw new Error("initializeWasm() must be awaited first!");
16319 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(o);
16320 return nativeResponseValue;
16322 // void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
16324 export function CResult_NodeAnnouncementDecodeErrorZ_free(_res: bigint): void {
16325 if(!isWasmInitialized) {
16326 throw new Error("initializeWasm() must be awaited first!");
16328 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_free(_res);
16329 // debug statements here
16331 // uint64_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
16333 export function CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16334 if(!isWasmInitialized) {
16335 throw new Error("initializeWasm() must be awaited first!");
16337 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg);
16338 return nativeResponseValue;
16340 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
16342 export function CResult_NodeAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
16343 if(!isWasmInitialized) {
16344 throw new Error("initializeWasm() must be awaited first!");
16346 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone(orig);
16347 return nativeResponseValue;
16349 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
16351 export function CResult_QueryShortChannelIdsDecodeErrorZ_ok(o: bigint): bigint {
16352 if(!isWasmInitialized) {
16353 throw new Error("initializeWasm() must be awaited first!");
16355 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(o);
16356 return nativeResponseValue;
16358 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
16360 export function CResult_QueryShortChannelIdsDecodeErrorZ_err(e: bigint): bigint {
16361 if(!isWasmInitialized) {
16362 throw new Error("initializeWasm() must be awaited first!");
16364 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(e);
16365 return nativeResponseValue;
16367 // bool CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR o);
16369 export function CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o: bigint): boolean {
16370 if(!isWasmInitialized) {
16371 throw new Error("initializeWasm() must be awaited first!");
16373 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o);
16374 return nativeResponseValue;
16376 // void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
16378 export function CResult_QueryShortChannelIdsDecodeErrorZ_free(_res: bigint): void {
16379 if(!isWasmInitialized) {
16380 throw new Error("initializeWasm() must be awaited first!");
16382 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(_res);
16383 // debug statements here
16385 // uint64_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg);
16387 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16388 if(!isWasmInitialized) {
16389 throw new Error("initializeWasm() must be awaited first!");
16391 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg);
16392 return nativeResponseValue;
16394 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
16396 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig: bigint): bigint {
16397 if(!isWasmInitialized) {
16398 throw new Error("initializeWasm() must be awaited first!");
16400 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig);
16401 return nativeResponseValue;
16403 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
16405 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o: bigint): bigint {
16406 if(!isWasmInitialized) {
16407 throw new Error("initializeWasm() must be awaited first!");
16409 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o);
16410 return nativeResponseValue;
16412 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
16414 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e: bigint): bigint {
16415 if(!isWasmInitialized) {
16416 throw new Error("initializeWasm() must be awaited first!");
16418 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e);
16419 return nativeResponseValue;
16421 // bool CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR o);
16423 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o: bigint): boolean {
16424 if(!isWasmInitialized) {
16425 throw new Error("initializeWasm() must be awaited first!");
16427 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o);
16428 return nativeResponseValue;
16430 // void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
16432 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res: bigint): void {
16433 if(!isWasmInitialized) {
16434 throw new Error("initializeWasm() must be awaited first!");
16436 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res);
16437 // debug statements here
16439 // uint64_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg);
16441 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16442 if(!isWasmInitialized) {
16443 throw new Error("initializeWasm() must be awaited first!");
16445 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg);
16446 return nativeResponseValue;
16448 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
16450 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig: bigint): bigint {
16451 if(!isWasmInitialized) {
16452 throw new Error("initializeWasm() must be awaited first!");
16454 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig);
16455 return nativeResponseValue;
16457 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
16459 export function CResult_QueryChannelRangeDecodeErrorZ_ok(o: bigint): bigint {
16460 if(!isWasmInitialized) {
16461 throw new Error("initializeWasm() must be awaited first!");
16463 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_ok(o);
16464 return nativeResponseValue;
16466 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
16468 export function CResult_QueryChannelRangeDecodeErrorZ_err(e: bigint): bigint {
16469 if(!isWasmInitialized) {
16470 throw new Error("initializeWasm() must be awaited first!");
16472 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_err(e);
16473 return nativeResponseValue;
16475 // bool CResult_QueryChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR o);
16477 export function CResult_QueryChannelRangeDecodeErrorZ_is_ok(o: bigint): boolean {
16478 if(!isWasmInitialized) {
16479 throw new Error("initializeWasm() must be awaited first!");
16481 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(o);
16482 return nativeResponseValue;
16484 // void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
16486 export function CResult_QueryChannelRangeDecodeErrorZ_free(_res: bigint): void {
16487 if(!isWasmInitialized) {
16488 throw new Error("initializeWasm() must be awaited first!");
16490 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_free(_res);
16491 // debug statements here
16493 // uint64_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg);
16495 export function CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16496 if(!isWasmInitialized) {
16497 throw new Error("initializeWasm() must be awaited first!");
16499 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg);
16500 return nativeResponseValue;
16502 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
16504 export function CResult_QueryChannelRangeDecodeErrorZ_clone(orig: bigint): bigint {
16505 if(!isWasmInitialized) {
16506 throw new Error("initializeWasm() must be awaited first!");
16508 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone(orig);
16509 return nativeResponseValue;
16511 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
16513 export function CResult_ReplyChannelRangeDecodeErrorZ_ok(o: bigint): bigint {
16514 if(!isWasmInitialized) {
16515 throw new Error("initializeWasm() must be awaited first!");
16517 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(o);
16518 return nativeResponseValue;
16520 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
16522 export function CResult_ReplyChannelRangeDecodeErrorZ_err(e: bigint): bigint {
16523 if(!isWasmInitialized) {
16524 throw new Error("initializeWasm() must be awaited first!");
16526 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_err(e);
16527 return nativeResponseValue;
16529 // bool CResult_ReplyChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR o);
16531 export function CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o: bigint): boolean {
16532 if(!isWasmInitialized) {
16533 throw new Error("initializeWasm() must be awaited first!");
16535 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o);
16536 return nativeResponseValue;
16538 // void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
16540 export function CResult_ReplyChannelRangeDecodeErrorZ_free(_res: bigint): void {
16541 if(!isWasmInitialized) {
16542 throw new Error("initializeWasm() must be awaited first!");
16544 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_free(_res);
16545 // debug statements here
16547 // uint64_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg);
16549 export function CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16550 if(!isWasmInitialized) {
16551 throw new Error("initializeWasm() must be awaited first!");
16553 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg);
16554 return nativeResponseValue;
16556 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
16558 export function CResult_ReplyChannelRangeDecodeErrorZ_clone(orig: bigint): bigint {
16559 if(!isWasmInitialized) {
16560 throw new Error("initializeWasm() must be awaited first!");
16562 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(orig);
16563 return nativeResponseValue;
16565 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
16567 export function CResult_GossipTimestampFilterDecodeErrorZ_ok(o: bigint): bigint {
16568 if(!isWasmInitialized) {
16569 throw new Error("initializeWasm() must be awaited first!");
16571 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(o);
16572 return nativeResponseValue;
16574 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
16576 export function CResult_GossipTimestampFilterDecodeErrorZ_err(e: bigint): bigint {
16577 if(!isWasmInitialized) {
16578 throw new Error("initializeWasm() must be awaited first!");
16580 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_err(e);
16581 return nativeResponseValue;
16583 // bool CResult_GossipTimestampFilterDecodeErrorZ_is_ok(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR o);
16585 export function CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o: bigint): boolean {
16586 if(!isWasmInitialized) {
16587 throw new Error("initializeWasm() must be awaited first!");
16589 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o);
16590 return nativeResponseValue;
16592 // void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
16594 export function CResult_GossipTimestampFilterDecodeErrorZ_free(_res: bigint): void {
16595 if(!isWasmInitialized) {
16596 throw new Error("initializeWasm() must be awaited first!");
16598 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_free(_res);
16599 // debug statements here
16601 // uint64_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg);
16603 export function CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16604 if(!isWasmInitialized) {
16605 throw new Error("initializeWasm() must be awaited first!");
16607 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg);
16608 return nativeResponseValue;
16610 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
16612 export function CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: bigint): bigint {
16613 if(!isWasmInitialized) {
16614 throw new Error("initializeWasm() must be awaited first!");
16616 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(orig);
16617 return nativeResponseValue;
16619 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_ok(struct LDKInvoice o);
16621 export function CResult_InvoiceSignOrCreationErrorZ_ok(o: bigint): bigint {
16622 if(!isWasmInitialized) {
16623 throw new Error("initializeWasm() must be awaited first!");
16625 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_ok(o);
16626 return nativeResponseValue;
16628 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_err(struct LDKSignOrCreationError e);
16630 export function CResult_InvoiceSignOrCreationErrorZ_err(e: bigint): bigint {
16631 if(!isWasmInitialized) {
16632 throw new Error("initializeWasm() must be awaited first!");
16634 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_err(e);
16635 return nativeResponseValue;
16637 // bool CResult_InvoiceSignOrCreationErrorZ_is_ok(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR o);
16639 export function CResult_InvoiceSignOrCreationErrorZ_is_ok(o: bigint): boolean {
16640 if(!isWasmInitialized) {
16641 throw new Error("initializeWasm() must be awaited first!");
16643 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_is_ok(o);
16644 return nativeResponseValue;
16646 // void CResult_InvoiceSignOrCreationErrorZ_free(struct LDKCResult_InvoiceSignOrCreationErrorZ _res);
16648 export function CResult_InvoiceSignOrCreationErrorZ_free(_res: bigint): void {
16649 if(!isWasmInitialized) {
16650 throw new Error("initializeWasm() must be awaited first!");
16652 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_free(_res);
16653 // debug statements here
16655 // uint64_t CResult_InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR arg);
16657 export function CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg: bigint): bigint {
16658 if(!isWasmInitialized) {
16659 throw new Error("initializeWasm() must be awaited first!");
16661 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg);
16662 return nativeResponseValue;
16664 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_clone(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR orig);
16666 export function CResult_InvoiceSignOrCreationErrorZ_clone(orig: bigint): bigint {
16667 if(!isWasmInitialized) {
16668 throw new Error("initializeWasm() must be awaited first!");
16670 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone(orig);
16671 return nativeResponseValue;
16673 // struct LDKCOption_FilterZ COption_FilterZ_some(struct LDKFilter o);
16675 export function COption_FilterZ_some(o: bigint): bigint {
16676 if(!isWasmInitialized) {
16677 throw new Error("initializeWasm() must be awaited first!");
16679 const nativeResponseValue = wasm.TS_COption_FilterZ_some(o);
16680 return nativeResponseValue;
16682 // struct LDKCOption_FilterZ COption_FilterZ_none(void);
16684 export function COption_FilterZ_none(): bigint {
16685 if(!isWasmInitialized) {
16686 throw new Error("initializeWasm() must be awaited first!");
16688 const nativeResponseValue = wasm.TS_COption_FilterZ_none();
16689 return nativeResponseValue;
16691 // void COption_FilterZ_free(struct LDKCOption_FilterZ _res);
16693 export function COption_FilterZ_free(_res: bigint): void {
16694 if(!isWasmInitialized) {
16695 throw new Error("initializeWasm() must be awaited first!");
16697 const nativeResponseValue = wasm.TS_COption_FilterZ_free(_res);
16698 // debug statements here
16700 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_ok(struct LDKLockedChannelMonitor o);
16702 export function CResult_LockedChannelMonitorNoneZ_ok(o: bigint): bigint {
16703 if(!isWasmInitialized) {
16704 throw new Error("initializeWasm() must be awaited first!");
16706 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_ok(o);
16707 return nativeResponseValue;
16709 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_err(void);
16711 export function CResult_LockedChannelMonitorNoneZ_err(): bigint {
16712 if(!isWasmInitialized) {
16713 throw new Error("initializeWasm() must be awaited first!");
16715 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_err();
16716 return nativeResponseValue;
16718 // bool CResult_LockedChannelMonitorNoneZ_is_ok(const struct LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR o);
16720 export function CResult_LockedChannelMonitorNoneZ_is_ok(o: bigint): boolean {
16721 if(!isWasmInitialized) {
16722 throw new Error("initializeWasm() must be awaited first!");
16724 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_is_ok(o);
16725 return nativeResponseValue;
16727 // void CResult_LockedChannelMonitorNoneZ_free(struct LDKCResult_LockedChannelMonitorNoneZ _res);
16729 export function CResult_LockedChannelMonitorNoneZ_free(_res: bigint): void {
16730 if(!isWasmInitialized) {
16731 throw new Error("initializeWasm() must be awaited first!");
16733 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_free(_res);
16734 // debug statements here
16736 // void CVec_OutPointZ_free(struct LDKCVec_OutPointZ _res);
16738 export function CVec_OutPointZ_free(_res: number): void {
16739 if(!isWasmInitialized) {
16740 throw new Error("initializeWasm() must be awaited first!");
16742 const nativeResponseValue = wasm.TS_CVec_OutPointZ_free(_res);
16743 // debug statements here
16745 // void PaymentPurpose_free(struct LDKPaymentPurpose this_ptr);
16747 export function PaymentPurpose_free(this_ptr: bigint): void {
16748 if(!isWasmInitialized) {
16749 throw new Error("initializeWasm() must be awaited first!");
16751 const nativeResponseValue = wasm.TS_PaymentPurpose_free(this_ptr);
16752 // debug statements here
16754 // uint64_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg);
16756 export function PaymentPurpose_clone_ptr(arg: bigint): bigint {
16757 if(!isWasmInitialized) {
16758 throw new Error("initializeWasm() must be awaited first!");
16760 const nativeResponseValue = wasm.TS_PaymentPurpose_clone_ptr(arg);
16761 return nativeResponseValue;
16763 // struct LDKPaymentPurpose PaymentPurpose_clone(const struct LDKPaymentPurpose *NONNULL_PTR orig);
16765 export function PaymentPurpose_clone(orig: bigint): bigint {
16766 if(!isWasmInitialized) {
16767 throw new Error("initializeWasm() must be awaited first!");
16769 const nativeResponseValue = wasm.TS_PaymentPurpose_clone(orig);
16770 return nativeResponseValue;
16772 // struct LDKPaymentPurpose PaymentPurpose_invoice_payment(struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_secret);
16774 export function PaymentPurpose_invoice_payment(payment_preimage: number, payment_secret: number): bigint {
16775 if(!isWasmInitialized) {
16776 throw new Error("initializeWasm() must be awaited first!");
16778 const nativeResponseValue = wasm.TS_PaymentPurpose_invoice_payment(payment_preimage, payment_secret);
16779 return nativeResponseValue;
16781 // struct LDKPaymentPurpose PaymentPurpose_spontaneous_payment(struct LDKThirtyTwoBytes a);
16783 export function PaymentPurpose_spontaneous_payment(a: number): bigint {
16784 if(!isWasmInitialized) {
16785 throw new Error("initializeWasm() must be awaited first!");
16787 const nativeResponseValue = wasm.TS_PaymentPurpose_spontaneous_payment(a);
16788 return nativeResponseValue;
16790 // struct LDKCVec_u8Z PaymentPurpose_write(const struct LDKPaymentPurpose *NONNULL_PTR obj);
16792 export function PaymentPurpose_write(obj: bigint): number {
16793 if(!isWasmInitialized) {
16794 throw new Error("initializeWasm() must be awaited first!");
16796 const nativeResponseValue = wasm.TS_PaymentPurpose_write(obj);
16797 return nativeResponseValue;
16799 // struct LDKCResult_PaymentPurposeDecodeErrorZ PaymentPurpose_read(struct LDKu8slice ser);
16801 export function PaymentPurpose_read(ser: number): bigint {
16802 if(!isWasmInitialized) {
16803 throw new Error("initializeWasm() must be awaited first!");
16805 const nativeResponseValue = wasm.TS_PaymentPurpose_read(ser);
16806 return nativeResponseValue;
16808 // void ClosureReason_free(struct LDKClosureReason this_ptr);
16810 export function ClosureReason_free(this_ptr: bigint): void {
16811 if(!isWasmInitialized) {
16812 throw new Error("initializeWasm() must be awaited first!");
16814 const nativeResponseValue = wasm.TS_ClosureReason_free(this_ptr);
16815 // debug statements here
16817 // uint64_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg);
16819 export function ClosureReason_clone_ptr(arg: bigint): bigint {
16820 if(!isWasmInitialized) {
16821 throw new Error("initializeWasm() must be awaited first!");
16823 const nativeResponseValue = wasm.TS_ClosureReason_clone_ptr(arg);
16824 return nativeResponseValue;
16826 // struct LDKClosureReason ClosureReason_clone(const struct LDKClosureReason *NONNULL_PTR orig);
16828 export function ClosureReason_clone(orig: bigint): bigint {
16829 if(!isWasmInitialized) {
16830 throw new Error("initializeWasm() must be awaited first!");
16832 const nativeResponseValue = wasm.TS_ClosureReason_clone(orig);
16833 return nativeResponseValue;
16835 // struct LDKClosureReason ClosureReason_counterparty_force_closed(struct LDKStr peer_msg);
16837 export function ClosureReason_counterparty_force_closed(peer_msg: number): bigint {
16838 if(!isWasmInitialized) {
16839 throw new Error("initializeWasm() must be awaited first!");
16841 const nativeResponseValue = wasm.TS_ClosureReason_counterparty_force_closed(peer_msg);
16842 return nativeResponseValue;
16844 // struct LDKClosureReason ClosureReason_holder_force_closed(void);
16846 export function ClosureReason_holder_force_closed(): bigint {
16847 if(!isWasmInitialized) {
16848 throw new Error("initializeWasm() must be awaited first!");
16850 const nativeResponseValue = wasm.TS_ClosureReason_holder_force_closed();
16851 return nativeResponseValue;
16853 // struct LDKClosureReason ClosureReason_cooperative_closure(void);
16855 export function ClosureReason_cooperative_closure(): bigint {
16856 if(!isWasmInitialized) {
16857 throw new Error("initializeWasm() must be awaited first!");
16859 const nativeResponseValue = wasm.TS_ClosureReason_cooperative_closure();
16860 return nativeResponseValue;
16862 // struct LDKClosureReason ClosureReason_commitment_tx_confirmed(void);
16864 export function ClosureReason_commitment_tx_confirmed(): bigint {
16865 if(!isWasmInitialized) {
16866 throw new Error("initializeWasm() must be awaited first!");
16868 const nativeResponseValue = wasm.TS_ClosureReason_commitment_tx_confirmed();
16869 return nativeResponseValue;
16871 // struct LDKClosureReason ClosureReason_funding_timed_out(void);
16873 export function ClosureReason_funding_timed_out(): bigint {
16874 if(!isWasmInitialized) {
16875 throw new Error("initializeWasm() must be awaited first!");
16877 const nativeResponseValue = wasm.TS_ClosureReason_funding_timed_out();
16878 return nativeResponseValue;
16880 // struct LDKClosureReason ClosureReason_processing_error(struct LDKStr err);
16882 export function ClosureReason_processing_error(err: number): bigint {
16883 if(!isWasmInitialized) {
16884 throw new Error("initializeWasm() must be awaited first!");
16886 const nativeResponseValue = wasm.TS_ClosureReason_processing_error(err);
16887 return nativeResponseValue;
16889 // struct LDKClosureReason ClosureReason_disconnected_peer(void);
16891 export function ClosureReason_disconnected_peer(): bigint {
16892 if(!isWasmInitialized) {
16893 throw new Error("initializeWasm() must be awaited first!");
16895 const nativeResponseValue = wasm.TS_ClosureReason_disconnected_peer();
16896 return nativeResponseValue;
16898 // struct LDKClosureReason ClosureReason_outdated_channel_manager(void);
16900 export function ClosureReason_outdated_channel_manager(): bigint {
16901 if(!isWasmInitialized) {
16902 throw new Error("initializeWasm() must be awaited first!");
16904 const nativeResponseValue = wasm.TS_ClosureReason_outdated_channel_manager();
16905 return nativeResponseValue;
16907 // bool ClosureReason_eq(const struct LDKClosureReason *NONNULL_PTR a, const struct LDKClosureReason *NONNULL_PTR b);
16909 export function ClosureReason_eq(a: bigint, b: bigint): boolean {
16910 if(!isWasmInitialized) {
16911 throw new Error("initializeWasm() must be awaited first!");
16913 const nativeResponseValue = wasm.TS_ClosureReason_eq(a, b);
16914 return nativeResponseValue;
16916 // struct LDKCVec_u8Z ClosureReason_write(const struct LDKClosureReason *NONNULL_PTR obj);
16918 export function ClosureReason_write(obj: bigint): number {
16919 if(!isWasmInitialized) {
16920 throw new Error("initializeWasm() must be awaited first!");
16922 const nativeResponseValue = wasm.TS_ClosureReason_write(obj);
16923 return nativeResponseValue;
16925 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ ClosureReason_read(struct LDKu8slice ser);
16927 export function ClosureReason_read(ser: number): bigint {
16928 if(!isWasmInitialized) {
16929 throw new Error("initializeWasm() must be awaited first!");
16931 const nativeResponseValue = wasm.TS_ClosureReason_read(ser);
16932 return nativeResponseValue;
16934 // void HTLCDestination_free(struct LDKHTLCDestination this_ptr);
16936 export function HTLCDestination_free(this_ptr: bigint): void {
16937 if(!isWasmInitialized) {
16938 throw new Error("initializeWasm() must be awaited first!");
16940 const nativeResponseValue = wasm.TS_HTLCDestination_free(this_ptr);
16941 // debug statements here
16943 // uint64_t HTLCDestination_clone_ptr(LDKHTLCDestination *NONNULL_PTR arg);
16945 export function HTLCDestination_clone_ptr(arg: bigint): bigint {
16946 if(!isWasmInitialized) {
16947 throw new Error("initializeWasm() must be awaited first!");
16949 const nativeResponseValue = wasm.TS_HTLCDestination_clone_ptr(arg);
16950 return nativeResponseValue;
16952 // struct LDKHTLCDestination HTLCDestination_clone(const struct LDKHTLCDestination *NONNULL_PTR orig);
16954 export function HTLCDestination_clone(orig: bigint): bigint {
16955 if(!isWasmInitialized) {
16956 throw new Error("initializeWasm() must be awaited first!");
16958 const nativeResponseValue = wasm.TS_HTLCDestination_clone(orig);
16959 return nativeResponseValue;
16961 // struct LDKHTLCDestination HTLCDestination_next_hop_channel(struct LDKPublicKey node_id, struct LDKThirtyTwoBytes channel_id);
16963 export function HTLCDestination_next_hop_channel(node_id: number, channel_id: number): bigint {
16964 if(!isWasmInitialized) {
16965 throw new Error("initializeWasm() must be awaited first!");
16967 const nativeResponseValue = wasm.TS_HTLCDestination_next_hop_channel(node_id, channel_id);
16968 return nativeResponseValue;
16970 // struct LDKHTLCDestination HTLCDestination_unknown_next_hop(uint64_t requested_forward_scid);
16972 export function HTLCDestination_unknown_next_hop(requested_forward_scid: bigint): bigint {
16973 if(!isWasmInitialized) {
16974 throw new Error("initializeWasm() must be awaited first!");
16976 const nativeResponseValue = wasm.TS_HTLCDestination_unknown_next_hop(requested_forward_scid);
16977 return nativeResponseValue;
16979 // struct LDKHTLCDestination HTLCDestination_failed_payment(struct LDKThirtyTwoBytes payment_hash);
16981 export function HTLCDestination_failed_payment(payment_hash: number): bigint {
16982 if(!isWasmInitialized) {
16983 throw new Error("initializeWasm() must be awaited first!");
16985 const nativeResponseValue = wasm.TS_HTLCDestination_failed_payment(payment_hash);
16986 return nativeResponseValue;
16988 // bool HTLCDestination_eq(const struct LDKHTLCDestination *NONNULL_PTR a, const struct LDKHTLCDestination *NONNULL_PTR b);
16990 export function HTLCDestination_eq(a: bigint, b: bigint): boolean {
16991 if(!isWasmInitialized) {
16992 throw new Error("initializeWasm() must be awaited first!");
16994 const nativeResponseValue = wasm.TS_HTLCDestination_eq(a, b);
16995 return nativeResponseValue;
16997 // struct LDKCVec_u8Z HTLCDestination_write(const struct LDKHTLCDestination *NONNULL_PTR obj);
16999 export function HTLCDestination_write(obj: bigint): number {
17000 if(!isWasmInitialized) {
17001 throw new Error("initializeWasm() must be awaited first!");
17003 const nativeResponseValue = wasm.TS_HTLCDestination_write(obj);
17004 return nativeResponseValue;
17006 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ HTLCDestination_read(struct LDKu8slice ser);
17008 export function HTLCDestination_read(ser: number): bigint {
17009 if(!isWasmInitialized) {
17010 throw new Error("initializeWasm() must be awaited first!");
17012 const nativeResponseValue = wasm.TS_HTLCDestination_read(ser);
17013 return nativeResponseValue;
17015 // void Event_free(struct LDKEvent this_ptr);
17017 export function Event_free(this_ptr: bigint): void {
17018 if(!isWasmInitialized) {
17019 throw new Error("initializeWasm() must be awaited first!");
17021 const nativeResponseValue = wasm.TS_Event_free(this_ptr);
17022 // debug statements here
17024 // uint64_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg);
17026 export function Event_clone_ptr(arg: bigint): bigint {
17027 if(!isWasmInitialized) {
17028 throw new Error("initializeWasm() must be awaited first!");
17030 const nativeResponseValue = wasm.TS_Event_clone_ptr(arg);
17031 return nativeResponseValue;
17033 // struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
17035 export function Event_clone(orig: bigint): bigint {
17036 if(!isWasmInitialized) {
17037 throw new Error("initializeWasm() must be awaited first!");
17039 const nativeResponseValue = wasm.TS_Event_clone(orig);
17040 return nativeResponseValue;
17042 // 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);
17044 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 {
17045 if(!isWasmInitialized) {
17046 throw new Error("initializeWasm() must be awaited first!");
17048 const nativeResponseValue = wasm.TS_Event_funding_generation_ready(temporary_channel_id, counterparty_node_id, channel_value_satoshis, output_script, user_channel_id);
17049 return nativeResponseValue;
17051 // struct LDKEvent Event_payment_received(struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose);
17053 export function Event_payment_received(payment_hash: number, amount_msat: bigint, purpose: bigint): bigint {
17054 if(!isWasmInitialized) {
17055 throw new Error("initializeWasm() must be awaited first!");
17057 const nativeResponseValue = wasm.TS_Event_payment_received(payment_hash, amount_msat, purpose);
17058 return nativeResponseValue;
17060 // struct LDKEvent Event_payment_claimed(struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose);
17062 export function Event_payment_claimed(payment_hash: number, amount_msat: bigint, purpose: bigint): bigint {
17063 if(!isWasmInitialized) {
17064 throw new Error("initializeWasm() must be awaited first!");
17066 const nativeResponseValue = wasm.TS_Event_payment_claimed(payment_hash, amount_msat, purpose);
17067 return nativeResponseValue;
17069 // struct LDKEvent Event_payment_sent(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z fee_paid_msat);
17071 export function Event_payment_sent(payment_id: number, payment_preimage: number, payment_hash: number, fee_paid_msat: bigint): bigint {
17072 if(!isWasmInitialized) {
17073 throw new Error("initializeWasm() must be awaited first!");
17075 const nativeResponseValue = wasm.TS_Event_payment_sent(payment_id, payment_preimage, payment_hash, fee_paid_msat);
17076 return nativeResponseValue;
17078 // struct LDKEvent Event_payment_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash);
17080 export function Event_payment_failed(payment_id: number, payment_hash: number): bigint {
17081 if(!isWasmInitialized) {
17082 throw new Error("initializeWasm() must be awaited first!");
17084 const nativeResponseValue = wasm.TS_Event_payment_failed(payment_id, payment_hash);
17085 return nativeResponseValue;
17087 // struct LDKEvent Event_payment_path_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path);
17089 export function Event_payment_path_successful(payment_id: number, payment_hash: number, path: number): bigint {
17090 if(!isWasmInitialized) {
17091 throw new Error("initializeWasm() must be awaited first!");
17093 const nativeResponseValue = wasm.TS_Event_payment_path_successful(payment_id, payment_hash, path);
17094 return nativeResponseValue;
17096 // 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);
17098 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 {
17099 if(!isWasmInitialized) {
17100 throw new Error("initializeWasm() must be awaited first!");
17102 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);
17103 return nativeResponseValue;
17105 // struct LDKEvent Event_probe_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path);
17107 export function Event_probe_successful(payment_id: number, payment_hash: number, path: number): bigint {
17108 if(!isWasmInitialized) {
17109 throw new Error("initializeWasm() must be awaited first!");
17111 const nativeResponseValue = wasm.TS_Event_probe_successful(payment_id, payment_hash, path);
17112 return nativeResponseValue;
17114 // struct LDKEvent Event_probe_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path, struct LDKCOption_u64Z short_channel_id);
17116 export function Event_probe_failed(payment_id: number, payment_hash: number, path: number, short_channel_id: bigint): bigint {
17117 if(!isWasmInitialized) {
17118 throw new Error("initializeWasm() must be awaited first!");
17120 const nativeResponseValue = wasm.TS_Event_probe_failed(payment_id, payment_hash, path, short_channel_id);
17121 return nativeResponseValue;
17123 // struct LDKEvent Event_pending_htlcs_forwardable(uint64_t time_forwardable);
17125 export function Event_pending_htlcs_forwardable(time_forwardable: bigint): bigint {
17126 if(!isWasmInitialized) {
17127 throw new Error("initializeWasm() must be awaited first!");
17129 const nativeResponseValue = wasm.TS_Event_pending_htlcs_forwardable(time_forwardable);
17130 return nativeResponseValue;
17132 // struct LDKEvent Event_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ outputs);
17134 export function Event_spendable_outputs(outputs: number): bigint {
17135 if(!isWasmInitialized) {
17136 throw new Error("initializeWasm() must be awaited first!");
17138 const nativeResponseValue = wasm.TS_Event_spendable_outputs(outputs);
17139 return nativeResponseValue;
17141 // 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);
17143 export function Event_payment_forwarded(prev_channel_id: number, next_channel_id: number, fee_earned_msat: bigint, claim_from_onchain_tx: boolean): bigint {
17144 if(!isWasmInitialized) {
17145 throw new Error("initializeWasm() must be awaited first!");
17147 const nativeResponseValue = wasm.TS_Event_payment_forwarded(prev_channel_id, next_channel_id, fee_earned_msat, claim_from_onchain_tx);
17148 return nativeResponseValue;
17150 // struct LDKEvent Event_channel_closed(struct LDKThirtyTwoBytes channel_id, uint64_t user_channel_id, struct LDKClosureReason reason);
17152 export function Event_channel_closed(channel_id: number, user_channel_id: bigint, reason: bigint): bigint {
17153 if(!isWasmInitialized) {
17154 throw new Error("initializeWasm() must be awaited first!");
17156 const nativeResponseValue = wasm.TS_Event_channel_closed(channel_id, user_channel_id, reason);
17157 return nativeResponseValue;
17159 // struct LDKEvent Event_discard_funding(struct LDKThirtyTwoBytes channel_id, struct LDKTransaction transaction);
17161 export function Event_discard_funding(channel_id: number, transaction: number): bigint {
17162 if(!isWasmInitialized) {
17163 throw new Error("initializeWasm() must be awaited first!");
17165 const nativeResponseValue = wasm.TS_Event_discard_funding(channel_id, transaction);
17166 return nativeResponseValue;
17168 // 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);
17170 export function Event_open_channel_request(temporary_channel_id: number, counterparty_node_id: number, funding_satoshis: bigint, push_msat: bigint, channel_type: bigint): bigint {
17171 if(!isWasmInitialized) {
17172 throw new Error("initializeWasm() must be awaited first!");
17174 const nativeResponseValue = wasm.TS_Event_open_channel_request(temporary_channel_id, counterparty_node_id, funding_satoshis, push_msat, channel_type);
17175 return nativeResponseValue;
17177 // struct LDKEvent Event_htlchandling_failed(struct LDKThirtyTwoBytes prev_channel_id, struct LDKHTLCDestination failed_next_destination);
17179 export function Event_htlchandling_failed(prev_channel_id: number, failed_next_destination: bigint): bigint {
17180 if(!isWasmInitialized) {
17181 throw new Error("initializeWasm() must be awaited first!");
17183 const nativeResponseValue = wasm.TS_Event_htlchandling_failed(prev_channel_id, failed_next_destination);
17184 return nativeResponseValue;
17186 // struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
17188 export function Event_write(obj: bigint): number {
17189 if(!isWasmInitialized) {
17190 throw new Error("initializeWasm() must be awaited first!");
17192 const nativeResponseValue = wasm.TS_Event_write(obj);
17193 return nativeResponseValue;
17195 // struct LDKCResult_COption_EventZDecodeErrorZ Event_read(struct LDKu8slice ser);
17197 export function Event_read(ser: number): bigint {
17198 if(!isWasmInitialized) {
17199 throw new Error("initializeWasm() must be awaited first!");
17201 const nativeResponseValue = wasm.TS_Event_read(ser);
17202 return nativeResponseValue;
17204 // void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
17206 export function MessageSendEvent_free(this_ptr: bigint): void {
17207 if(!isWasmInitialized) {
17208 throw new Error("initializeWasm() must be awaited first!");
17210 const nativeResponseValue = wasm.TS_MessageSendEvent_free(this_ptr);
17211 // debug statements here
17213 // uint64_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg);
17215 export function MessageSendEvent_clone_ptr(arg: bigint): bigint {
17216 if(!isWasmInitialized) {
17217 throw new Error("initializeWasm() must be awaited first!");
17219 const nativeResponseValue = wasm.TS_MessageSendEvent_clone_ptr(arg);
17220 return nativeResponseValue;
17222 // struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
17224 export function MessageSendEvent_clone(orig: bigint): bigint {
17225 if(!isWasmInitialized) {
17226 throw new Error("initializeWasm() must be awaited first!");
17228 const nativeResponseValue = wasm.TS_MessageSendEvent_clone(orig);
17229 return nativeResponseValue;
17231 // struct LDKMessageSendEvent MessageSendEvent_send_accept_channel(struct LDKPublicKey node_id, struct LDKAcceptChannel msg);
17233 export function MessageSendEvent_send_accept_channel(node_id: number, msg: bigint): bigint {
17234 if(!isWasmInitialized) {
17235 throw new Error("initializeWasm() must be awaited first!");
17237 const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel(node_id, msg);
17238 return nativeResponseValue;
17240 // struct LDKMessageSendEvent MessageSendEvent_send_open_channel(struct LDKPublicKey node_id, struct LDKOpenChannel msg);
17242 export function MessageSendEvent_send_open_channel(node_id: number, msg: bigint): bigint {
17243 if(!isWasmInitialized) {
17244 throw new Error("initializeWasm() must be awaited first!");
17246 const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel(node_id, msg);
17247 return nativeResponseValue;
17249 // struct LDKMessageSendEvent MessageSendEvent_send_funding_created(struct LDKPublicKey node_id, struct LDKFundingCreated msg);
17251 export function MessageSendEvent_send_funding_created(node_id: number, msg: bigint): bigint {
17252 if(!isWasmInitialized) {
17253 throw new Error("initializeWasm() must be awaited first!");
17255 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_created(node_id, msg);
17256 return nativeResponseValue;
17258 // struct LDKMessageSendEvent MessageSendEvent_send_funding_signed(struct LDKPublicKey node_id, struct LDKFundingSigned msg);
17260 export function MessageSendEvent_send_funding_signed(node_id: number, msg: bigint): bigint {
17261 if(!isWasmInitialized) {
17262 throw new Error("initializeWasm() must be awaited first!");
17264 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_signed(node_id, msg);
17265 return nativeResponseValue;
17267 // struct LDKMessageSendEvent MessageSendEvent_send_channel_ready(struct LDKPublicKey node_id, struct LDKChannelReady msg);
17269 export function MessageSendEvent_send_channel_ready(node_id: number, msg: bigint): bigint {
17270 if(!isWasmInitialized) {
17271 throw new Error("initializeWasm() must be awaited first!");
17273 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_ready(node_id, msg);
17274 return nativeResponseValue;
17276 // struct LDKMessageSendEvent MessageSendEvent_send_announcement_signatures(struct LDKPublicKey node_id, struct LDKAnnouncementSignatures msg);
17278 export function MessageSendEvent_send_announcement_signatures(node_id: number, msg: bigint): bigint {
17279 if(!isWasmInitialized) {
17280 throw new Error("initializeWasm() must be awaited first!");
17282 const nativeResponseValue = wasm.TS_MessageSendEvent_send_announcement_signatures(node_id, msg);
17283 return nativeResponseValue;
17285 // struct LDKMessageSendEvent MessageSendEvent_update_htlcs(struct LDKPublicKey node_id, struct LDKCommitmentUpdate updates);
17287 export function MessageSendEvent_update_htlcs(node_id: number, updates: bigint): bigint {
17288 if(!isWasmInitialized) {
17289 throw new Error("initializeWasm() must be awaited first!");
17291 const nativeResponseValue = wasm.TS_MessageSendEvent_update_htlcs(node_id, updates);
17292 return nativeResponseValue;
17294 // struct LDKMessageSendEvent MessageSendEvent_send_revoke_and_ack(struct LDKPublicKey node_id, struct LDKRevokeAndACK msg);
17296 export function MessageSendEvent_send_revoke_and_ack(node_id: number, msg: bigint): bigint {
17297 if(!isWasmInitialized) {
17298 throw new Error("initializeWasm() must be awaited first!");
17300 const nativeResponseValue = wasm.TS_MessageSendEvent_send_revoke_and_ack(node_id, msg);
17301 return nativeResponseValue;
17303 // struct LDKMessageSendEvent MessageSendEvent_send_closing_signed(struct LDKPublicKey node_id, struct LDKClosingSigned msg);
17305 export function MessageSendEvent_send_closing_signed(node_id: number, msg: bigint): bigint {
17306 if(!isWasmInitialized) {
17307 throw new Error("initializeWasm() must be awaited first!");
17309 const nativeResponseValue = wasm.TS_MessageSendEvent_send_closing_signed(node_id, msg);
17310 return nativeResponseValue;
17312 // struct LDKMessageSendEvent MessageSendEvent_send_shutdown(struct LDKPublicKey node_id, struct LDKShutdown msg);
17314 export function MessageSendEvent_send_shutdown(node_id: number, msg: bigint): bigint {
17315 if(!isWasmInitialized) {
17316 throw new Error("initializeWasm() must be awaited first!");
17318 const nativeResponseValue = wasm.TS_MessageSendEvent_send_shutdown(node_id, msg);
17319 return nativeResponseValue;
17321 // struct LDKMessageSendEvent MessageSendEvent_send_channel_reestablish(struct LDKPublicKey node_id, struct LDKChannelReestablish msg);
17323 export function MessageSendEvent_send_channel_reestablish(node_id: number, msg: bigint): bigint {
17324 if(!isWasmInitialized) {
17325 throw new Error("initializeWasm() must be awaited first!");
17327 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_reestablish(node_id, msg);
17328 return nativeResponseValue;
17330 // struct LDKMessageSendEvent MessageSendEvent_send_channel_announcement(struct LDKPublicKey node_id, struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
17332 export function MessageSendEvent_send_channel_announcement(node_id: number, msg: bigint, update_msg: bigint): bigint {
17333 if(!isWasmInitialized) {
17334 throw new Error("initializeWasm() must be awaited first!");
17336 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_announcement(node_id, msg, update_msg);
17337 return nativeResponseValue;
17339 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_announcement(struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
17341 export function MessageSendEvent_broadcast_channel_announcement(msg: bigint, update_msg: bigint): bigint {
17342 if(!isWasmInitialized) {
17343 throw new Error("initializeWasm() must be awaited first!");
17345 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_announcement(msg, update_msg);
17346 return nativeResponseValue;
17348 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_update(struct LDKChannelUpdate msg);
17350 export function MessageSendEvent_broadcast_channel_update(msg: bigint): bigint {
17351 if(!isWasmInitialized) {
17352 throw new Error("initializeWasm() must be awaited first!");
17354 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_update(msg);
17355 return nativeResponseValue;
17357 // struct LDKMessageSendEvent MessageSendEvent_send_channel_update(struct LDKPublicKey node_id, struct LDKChannelUpdate msg);
17359 export function MessageSendEvent_send_channel_update(node_id: number, msg: bigint): bigint {
17360 if(!isWasmInitialized) {
17361 throw new Error("initializeWasm() must be awaited first!");
17363 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_update(node_id, msg);
17364 return nativeResponseValue;
17366 // struct LDKMessageSendEvent MessageSendEvent_handle_error(struct LDKPublicKey node_id, struct LDKErrorAction action);
17368 export function MessageSendEvent_handle_error(node_id: number, action: bigint): bigint {
17369 if(!isWasmInitialized) {
17370 throw new Error("initializeWasm() must be awaited first!");
17372 const nativeResponseValue = wasm.TS_MessageSendEvent_handle_error(node_id, action);
17373 return nativeResponseValue;
17375 // struct LDKMessageSendEvent MessageSendEvent_send_channel_range_query(struct LDKPublicKey node_id, struct LDKQueryChannelRange msg);
17377 export function MessageSendEvent_send_channel_range_query(node_id: number, msg: bigint): bigint {
17378 if(!isWasmInitialized) {
17379 throw new Error("initializeWasm() must be awaited first!");
17381 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_range_query(node_id, msg);
17382 return nativeResponseValue;
17384 // struct LDKMessageSendEvent MessageSendEvent_send_short_ids_query(struct LDKPublicKey node_id, struct LDKQueryShortChannelIds msg);
17386 export function MessageSendEvent_send_short_ids_query(node_id: number, msg: bigint): bigint {
17387 if(!isWasmInitialized) {
17388 throw new Error("initializeWasm() must be awaited first!");
17390 const nativeResponseValue = wasm.TS_MessageSendEvent_send_short_ids_query(node_id, msg);
17391 return nativeResponseValue;
17393 // struct LDKMessageSendEvent MessageSendEvent_send_reply_channel_range(struct LDKPublicKey node_id, struct LDKReplyChannelRange msg);
17395 export function MessageSendEvent_send_reply_channel_range(node_id: number, msg: bigint): bigint {
17396 if(!isWasmInitialized) {
17397 throw new Error("initializeWasm() must be awaited first!");
17399 const nativeResponseValue = wasm.TS_MessageSendEvent_send_reply_channel_range(node_id, msg);
17400 return nativeResponseValue;
17402 // struct LDKMessageSendEvent MessageSendEvent_send_gossip_timestamp_filter(struct LDKPublicKey node_id, struct LDKGossipTimestampFilter msg);
17404 export function MessageSendEvent_send_gossip_timestamp_filter(node_id: number, msg: bigint): bigint {
17405 if(!isWasmInitialized) {
17406 throw new Error("initializeWasm() must be awaited first!");
17408 const nativeResponseValue = wasm.TS_MessageSendEvent_send_gossip_timestamp_filter(node_id, msg);
17409 return nativeResponseValue;
17411 // void MessageSendEventsProvider_free(struct LDKMessageSendEventsProvider this_ptr);
17413 export function MessageSendEventsProvider_free(this_ptr: bigint): void {
17414 if(!isWasmInitialized) {
17415 throw new Error("initializeWasm() must be awaited first!");
17417 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_free(this_ptr);
17418 // debug statements here
17420 // void OnionMessageProvider_free(struct LDKOnionMessageProvider this_ptr);
17422 export function OnionMessageProvider_free(this_ptr: bigint): void {
17423 if(!isWasmInitialized) {
17424 throw new Error("initializeWasm() must be awaited first!");
17426 const nativeResponseValue = wasm.TS_OnionMessageProvider_free(this_ptr);
17427 // debug statements here
17429 // void EventsProvider_free(struct LDKEventsProvider this_ptr);
17431 export function EventsProvider_free(this_ptr: bigint): void {
17432 if(!isWasmInitialized) {
17433 throw new Error("initializeWasm() must be awaited first!");
17435 const nativeResponseValue = wasm.TS_EventsProvider_free(this_ptr);
17436 // debug statements here
17438 // void EventHandler_free(struct LDKEventHandler this_ptr);
17440 export function EventHandler_free(this_ptr: bigint): void {
17441 if(!isWasmInitialized) {
17442 throw new Error("initializeWasm() must be awaited first!");
17444 const nativeResponseValue = wasm.TS_EventHandler_free(this_ptr);
17445 // debug statements here
17447 // void APIError_free(struct LDKAPIError this_ptr);
17449 export function APIError_free(this_ptr: bigint): void {
17450 if(!isWasmInitialized) {
17451 throw new Error("initializeWasm() must be awaited first!");
17453 const nativeResponseValue = wasm.TS_APIError_free(this_ptr);
17454 // debug statements here
17456 // uint64_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg);
17458 export function APIError_clone_ptr(arg: bigint): bigint {
17459 if(!isWasmInitialized) {
17460 throw new Error("initializeWasm() must be awaited first!");
17462 const nativeResponseValue = wasm.TS_APIError_clone_ptr(arg);
17463 return nativeResponseValue;
17465 // struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
17467 export function APIError_clone(orig: bigint): bigint {
17468 if(!isWasmInitialized) {
17469 throw new Error("initializeWasm() must be awaited first!");
17471 const nativeResponseValue = wasm.TS_APIError_clone(orig);
17472 return nativeResponseValue;
17474 // struct LDKAPIError APIError_apimisuse_error(struct LDKStr err);
17476 export function APIError_apimisuse_error(err: number): bigint {
17477 if(!isWasmInitialized) {
17478 throw new Error("initializeWasm() must be awaited first!");
17480 const nativeResponseValue = wasm.TS_APIError_apimisuse_error(err);
17481 return nativeResponseValue;
17483 // struct LDKAPIError APIError_fee_rate_too_high(struct LDKStr err, uint32_t feerate);
17485 export function APIError_fee_rate_too_high(err: number, feerate: number): bigint {
17486 if(!isWasmInitialized) {
17487 throw new Error("initializeWasm() must be awaited first!");
17489 const nativeResponseValue = wasm.TS_APIError_fee_rate_too_high(err, feerate);
17490 return nativeResponseValue;
17492 // struct LDKAPIError APIError_route_error(struct LDKStr err);
17494 export function APIError_route_error(err: number): bigint {
17495 if(!isWasmInitialized) {
17496 throw new Error("initializeWasm() must be awaited first!");
17498 const nativeResponseValue = wasm.TS_APIError_route_error(err);
17499 return nativeResponseValue;
17501 // struct LDKAPIError APIError_channel_unavailable(struct LDKStr err);
17503 export function APIError_channel_unavailable(err: number): bigint {
17504 if(!isWasmInitialized) {
17505 throw new Error("initializeWasm() must be awaited first!");
17507 const nativeResponseValue = wasm.TS_APIError_channel_unavailable(err);
17508 return nativeResponseValue;
17510 // struct LDKAPIError APIError_monitor_update_in_progress(void);
17512 export function APIError_monitor_update_in_progress(): bigint {
17513 if(!isWasmInitialized) {
17514 throw new Error("initializeWasm() must be awaited first!");
17516 const nativeResponseValue = wasm.TS_APIError_monitor_update_in_progress();
17517 return nativeResponseValue;
17519 // struct LDKAPIError APIError_incompatible_shutdown_script(struct LDKShutdownScript script);
17521 export function APIError_incompatible_shutdown_script(script: bigint): bigint {
17522 if(!isWasmInitialized) {
17523 throw new Error("initializeWasm() must be awaited first!");
17525 const nativeResponseValue = wasm.TS_APIError_incompatible_shutdown_script(script);
17526 return nativeResponseValue;
17528 // bool APIError_eq(const struct LDKAPIError *NONNULL_PTR a, const struct LDKAPIError *NONNULL_PTR b);
17530 export function APIError_eq(a: bigint, b: bigint): boolean {
17531 if(!isWasmInitialized) {
17532 throw new Error("initializeWasm() must be awaited first!");
17534 const nativeResponseValue = wasm.TS_APIError_eq(a, b);
17535 return nativeResponseValue;
17537 // void BigSize_free(struct LDKBigSize this_obj);
17539 export function BigSize_free(this_obj: bigint): void {
17540 if(!isWasmInitialized) {
17541 throw new Error("initializeWasm() must be awaited first!");
17543 const nativeResponseValue = wasm.TS_BigSize_free(this_obj);
17544 // debug statements here
17546 // uint64_t BigSize_get_a(const struct LDKBigSize *NONNULL_PTR this_ptr);
17548 export function BigSize_get_a(this_ptr: bigint): bigint {
17549 if(!isWasmInitialized) {
17550 throw new Error("initializeWasm() must be awaited first!");
17552 const nativeResponseValue = wasm.TS_BigSize_get_a(this_ptr);
17553 return nativeResponseValue;
17555 // void BigSize_set_a(struct LDKBigSize *NONNULL_PTR this_ptr, uint64_t val);
17557 export function BigSize_set_a(this_ptr: bigint, val: bigint): void {
17558 if(!isWasmInitialized) {
17559 throw new Error("initializeWasm() must be awaited first!");
17561 const nativeResponseValue = wasm.TS_BigSize_set_a(this_ptr, val);
17562 // debug statements here
17564 // MUST_USE_RES struct LDKBigSize BigSize_new(uint64_t a_arg);
17566 export function BigSize_new(a_arg: bigint): bigint {
17567 if(!isWasmInitialized) {
17568 throw new Error("initializeWasm() must be awaited first!");
17570 const nativeResponseValue = wasm.TS_BigSize_new(a_arg);
17571 return nativeResponseValue;
17573 // void Hostname_free(struct LDKHostname this_obj);
17575 export function Hostname_free(this_obj: bigint): void {
17576 if(!isWasmInitialized) {
17577 throw new Error("initializeWasm() must be awaited first!");
17579 const nativeResponseValue = wasm.TS_Hostname_free(this_obj);
17580 // debug statements here
17582 // uint64_t Hostname_clone_ptr(LDKHostname *NONNULL_PTR arg);
17584 export function Hostname_clone_ptr(arg: bigint): bigint {
17585 if(!isWasmInitialized) {
17586 throw new Error("initializeWasm() must be awaited first!");
17588 const nativeResponseValue = wasm.TS_Hostname_clone_ptr(arg);
17589 return nativeResponseValue;
17591 // struct LDKHostname Hostname_clone(const struct LDKHostname *NONNULL_PTR orig);
17593 export function Hostname_clone(orig: bigint): bigint {
17594 if(!isWasmInitialized) {
17595 throw new Error("initializeWasm() must be awaited first!");
17597 const nativeResponseValue = wasm.TS_Hostname_clone(orig);
17598 return nativeResponseValue;
17600 // bool Hostname_eq(const struct LDKHostname *NONNULL_PTR a, const struct LDKHostname *NONNULL_PTR b);
17602 export function Hostname_eq(a: bigint, b: bigint): boolean {
17603 if(!isWasmInitialized) {
17604 throw new Error("initializeWasm() must be awaited first!");
17606 const nativeResponseValue = wasm.TS_Hostname_eq(a, b);
17607 return nativeResponseValue;
17609 // MUST_USE_RES uint8_t Hostname_len(const struct LDKHostname *NONNULL_PTR this_arg);
17611 export function Hostname_len(this_arg: bigint): number {
17612 if(!isWasmInitialized) {
17613 throw new Error("initializeWasm() must be awaited first!");
17615 const nativeResponseValue = wasm.TS_Hostname_len(this_arg);
17616 return nativeResponseValue;
17618 // struct LDKCResult_StringErrorZ sign(struct LDKu8slice msg, const uint8_t (*sk)[32]);
17620 export function sign(msg: number, sk: number): bigint {
17621 if(!isWasmInitialized) {
17622 throw new Error("initializeWasm() must be awaited first!");
17624 const nativeResponseValue = wasm.TS_sign(msg, sk);
17625 return nativeResponseValue;
17627 // struct LDKCResult_PublicKeyErrorZ recover_pk(struct LDKu8slice msg, struct LDKStr sig);
17629 export function recover_pk(msg: number, sig: number): bigint {
17630 if(!isWasmInitialized) {
17631 throw new Error("initializeWasm() must be awaited first!");
17633 const nativeResponseValue = wasm.TS_recover_pk(msg, sig);
17634 return nativeResponseValue;
17636 // bool verify(struct LDKu8slice msg, struct LDKStr sig, struct LDKPublicKey pk);
17638 export function verify(msg: number, sig: number, pk: number): boolean {
17639 if(!isWasmInitialized) {
17640 throw new Error("initializeWasm() must be awaited first!");
17642 const nativeResponseValue = wasm.TS_verify(msg, sig, pk);
17643 return nativeResponseValue;
17645 // struct LDKCVec_u8Z construct_invoice_preimage(struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z data_without_signature);
17647 export function construct_invoice_preimage(hrp_bytes: number, data_without_signature: number): number {
17648 if(!isWasmInitialized) {
17649 throw new Error("initializeWasm() must be awaited first!");
17651 const nativeResponseValue = wasm.TS_construct_invoice_preimage(hrp_bytes, data_without_signature);
17652 return nativeResponseValue;
17654 // void Persister_free(struct LDKPersister this_ptr);
17656 export function Persister_free(this_ptr: bigint): void {
17657 if(!isWasmInitialized) {
17658 throw new Error("initializeWasm() must be awaited first!");
17660 const nativeResponseValue = wasm.TS_Persister_free(this_ptr);
17661 // debug statements here
17663 // void FutureCallback_free(struct LDKFutureCallback this_ptr);
17665 export function FutureCallback_free(this_ptr: bigint): void {
17666 if(!isWasmInitialized) {
17667 throw new Error("initializeWasm() must be awaited first!");
17669 const nativeResponseValue = wasm.TS_FutureCallback_free(this_ptr);
17670 // debug statements here
17672 // void Future_free(struct LDKFuture this_obj);
17674 export function Future_free(this_obj: bigint): void {
17675 if(!isWasmInitialized) {
17676 throw new Error("initializeWasm() must be awaited first!");
17678 const nativeResponseValue = wasm.TS_Future_free(this_obj);
17679 // debug statements here
17681 // void Future_register_callback_fn(const struct LDKFuture *NONNULL_PTR this_arg, struct LDKFutureCallback callback);
17683 export function Future_register_callback_fn(this_arg: bigint, callback: bigint): void {
17684 if(!isWasmInitialized) {
17685 throw new Error("initializeWasm() must be awaited first!");
17687 const nativeResponseValue = wasm.TS_Future_register_callback_fn(this_arg, callback);
17688 // debug statements here
17690 // enum LDKLevel Level_clone(const enum LDKLevel *NONNULL_PTR orig);
17692 export function Level_clone(orig: bigint): Level {
17693 if(!isWasmInitialized) {
17694 throw new Error("initializeWasm() must be awaited first!");
17696 const nativeResponseValue = wasm.TS_Level_clone(orig);
17697 return nativeResponseValue;
17699 // enum LDKLevel Level_gossip(void);
17701 export function Level_gossip(): Level {
17702 if(!isWasmInitialized) {
17703 throw new Error("initializeWasm() must be awaited first!");
17705 const nativeResponseValue = wasm.TS_Level_gossip();
17706 return nativeResponseValue;
17708 // enum LDKLevel Level_trace(void);
17710 export function Level_trace(): Level {
17711 if(!isWasmInitialized) {
17712 throw new Error("initializeWasm() must be awaited first!");
17714 const nativeResponseValue = wasm.TS_Level_trace();
17715 return nativeResponseValue;
17717 // enum LDKLevel Level_debug(void);
17719 export function Level_debug(): Level {
17720 if(!isWasmInitialized) {
17721 throw new Error("initializeWasm() must be awaited first!");
17723 const nativeResponseValue = wasm.TS_Level_debug();
17724 return nativeResponseValue;
17726 // enum LDKLevel Level_info(void);
17728 export function Level_info(): Level {
17729 if(!isWasmInitialized) {
17730 throw new Error("initializeWasm() must be awaited first!");
17732 const nativeResponseValue = wasm.TS_Level_info();
17733 return nativeResponseValue;
17735 // enum LDKLevel Level_warn(void);
17737 export function Level_warn(): Level {
17738 if(!isWasmInitialized) {
17739 throw new Error("initializeWasm() must be awaited first!");
17741 const nativeResponseValue = wasm.TS_Level_warn();
17742 return nativeResponseValue;
17744 // enum LDKLevel Level_error(void);
17746 export function Level_error(): Level {
17747 if(!isWasmInitialized) {
17748 throw new Error("initializeWasm() must be awaited first!");
17750 const nativeResponseValue = wasm.TS_Level_error();
17751 return nativeResponseValue;
17753 // bool Level_eq(const enum LDKLevel *NONNULL_PTR a, const enum LDKLevel *NONNULL_PTR b);
17755 export function Level_eq(a: bigint, b: bigint): boolean {
17756 if(!isWasmInitialized) {
17757 throw new Error("initializeWasm() must be awaited first!");
17759 const nativeResponseValue = wasm.TS_Level_eq(a, b);
17760 return nativeResponseValue;
17762 // uint64_t Level_hash(const enum LDKLevel *NONNULL_PTR o);
17764 export function Level_hash(o: bigint): bigint {
17765 if(!isWasmInitialized) {
17766 throw new Error("initializeWasm() must be awaited first!");
17768 const nativeResponseValue = wasm.TS_Level_hash(o);
17769 return nativeResponseValue;
17771 // MUST_USE_RES enum LDKLevel Level_max(void);
17773 export function Level_max(): Level {
17774 if(!isWasmInitialized) {
17775 throw new Error("initializeWasm() must be awaited first!");
17777 const nativeResponseValue = wasm.TS_Level_max();
17778 return nativeResponseValue;
17780 // void Record_free(struct LDKRecord this_obj);
17782 export function Record_free(this_obj: bigint): void {
17783 if(!isWasmInitialized) {
17784 throw new Error("initializeWasm() must be awaited first!");
17786 const nativeResponseValue = wasm.TS_Record_free(this_obj);
17787 // debug statements here
17789 // enum LDKLevel Record_get_level(const struct LDKRecord *NONNULL_PTR this_ptr);
17791 export function Record_get_level(this_ptr: bigint): Level {
17792 if(!isWasmInitialized) {
17793 throw new Error("initializeWasm() must be awaited first!");
17795 const nativeResponseValue = wasm.TS_Record_get_level(this_ptr);
17796 return nativeResponseValue;
17798 // void Record_set_level(struct LDKRecord *NONNULL_PTR this_ptr, enum LDKLevel val);
17800 export function Record_set_level(this_ptr: bigint, val: Level): void {
17801 if(!isWasmInitialized) {
17802 throw new Error("initializeWasm() must be awaited first!");
17804 const nativeResponseValue = wasm.TS_Record_set_level(this_ptr, val);
17805 // debug statements here
17807 // struct LDKStr Record_get_args(const struct LDKRecord *NONNULL_PTR this_ptr);
17809 export function Record_get_args(this_ptr: bigint): number {
17810 if(!isWasmInitialized) {
17811 throw new Error("initializeWasm() must be awaited first!");
17813 const nativeResponseValue = wasm.TS_Record_get_args(this_ptr);
17814 return nativeResponseValue;
17816 // void Record_set_args(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
17818 export function Record_set_args(this_ptr: bigint, val: number): void {
17819 if(!isWasmInitialized) {
17820 throw new Error("initializeWasm() must be awaited first!");
17822 const nativeResponseValue = wasm.TS_Record_set_args(this_ptr, val);
17823 // debug statements here
17825 // struct LDKStr Record_get_module_path(const struct LDKRecord *NONNULL_PTR this_ptr);
17827 export function Record_get_module_path(this_ptr: bigint): number {
17828 if(!isWasmInitialized) {
17829 throw new Error("initializeWasm() must be awaited first!");
17831 const nativeResponseValue = wasm.TS_Record_get_module_path(this_ptr);
17832 return nativeResponseValue;
17834 // void Record_set_module_path(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
17836 export function Record_set_module_path(this_ptr: bigint, val: number): void {
17837 if(!isWasmInitialized) {
17838 throw new Error("initializeWasm() must be awaited first!");
17840 const nativeResponseValue = wasm.TS_Record_set_module_path(this_ptr, val);
17841 // debug statements here
17843 // struct LDKStr Record_get_file(const struct LDKRecord *NONNULL_PTR this_ptr);
17845 export function Record_get_file(this_ptr: bigint): number {
17846 if(!isWasmInitialized) {
17847 throw new Error("initializeWasm() must be awaited first!");
17849 const nativeResponseValue = wasm.TS_Record_get_file(this_ptr);
17850 return nativeResponseValue;
17852 // void Record_set_file(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
17854 export function Record_set_file(this_ptr: bigint, val: number): void {
17855 if(!isWasmInitialized) {
17856 throw new Error("initializeWasm() must be awaited first!");
17858 const nativeResponseValue = wasm.TS_Record_set_file(this_ptr, val);
17859 // debug statements here
17861 // uint32_t Record_get_line(const struct LDKRecord *NONNULL_PTR this_ptr);
17863 export function Record_get_line(this_ptr: bigint): number {
17864 if(!isWasmInitialized) {
17865 throw new Error("initializeWasm() must be awaited first!");
17867 const nativeResponseValue = wasm.TS_Record_get_line(this_ptr);
17868 return nativeResponseValue;
17870 // void Record_set_line(struct LDKRecord *NONNULL_PTR this_ptr, uint32_t val);
17872 export function Record_set_line(this_ptr: bigint, val: number): void {
17873 if(!isWasmInitialized) {
17874 throw new Error("initializeWasm() must be awaited first!");
17876 const nativeResponseValue = wasm.TS_Record_set_line(this_ptr, val);
17877 // debug statements here
17879 // uint64_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg);
17881 export function Record_clone_ptr(arg: bigint): bigint {
17882 if(!isWasmInitialized) {
17883 throw new Error("initializeWasm() must be awaited first!");
17885 const nativeResponseValue = wasm.TS_Record_clone_ptr(arg);
17886 return nativeResponseValue;
17888 // struct LDKRecord Record_clone(const struct LDKRecord *NONNULL_PTR orig);
17890 export function Record_clone(orig: bigint): bigint {
17891 if(!isWasmInitialized) {
17892 throw new Error("initializeWasm() must be awaited first!");
17894 const nativeResponseValue = wasm.TS_Record_clone(orig);
17895 return nativeResponseValue;
17897 // void Logger_free(struct LDKLogger this_ptr);
17899 export function Logger_free(this_ptr: bigint): void {
17900 if(!isWasmInitialized) {
17901 throw new Error("initializeWasm() must be awaited first!");
17903 const nativeResponseValue = wasm.TS_Logger_free(this_ptr);
17904 // debug statements here
17906 // void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_obj);
17908 export function ChannelHandshakeConfig_free(this_obj: bigint): void {
17909 if(!isWasmInitialized) {
17910 throw new Error("initializeWasm() must be awaited first!");
17912 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_free(this_obj);
17913 // debug statements here
17915 // uint32_t ChannelHandshakeConfig_get_minimum_depth(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
17917 export function ChannelHandshakeConfig_get_minimum_depth(this_ptr: bigint): number {
17918 if(!isWasmInitialized) {
17919 throw new Error("initializeWasm() must be awaited first!");
17921 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_minimum_depth(this_ptr);
17922 return nativeResponseValue;
17924 // void ChannelHandshakeConfig_set_minimum_depth(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
17926 export function ChannelHandshakeConfig_set_minimum_depth(this_ptr: bigint, val: number): void {
17927 if(!isWasmInitialized) {
17928 throw new Error("initializeWasm() must be awaited first!");
17930 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_minimum_depth(this_ptr, val);
17931 // debug statements here
17933 // uint16_t ChannelHandshakeConfig_get_our_to_self_delay(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
17935 export function ChannelHandshakeConfig_get_our_to_self_delay(this_ptr: bigint): number {
17936 if(!isWasmInitialized) {
17937 throw new Error("initializeWasm() must be awaited first!");
17939 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_to_self_delay(this_ptr);
17940 return nativeResponseValue;
17942 // void ChannelHandshakeConfig_set_our_to_self_delay(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
17944 export function ChannelHandshakeConfig_set_our_to_self_delay(this_ptr: bigint, val: number): void {
17945 if(!isWasmInitialized) {
17946 throw new Error("initializeWasm() must be awaited first!");
17948 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_to_self_delay(this_ptr, val);
17949 // debug statements here
17951 // uint64_t ChannelHandshakeConfig_get_our_htlc_minimum_msat(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
17953 export function ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr: bigint): bigint {
17954 if(!isWasmInitialized) {
17955 throw new Error("initializeWasm() must be awaited first!");
17957 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr);
17958 return nativeResponseValue;
17960 // void ChannelHandshakeConfig_set_our_htlc_minimum_msat(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint64_t val);
17962 export function ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
17963 if(!isWasmInitialized) {
17964 throw new Error("initializeWasm() must be awaited first!");
17966 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr, val);
17967 // debug statements here
17969 // uint8_t ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
17971 export function ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: bigint): number {
17972 if(!isWasmInitialized) {
17973 throw new Error("initializeWasm() must be awaited first!");
17975 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr);
17976 return nativeResponseValue;
17978 // void ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint8_t val);
17980 export function ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: bigint, val: number): void {
17981 if(!isWasmInitialized) {
17982 throw new Error("initializeWasm() must be awaited first!");
17984 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr, val);
17985 // debug statements here
17987 // bool ChannelHandshakeConfig_get_negotiate_scid_privacy(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
17989 export function ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr: bigint): boolean {
17990 if(!isWasmInitialized) {
17991 throw new Error("initializeWasm() must be awaited first!");
17993 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr);
17994 return nativeResponseValue;
17996 // void ChannelHandshakeConfig_set_negotiate_scid_privacy(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
17998 export function ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr: bigint, val: boolean): void {
17999 if(!isWasmInitialized) {
18000 throw new Error("initializeWasm() must be awaited first!");
18002 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr, val);
18003 // debug statements here
18005 // bool ChannelHandshakeConfig_get_announced_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
18007 export function ChannelHandshakeConfig_get_announced_channel(this_ptr: bigint): boolean {
18008 if(!isWasmInitialized) {
18009 throw new Error("initializeWasm() must be awaited first!");
18011 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_announced_channel(this_ptr);
18012 return nativeResponseValue;
18014 // void ChannelHandshakeConfig_set_announced_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
18016 export function ChannelHandshakeConfig_set_announced_channel(this_ptr: bigint, val: boolean): void {
18017 if(!isWasmInitialized) {
18018 throw new Error("initializeWasm() must be awaited first!");
18020 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_announced_channel(this_ptr, val);
18021 // debug statements here
18023 // bool ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
18025 export function ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr: bigint): boolean {
18026 if(!isWasmInitialized) {
18027 throw new Error("initializeWasm() must be awaited first!");
18029 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr);
18030 return nativeResponseValue;
18032 // void ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
18034 export function ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr: bigint, val: boolean): void {
18035 if(!isWasmInitialized) {
18036 throw new Error("initializeWasm() must be awaited first!");
18038 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr, val);
18039 // debug statements here
18041 // uint32_t ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
18043 export function ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(this_ptr: bigint): number {
18044 if(!isWasmInitialized) {
18045 throw new Error("initializeWasm() must be awaited first!");
18047 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(this_ptr);
18048 return nativeResponseValue;
18050 // void ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
18052 export function ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(this_ptr: bigint, val: number): void {
18053 if(!isWasmInitialized) {
18054 throw new Error("initializeWasm() must be awaited first!");
18056 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(this_ptr, val);
18057 // debug statements here
18059 // 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);
18061 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 {
18062 if(!isWasmInitialized) {
18063 throw new Error("initializeWasm() must be awaited first!");
18065 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);
18066 return nativeResponseValue;
18068 // uint64_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg);
18070 export function ChannelHandshakeConfig_clone_ptr(arg: bigint): bigint {
18071 if(!isWasmInitialized) {
18072 throw new Error("initializeWasm() must be awaited first!");
18074 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone_ptr(arg);
18075 return nativeResponseValue;
18077 // struct LDKChannelHandshakeConfig ChannelHandshakeConfig_clone(const struct LDKChannelHandshakeConfig *NONNULL_PTR orig);
18079 export function ChannelHandshakeConfig_clone(orig: bigint): bigint {
18080 if(!isWasmInitialized) {
18081 throw new Error("initializeWasm() must be awaited first!");
18083 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone(orig);
18084 return nativeResponseValue;
18086 // MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void);
18088 export function ChannelHandshakeConfig_default(): bigint {
18089 if(!isWasmInitialized) {
18090 throw new Error("initializeWasm() must be awaited first!");
18092 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_default();
18093 return nativeResponseValue;
18095 // void ChannelHandshakeLimits_free(struct LDKChannelHandshakeLimits this_obj);
18097 export function ChannelHandshakeLimits_free(this_obj: bigint): void {
18098 if(!isWasmInitialized) {
18099 throw new Error("initializeWasm() must be awaited first!");
18101 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_free(this_obj);
18102 // debug statements here
18104 // uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
18106 export function ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr: bigint): bigint {
18107 if(!isWasmInitialized) {
18108 throw new Error("initializeWasm() must be awaited first!");
18110 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr);
18111 return nativeResponseValue;
18113 // void ChannelHandshakeLimits_set_min_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
18115 export function ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr: bigint, val: bigint): void {
18116 if(!isWasmInitialized) {
18117 throw new Error("initializeWasm() must be awaited first!");
18119 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr, val);
18120 // debug statements here
18122 // uint64_t ChannelHandshakeLimits_get_max_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
18124 export function ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr: bigint): bigint {
18125 if(!isWasmInitialized) {
18126 throw new Error("initializeWasm() must be awaited first!");
18128 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr);
18129 return nativeResponseValue;
18131 // void ChannelHandshakeLimits_set_max_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
18133 export function ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr: bigint, val: bigint): void {
18134 if(!isWasmInitialized) {
18135 throw new Error("initializeWasm() must be awaited first!");
18137 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr, val);
18138 // debug statements here
18140 // uint64_t ChannelHandshakeLimits_get_max_htlc_minimum_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
18142 export function ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr: bigint): bigint {
18143 if(!isWasmInitialized) {
18144 throw new Error("initializeWasm() must be awaited first!");
18146 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr);
18147 return nativeResponseValue;
18149 // void ChannelHandshakeLimits_set_max_htlc_minimum_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
18151 export function ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
18152 if(!isWasmInitialized) {
18153 throw new Error("initializeWasm() must be awaited first!");
18155 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr, val);
18156 // debug statements here
18158 // uint64_t ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
18160 export function ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
18161 if(!isWasmInitialized) {
18162 throw new Error("initializeWasm() must be awaited first!");
18164 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr);
18165 return nativeResponseValue;
18167 // void ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
18169 export function ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
18170 if(!isWasmInitialized) {
18171 throw new Error("initializeWasm() must be awaited first!");
18173 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr, val);
18174 // debug statements here
18176 // uint64_t ChannelHandshakeLimits_get_max_channel_reserve_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
18178 export function ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr: bigint): bigint {
18179 if(!isWasmInitialized) {
18180 throw new Error("initializeWasm() must be awaited first!");
18182 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr);
18183 return nativeResponseValue;
18185 // void ChannelHandshakeLimits_set_max_channel_reserve_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
18187 export function ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
18188 if(!isWasmInitialized) {
18189 throw new Error("initializeWasm() must be awaited first!");
18191 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr, val);
18192 // debug statements here
18194 // uint16_t ChannelHandshakeLimits_get_min_max_accepted_htlcs(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
18196 export function ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr: bigint): number {
18197 if(!isWasmInitialized) {
18198 throw new Error("initializeWasm() must be awaited first!");
18200 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr);
18201 return nativeResponseValue;
18203 // void ChannelHandshakeLimits_set_min_max_accepted_htlcs(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
18205 export function ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr: bigint, val: number): void {
18206 if(!isWasmInitialized) {
18207 throw new Error("initializeWasm() must be awaited first!");
18209 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr, val);
18210 // debug statements here
18212 // uint32_t ChannelHandshakeLimits_get_max_minimum_depth(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
18214 export function ChannelHandshakeLimits_get_max_minimum_depth(this_ptr: bigint): number {
18215 if(!isWasmInitialized) {
18216 throw new Error("initializeWasm() must be awaited first!");
18218 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_minimum_depth(this_ptr);
18219 return nativeResponseValue;
18221 // void ChannelHandshakeLimits_set_max_minimum_depth(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint32_t val);
18223 export function ChannelHandshakeLimits_set_max_minimum_depth(this_ptr: bigint, val: number): void {
18224 if(!isWasmInitialized) {
18225 throw new Error("initializeWasm() must be awaited first!");
18227 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_minimum_depth(this_ptr, val);
18228 // debug statements here
18230 // bool ChannelHandshakeLimits_get_trust_own_funding_0conf(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
18232 export function ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr: bigint): boolean {
18233 if(!isWasmInitialized) {
18234 throw new Error("initializeWasm() must be awaited first!");
18236 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr);
18237 return nativeResponseValue;
18239 // void ChannelHandshakeLimits_set_trust_own_funding_0conf(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
18241 export function ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr: bigint, val: boolean): void {
18242 if(!isWasmInitialized) {
18243 throw new Error("initializeWasm() must be awaited first!");
18245 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr, val);
18246 // debug statements here
18248 // bool ChannelHandshakeLimits_get_force_announced_channel_preference(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
18250 export function ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr: bigint): boolean {
18251 if(!isWasmInitialized) {
18252 throw new Error("initializeWasm() must be awaited first!");
18254 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr);
18255 return nativeResponseValue;
18257 // void ChannelHandshakeLimits_set_force_announced_channel_preference(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
18259 export function ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr: bigint, val: boolean): void {
18260 if(!isWasmInitialized) {
18261 throw new Error("initializeWasm() must be awaited first!");
18263 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr, val);
18264 // debug statements here
18266 // uint16_t ChannelHandshakeLimits_get_their_to_self_delay(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
18268 export function ChannelHandshakeLimits_get_their_to_self_delay(this_ptr: bigint): number {
18269 if(!isWasmInitialized) {
18270 throw new Error("initializeWasm() must be awaited first!");
18272 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_their_to_self_delay(this_ptr);
18273 return nativeResponseValue;
18275 // void ChannelHandshakeLimits_set_their_to_self_delay(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
18277 export function ChannelHandshakeLimits_set_their_to_self_delay(this_ptr: bigint, val: number): void {
18278 if(!isWasmInitialized) {
18279 throw new Error("initializeWasm() must be awaited first!");
18281 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_their_to_self_delay(this_ptr, val);
18282 // debug statements here
18284 // 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);
18286 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 {
18287 if(!isWasmInitialized) {
18288 throw new Error("initializeWasm() must be awaited first!");
18290 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);
18291 return nativeResponseValue;
18293 // uint64_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg);
18295 export function ChannelHandshakeLimits_clone_ptr(arg: bigint): bigint {
18296 if(!isWasmInitialized) {
18297 throw new Error("initializeWasm() must be awaited first!");
18299 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone_ptr(arg);
18300 return nativeResponseValue;
18302 // struct LDKChannelHandshakeLimits ChannelHandshakeLimits_clone(const struct LDKChannelHandshakeLimits *NONNULL_PTR orig);
18304 export function ChannelHandshakeLimits_clone(orig: bigint): bigint {
18305 if(!isWasmInitialized) {
18306 throw new Error("initializeWasm() must be awaited first!");
18308 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone(orig);
18309 return nativeResponseValue;
18311 // MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_default(void);
18313 export function ChannelHandshakeLimits_default(): bigint {
18314 if(!isWasmInitialized) {
18315 throw new Error("initializeWasm() must be awaited first!");
18317 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_default();
18318 return nativeResponseValue;
18320 // void ChannelConfig_free(struct LDKChannelConfig this_obj);
18322 export function ChannelConfig_free(this_obj: bigint): void {
18323 if(!isWasmInitialized) {
18324 throw new Error("initializeWasm() must be awaited first!");
18326 const nativeResponseValue = wasm.TS_ChannelConfig_free(this_obj);
18327 // debug statements here
18329 // uint32_t ChannelConfig_get_forwarding_fee_proportional_millionths(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
18331 export function ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr: bigint): number {
18332 if(!isWasmInitialized) {
18333 throw new Error("initializeWasm() must be awaited first!");
18335 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr);
18336 return nativeResponseValue;
18338 // void ChannelConfig_set_forwarding_fee_proportional_millionths(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
18340 export function ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr: bigint, val: number): void {
18341 if(!isWasmInitialized) {
18342 throw new Error("initializeWasm() must be awaited first!");
18344 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr, val);
18345 // debug statements here
18347 // uint32_t ChannelConfig_get_forwarding_fee_base_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
18349 export function ChannelConfig_get_forwarding_fee_base_msat(this_ptr: bigint): number {
18350 if(!isWasmInitialized) {
18351 throw new Error("initializeWasm() must be awaited first!");
18353 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_base_msat(this_ptr);
18354 return nativeResponseValue;
18356 // void ChannelConfig_set_forwarding_fee_base_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
18358 export function ChannelConfig_set_forwarding_fee_base_msat(this_ptr: bigint, val: number): void {
18359 if(!isWasmInitialized) {
18360 throw new Error("initializeWasm() must be awaited first!");
18362 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_base_msat(this_ptr, val);
18363 // debug statements here
18365 // uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
18367 export function ChannelConfig_get_cltv_expiry_delta(this_ptr: bigint): number {
18368 if(!isWasmInitialized) {
18369 throw new Error("initializeWasm() must be awaited first!");
18371 const nativeResponseValue = wasm.TS_ChannelConfig_get_cltv_expiry_delta(this_ptr);
18372 return nativeResponseValue;
18374 // void ChannelConfig_set_cltv_expiry_delta(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint16_t val);
18376 export function ChannelConfig_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
18377 if(!isWasmInitialized) {
18378 throw new Error("initializeWasm() must be awaited first!");
18380 const nativeResponseValue = wasm.TS_ChannelConfig_set_cltv_expiry_delta(this_ptr, val);
18381 // debug statements here
18383 // uint64_t ChannelConfig_get_max_dust_htlc_exposure_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
18385 export function ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr: bigint): bigint {
18386 if(!isWasmInitialized) {
18387 throw new Error("initializeWasm() must be awaited first!");
18389 const nativeResponseValue = wasm.TS_ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr);
18390 return nativeResponseValue;
18392 // void ChannelConfig_set_max_dust_htlc_exposure_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
18394 export function ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr: bigint, val: bigint): void {
18395 if(!isWasmInitialized) {
18396 throw new Error("initializeWasm() must be awaited first!");
18398 const nativeResponseValue = wasm.TS_ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr, val);
18399 // debug statements here
18401 // uint64_t ChannelConfig_get_force_close_avoidance_max_fee_satoshis(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
18403 export function ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr: bigint): bigint {
18404 if(!isWasmInitialized) {
18405 throw new Error("initializeWasm() must be awaited first!");
18407 const nativeResponseValue = wasm.TS_ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr);
18408 return nativeResponseValue;
18410 // void ChannelConfig_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
18412 export function ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr: bigint, val: bigint): void {
18413 if(!isWasmInitialized) {
18414 throw new Error("initializeWasm() must be awaited first!");
18416 const nativeResponseValue = wasm.TS_ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr, val);
18417 // debug statements here
18419 // 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);
18421 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 {
18422 if(!isWasmInitialized) {
18423 throw new Error("initializeWasm() must be awaited first!");
18425 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);
18426 return nativeResponseValue;
18428 // uint64_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg);
18430 export function ChannelConfig_clone_ptr(arg: bigint): bigint {
18431 if(!isWasmInitialized) {
18432 throw new Error("initializeWasm() must be awaited first!");
18434 const nativeResponseValue = wasm.TS_ChannelConfig_clone_ptr(arg);
18435 return nativeResponseValue;
18437 // struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
18439 export function ChannelConfig_clone(orig: bigint): bigint {
18440 if(!isWasmInitialized) {
18441 throw new Error("initializeWasm() must be awaited first!");
18443 const nativeResponseValue = wasm.TS_ChannelConfig_clone(orig);
18444 return nativeResponseValue;
18446 // bool ChannelConfig_eq(const struct LDKChannelConfig *NONNULL_PTR a, const struct LDKChannelConfig *NONNULL_PTR b);
18448 export function ChannelConfig_eq(a: bigint, b: bigint): boolean {
18449 if(!isWasmInitialized) {
18450 throw new Error("initializeWasm() must be awaited first!");
18452 const nativeResponseValue = wasm.TS_ChannelConfig_eq(a, b);
18453 return nativeResponseValue;
18455 // MUST_USE_RES struct LDKChannelConfig ChannelConfig_default(void);
18457 export function ChannelConfig_default(): bigint {
18458 if(!isWasmInitialized) {
18459 throw new Error("initializeWasm() must be awaited first!");
18461 const nativeResponseValue = wasm.TS_ChannelConfig_default();
18462 return nativeResponseValue;
18464 // struct LDKCVec_u8Z ChannelConfig_write(const struct LDKChannelConfig *NONNULL_PTR obj);
18466 export function ChannelConfig_write(obj: bigint): number {
18467 if(!isWasmInitialized) {
18468 throw new Error("initializeWasm() must be awaited first!");
18470 const nativeResponseValue = wasm.TS_ChannelConfig_write(obj);
18471 return nativeResponseValue;
18473 // struct LDKCResult_ChannelConfigDecodeErrorZ ChannelConfig_read(struct LDKu8slice ser);
18475 export function ChannelConfig_read(ser: number): bigint {
18476 if(!isWasmInitialized) {
18477 throw new Error("initializeWasm() must be awaited first!");
18479 const nativeResponseValue = wasm.TS_ChannelConfig_read(ser);
18480 return nativeResponseValue;
18482 // void UserConfig_free(struct LDKUserConfig this_obj);
18484 export function UserConfig_free(this_obj: bigint): void {
18485 if(!isWasmInitialized) {
18486 throw new Error("initializeWasm() must be awaited first!");
18488 const nativeResponseValue = wasm.TS_UserConfig_free(this_obj);
18489 // debug statements here
18491 // struct LDKChannelHandshakeConfig UserConfig_get_channel_handshake_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
18493 export function UserConfig_get_channel_handshake_config(this_ptr: bigint): bigint {
18494 if(!isWasmInitialized) {
18495 throw new Error("initializeWasm() must be awaited first!");
18497 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_config(this_ptr);
18498 return nativeResponseValue;
18500 // void UserConfig_set_channel_handshake_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeConfig val);
18502 export function UserConfig_set_channel_handshake_config(this_ptr: bigint, val: bigint): void {
18503 if(!isWasmInitialized) {
18504 throw new Error("initializeWasm() must be awaited first!");
18506 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_config(this_ptr, val);
18507 // debug statements here
18509 // struct LDKChannelHandshakeLimits UserConfig_get_channel_handshake_limits(const struct LDKUserConfig *NONNULL_PTR this_ptr);
18511 export function UserConfig_get_channel_handshake_limits(this_ptr: bigint): bigint {
18512 if(!isWasmInitialized) {
18513 throw new Error("initializeWasm() must be awaited first!");
18515 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_limits(this_ptr);
18516 return nativeResponseValue;
18518 // void UserConfig_set_channel_handshake_limits(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeLimits val);
18520 export function UserConfig_set_channel_handshake_limits(this_ptr: bigint, val: bigint): void {
18521 if(!isWasmInitialized) {
18522 throw new Error("initializeWasm() must be awaited first!");
18524 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_limits(this_ptr, val);
18525 // debug statements here
18527 // struct LDKChannelConfig UserConfig_get_channel_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
18529 export function UserConfig_get_channel_config(this_ptr: bigint): bigint {
18530 if(!isWasmInitialized) {
18531 throw new Error("initializeWasm() must be awaited first!");
18533 const nativeResponseValue = wasm.TS_UserConfig_get_channel_config(this_ptr);
18534 return nativeResponseValue;
18536 // void UserConfig_set_channel_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
18538 export function UserConfig_set_channel_config(this_ptr: bigint, val: bigint): void {
18539 if(!isWasmInitialized) {
18540 throw new Error("initializeWasm() must be awaited first!");
18542 const nativeResponseValue = wasm.TS_UserConfig_set_channel_config(this_ptr, val);
18543 // debug statements here
18545 // bool UserConfig_get_accept_forwards_to_priv_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
18547 export function UserConfig_get_accept_forwards_to_priv_channels(this_ptr: bigint): boolean {
18548 if(!isWasmInitialized) {
18549 throw new Error("initializeWasm() must be awaited first!");
18551 const nativeResponseValue = wasm.TS_UserConfig_get_accept_forwards_to_priv_channels(this_ptr);
18552 return nativeResponseValue;
18554 // void UserConfig_set_accept_forwards_to_priv_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
18556 export function UserConfig_set_accept_forwards_to_priv_channels(this_ptr: bigint, val: boolean): void {
18557 if(!isWasmInitialized) {
18558 throw new Error("initializeWasm() must be awaited first!");
18560 const nativeResponseValue = wasm.TS_UserConfig_set_accept_forwards_to_priv_channels(this_ptr, val);
18561 // debug statements here
18563 // bool UserConfig_get_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
18565 export function UserConfig_get_accept_inbound_channels(this_ptr: bigint): boolean {
18566 if(!isWasmInitialized) {
18567 throw new Error("initializeWasm() must be awaited first!");
18569 const nativeResponseValue = wasm.TS_UserConfig_get_accept_inbound_channels(this_ptr);
18570 return nativeResponseValue;
18572 // void UserConfig_set_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
18574 export function UserConfig_set_accept_inbound_channels(this_ptr: bigint, val: boolean): void {
18575 if(!isWasmInitialized) {
18576 throw new Error("initializeWasm() must be awaited first!");
18578 const nativeResponseValue = wasm.TS_UserConfig_set_accept_inbound_channels(this_ptr, val);
18579 // debug statements here
18581 // bool UserConfig_get_manually_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
18583 export function UserConfig_get_manually_accept_inbound_channels(this_ptr: bigint): boolean {
18584 if(!isWasmInitialized) {
18585 throw new Error("initializeWasm() must be awaited first!");
18587 const nativeResponseValue = wasm.TS_UserConfig_get_manually_accept_inbound_channels(this_ptr);
18588 return nativeResponseValue;
18590 // void UserConfig_set_manually_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
18592 export function UserConfig_set_manually_accept_inbound_channels(this_ptr: bigint, val: boolean): void {
18593 if(!isWasmInitialized) {
18594 throw new Error("initializeWasm() must be awaited first!");
18596 const nativeResponseValue = wasm.TS_UserConfig_set_manually_accept_inbound_channels(this_ptr, val);
18597 // debug statements here
18599 // 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);
18601 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 {
18602 if(!isWasmInitialized) {
18603 throw new Error("initializeWasm() must be awaited first!");
18605 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);
18606 return nativeResponseValue;
18608 // uint64_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg);
18610 export function UserConfig_clone_ptr(arg: bigint): bigint {
18611 if(!isWasmInitialized) {
18612 throw new Error("initializeWasm() must be awaited first!");
18614 const nativeResponseValue = wasm.TS_UserConfig_clone_ptr(arg);
18615 return nativeResponseValue;
18617 // struct LDKUserConfig UserConfig_clone(const struct LDKUserConfig *NONNULL_PTR orig);
18619 export function UserConfig_clone(orig: bigint): bigint {
18620 if(!isWasmInitialized) {
18621 throw new Error("initializeWasm() must be awaited first!");
18623 const nativeResponseValue = wasm.TS_UserConfig_clone(orig);
18624 return nativeResponseValue;
18626 // MUST_USE_RES struct LDKUserConfig UserConfig_default(void);
18628 export function UserConfig_default(): bigint {
18629 if(!isWasmInitialized) {
18630 throw new Error("initializeWasm() must be awaited first!");
18632 const nativeResponseValue = wasm.TS_UserConfig_default();
18633 return nativeResponseValue;
18635 // void BestBlock_free(struct LDKBestBlock this_obj);
18637 export function BestBlock_free(this_obj: bigint): void {
18638 if(!isWasmInitialized) {
18639 throw new Error("initializeWasm() must be awaited first!");
18641 const nativeResponseValue = wasm.TS_BestBlock_free(this_obj);
18642 // debug statements here
18644 // uint64_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg);
18646 export function BestBlock_clone_ptr(arg: bigint): bigint {
18647 if(!isWasmInitialized) {
18648 throw new Error("initializeWasm() must be awaited first!");
18650 const nativeResponseValue = wasm.TS_BestBlock_clone_ptr(arg);
18651 return nativeResponseValue;
18653 // struct LDKBestBlock BestBlock_clone(const struct LDKBestBlock *NONNULL_PTR orig);
18655 export function BestBlock_clone(orig: bigint): bigint {
18656 if(!isWasmInitialized) {
18657 throw new Error("initializeWasm() must be awaited first!");
18659 const nativeResponseValue = wasm.TS_BestBlock_clone(orig);
18660 return nativeResponseValue;
18662 // bool BestBlock_eq(const struct LDKBestBlock *NONNULL_PTR a, const struct LDKBestBlock *NONNULL_PTR b);
18664 export function BestBlock_eq(a: bigint, b: bigint): boolean {
18665 if(!isWasmInitialized) {
18666 throw new Error("initializeWasm() must be awaited first!");
18668 const nativeResponseValue = wasm.TS_BestBlock_eq(a, b);
18669 return nativeResponseValue;
18671 // MUST_USE_RES struct LDKBestBlock BestBlock_from_genesis(enum LDKNetwork network);
18673 export function BestBlock_from_genesis(network: Network): bigint {
18674 if(!isWasmInitialized) {
18675 throw new Error("initializeWasm() must be awaited first!");
18677 const nativeResponseValue = wasm.TS_BestBlock_from_genesis(network);
18678 return nativeResponseValue;
18680 // MUST_USE_RES struct LDKBestBlock BestBlock_new(struct LDKThirtyTwoBytes block_hash, uint32_t height);
18682 export function BestBlock_new(block_hash: number, height: number): bigint {
18683 if(!isWasmInitialized) {
18684 throw new Error("initializeWasm() must be awaited first!");
18686 const nativeResponseValue = wasm.TS_BestBlock_new(block_hash, height);
18687 return nativeResponseValue;
18689 // MUST_USE_RES struct LDKThirtyTwoBytes BestBlock_block_hash(const struct LDKBestBlock *NONNULL_PTR this_arg);
18691 export function BestBlock_block_hash(this_arg: bigint): number {
18692 if(!isWasmInitialized) {
18693 throw new Error("initializeWasm() must be awaited first!");
18695 const nativeResponseValue = wasm.TS_BestBlock_block_hash(this_arg);
18696 return nativeResponseValue;
18698 // MUST_USE_RES uint32_t BestBlock_height(const struct LDKBestBlock *NONNULL_PTR this_arg);
18700 export function BestBlock_height(this_arg: bigint): number {
18701 if(!isWasmInitialized) {
18702 throw new Error("initializeWasm() must be awaited first!");
18704 const nativeResponseValue = wasm.TS_BestBlock_height(this_arg);
18705 return nativeResponseValue;
18707 // enum LDKAccessError AccessError_clone(const enum LDKAccessError *NONNULL_PTR orig);
18709 export function AccessError_clone(orig: bigint): AccessError {
18710 if(!isWasmInitialized) {
18711 throw new Error("initializeWasm() must be awaited first!");
18713 const nativeResponseValue = wasm.TS_AccessError_clone(orig);
18714 return nativeResponseValue;
18716 // enum LDKAccessError AccessError_unknown_chain(void);
18718 export function AccessError_unknown_chain(): AccessError {
18719 if(!isWasmInitialized) {
18720 throw new Error("initializeWasm() must be awaited first!");
18722 const nativeResponseValue = wasm.TS_AccessError_unknown_chain();
18723 return nativeResponseValue;
18725 // enum LDKAccessError AccessError_unknown_tx(void);
18727 export function AccessError_unknown_tx(): AccessError {
18728 if(!isWasmInitialized) {
18729 throw new Error("initializeWasm() must be awaited first!");
18731 const nativeResponseValue = wasm.TS_AccessError_unknown_tx();
18732 return nativeResponseValue;
18734 // void Access_free(struct LDKAccess this_ptr);
18736 export function Access_free(this_ptr: bigint): void {
18737 if(!isWasmInitialized) {
18738 throw new Error("initializeWasm() must be awaited first!");
18740 const nativeResponseValue = wasm.TS_Access_free(this_ptr);
18741 // debug statements here
18743 // void Listen_free(struct LDKListen this_ptr);
18745 export function Listen_free(this_ptr: bigint): void {
18746 if(!isWasmInitialized) {
18747 throw new Error("initializeWasm() must be awaited first!");
18749 const nativeResponseValue = wasm.TS_Listen_free(this_ptr);
18750 // debug statements here
18752 // void Confirm_free(struct LDKConfirm this_ptr);
18754 export function Confirm_free(this_ptr: bigint): void {
18755 if(!isWasmInitialized) {
18756 throw new Error("initializeWasm() must be awaited first!");
18758 const nativeResponseValue = wasm.TS_Confirm_free(this_ptr);
18759 // debug statements here
18761 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_clone(const enum LDKChannelMonitorUpdateStatus *NONNULL_PTR orig);
18763 export function ChannelMonitorUpdateStatus_clone(orig: bigint): ChannelMonitorUpdateStatus {
18764 if(!isWasmInitialized) {
18765 throw new Error("initializeWasm() must be awaited first!");
18767 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_clone(orig);
18768 return nativeResponseValue;
18770 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_completed(void);
18772 export function ChannelMonitorUpdateStatus_completed(): ChannelMonitorUpdateStatus {
18773 if(!isWasmInitialized) {
18774 throw new Error("initializeWasm() must be awaited first!");
18776 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_completed();
18777 return nativeResponseValue;
18779 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_in_progress(void);
18781 export function ChannelMonitorUpdateStatus_in_progress(): ChannelMonitorUpdateStatus {
18782 if(!isWasmInitialized) {
18783 throw new Error("initializeWasm() must be awaited first!");
18785 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_in_progress();
18786 return nativeResponseValue;
18788 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_permanent_failure(void);
18790 export function ChannelMonitorUpdateStatus_permanent_failure(): ChannelMonitorUpdateStatus {
18791 if(!isWasmInitialized) {
18792 throw new Error("initializeWasm() must be awaited first!");
18794 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_permanent_failure();
18795 return nativeResponseValue;
18797 // bool ChannelMonitorUpdateStatus_eq(const enum LDKChannelMonitorUpdateStatus *NONNULL_PTR a, const enum LDKChannelMonitorUpdateStatus *NONNULL_PTR b);
18799 export function ChannelMonitorUpdateStatus_eq(a: bigint, b: bigint): boolean {
18800 if(!isWasmInitialized) {
18801 throw new Error("initializeWasm() must be awaited first!");
18803 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_eq(a, b);
18804 return nativeResponseValue;
18806 // void Watch_free(struct LDKWatch this_ptr);
18808 export function Watch_free(this_ptr: bigint): void {
18809 if(!isWasmInitialized) {
18810 throw new Error("initializeWasm() must be awaited first!");
18812 const nativeResponseValue = wasm.TS_Watch_free(this_ptr);
18813 // debug statements here
18815 // void Filter_free(struct LDKFilter this_ptr);
18817 export function Filter_free(this_ptr: bigint): void {
18818 if(!isWasmInitialized) {
18819 throw new Error("initializeWasm() must be awaited first!");
18821 const nativeResponseValue = wasm.TS_Filter_free(this_ptr);
18822 // debug statements here
18824 // void WatchedOutput_free(struct LDKWatchedOutput this_obj);
18826 export function WatchedOutput_free(this_obj: bigint): void {
18827 if(!isWasmInitialized) {
18828 throw new Error("initializeWasm() must be awaited first!");
18830 const nativeResponseValue = wasm.TS_WatchedOutput_free(this_obj);
18831 // debug statements here
18833 // struct LDKThirtyTwoBytes WatchedOutput_get_block_hash(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
18835 export function WatchedOutput_get_block_hash(this_ptr: bigint): number {
18836 if(!isWasmInitialized) {
18837 throw new Error("initializeWasm() must be awaited first!");
18839 const nativeResponseValue = wasm.TS_WatchedOutput_get_block_hash(this_ptr);
18840 return nativeResponseValue;
18842 // void WatchedOutput_set_block_hash(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18844 export function WatchedOutput_set_block_hash(this_ptr: bigint, val: number): void {
18845 if(!isWasmInitialized) {
18846 throw new Error("initializeWasm() must be awaited first!");
18848 const nativeResponseValue = wasm.TS_WatchedOutput_set_block_hash(this_ptr, val);
18849 // debug statements here
18851 // struct LDKOutPoint WatchedOutput_get_outpoint(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
18853 export function WatchedOutput_get_outpoint(this_ptr: bigint): bigint {
18854 if(!isWasmInitialized) {
18855 throw new Error("initializeWasm() must be awaited first!");
18857 const nativeResponseValue = wasm.TS_WatchedOutput_get_outpoint(this_ptr);
18858 return nativeResponseValue;
18860 // void WatchedOutput_set_outpoint(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
18862 export function WatchedOutput_set_outpoint(this_ptr: bigint, val: bigint): void {
18863 if(!isWasmInitialized) {
18864 throw new Error("initializeWasm() must be awaited first!");
18866 const nativeResponseValue = wasm.TS_WatchedOutput_set_outpoint(this_ptr, val);
18867 // debug statements here
18869 // struct LDKu8slice WatchedOutput_get_script_pubkey(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
18871 export function WatchedOutput_get_script_pubkey(this_ptr: bigint): number {
18872 if(!isWasmInitialized) {
18873 throw new Error("initializeWasm() must be awaited first!");
18875 const nativeResponseValue = wasm.TS_WatchedOutput_get_script_pubkey(this_ptr);
18876 return nativeResponseValue;
18878 // void WatchedOutput_set_script_pubkey(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
18880 export function WatchedOutput_set_script_pubkey(this_ptr: bigint, val: number): void {
18881 if(!isWasmInitialized) {
18882 throw new Error("initializeWasm() must be awaited first!");
18884 const nativeResponseValue = wasm.TS_WatchedOutput_set_script_pubkey(this_ptr, val);
18885 // debug statements here
18887 // MUST_USE_RES struct LDKWatchedOutput WatchedOutput_new(struct LDKThirtyTwoBytes block_hash_arg, struct LDKOutPoint outpoint_arg, struct LDKCVec_u8Z script_pubkey_arg);
18889 export function WatchedOutput_new(block_hash_arg: number, outpoint_arg: bigint, script_pubkey_arg: number): bigint {
18890 if(!isWasmInitialized) {
18891 throw new Error("initializeWasm() must be awaited first!");
18893 const nativeResponseValue = wasm.TS_WatchedOutput_new(block_hash_arg, outpoint_arg, script_pubkey_arg);
18894 return nativeResponseValue;
18896 // uint64_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg);
18898 export function WatchedOutput_clone_ptr(arg: bigint): bigint {
18899 if(!isWasmInitialized) {
18900 throw new Error("initializeWasm() must be awaited first!");
18902 const nativeResponseValue = wasm.TS_WatchedOutput_clone_ptr(arg);
18903 return nativeResponseValue;
18905 // struct LDKWatchedOutput WatchedOutput_clone(const struct LDKWatchedOutput *NONNULL_PTR orig);
18907 export function WatchedOutput_clone(orig: bigint): bigint {
18908 if(!isWasmInitialized) {
18909 throw new Error("initializeWasm() must be awaited first!");
18911 const nativeResponseValue = wasm.TS_WatchedOutput_clone(orig);
18912 return nativeResponseValue;
18914 // bool WatchedOutput_eq(const struct LDKWatchedOutput *NONNULL_PTR a, const struct LDKWatchedOutput *NONNULL_PTR b);
18916 export function WatchedOutput_eq(a: bigint, b: bigint): boolean {
18917 if(!isWasmInitialized) {
18918 throw new Error("initializeWasm() must be awaited first!");
18920 const nativeResponseValue = wasm.TS_WatchedOutput_eq(a, b);
18921 return nativeResponseValue;
18923 // uint64_t WatchedOutput_hash(const struct LDKWatchedOutput *NONNULL_PTR o);
18925 export function WatchedOutput_hash(o: bigint): bigint {
18926 if(!isWasmInitialized) {
18927 throw new Error("initializeWasm() must be awaited first!");
18929 const nativeResponseValue = wasm.TS_WatchedOutput_hash(o);
18930 return nativeResponseValue;
18932 // void BroadcasterInterface_free(struct LDKBroadcasterInterface this_ptr);
18934 export function BroadcasterInterface_free(this_ptr: bigint): void {
18935 if(!isWasmInitialized) {
18936 throw new Error("initializeWasm() must be awaited first!");
18938 const nativeResponseValue = wasm.TS_BroadcasterInterface_free(this_ptr);
18939 // debug statements here
18941 // enum LDKConfirmationTarget ConfirmationTarget_clone(const enum LDKConfirmationTarget *NONNULL_PTR orig);
18943 export function ConfirmationTarget_clone(orig: bigint): ConfirmationTarget {
18944 if(!isWasmInitialized) {
18945 throw new Error("initializeWasm() must be awaited first!");
18947 const nativeResponseValue = wasm.TS_ConfirmationTarget_clone(orig);
18948 return nativeResponseValue;
18950 // enum LDKConfirmationTarget ConfirmationTarget_background(void);
18952 export function ConfirmationTarget_background(): ConfirmationTarget {
18953 if(!isWasmInitialized) {
18954 throw new Error("initializeWasm() must be awaited first!");
18956 const nativeResponseValue = wasm.TS_ConfirmationTarget_background();
18957 return nativeResponseValue;
18959 // enum LDKConfirmationTarget ConfirmationTarget_normal(void);
18961 export function ConfirmationTarget_normal(): ConfirmationTarget {
18962 if(!isWasmInitialized) {
18963 throw new Error("initializeWasm() must be awaited first!");
18965 const nativeResponseValue = wasm.TS_ConfirmationTarget_normal();
18966 return nativeResponseValue;
18968 // enum LDKConfirmationTarget ConfirmationTarget_high_priority(void);
18970 export function ConfirmationTarget_high_priority(): ConfirmationTarget {
18971 if(!isWasmInitialized) {
18972 throw new Error("initializeWasm() must be awaited first!");
18974 const nativeResponseValue = wasm.TS_ConfirmationTarget_high_priority();
18975 return nativeResponseValue;
18977 // bool ConfirmationTarget_eq(const enum LDKConfirmationTarget *NONNULL_PTR a, const enum LDKConfirmationTarget *NONNULL_PTR b);
18979 export function ConfirmationTarget_eq(a: bigint, b: bigint): boolean {
18980 if(!isWasmInitialized) {
18981 throw new Error("initializeWasm() must be awaited first!");
18983 const nativeResponseValue = wasm.TS_ConfirmationTarget_eq(a, b);
18984 return nativeResponseValue;
18986 // void FeeEstimator_free(struct LDKFeeEstimator this_ptr);
18988 export function FeeEstimator_free(this_ptr: bigint): void {
18989 if(!isWasmInitialized) {
18990 throw new Error("initializeWasm() must be awaited first!");
18992 const nativeResponseValue = wasm.TS_FeeEstimator_free(this_ptr);
18993 // debug statements here
18995 // void MonitorUpdateId_free(struct LDKMonitorUpdateId this_obj);
18997 export function MonitorUpdateId_free(this_obj: bigint): void {
18998 if(!isWasmInitialized) {
18999 throw new Error("initializeWasm() must be awaited first!");
19001 const nativeResponseValue = wasm.TS_MonitorUpdateId_free(this_obj);
19002 // debug statements here
19004 // uint64_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg);
19006 export function MonitorUpdateId_clone_ptr(arg: bigint): bigint {
19007 if(!isWasmInitialized) {
19008 throw new Error("initializeWasm() must be awaited first!");
19010 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone_ptr(arg);
19011 return nativeResponseValue;
19013 // struct LDKMonitorUpdateId MonitorUpdateId_clone(const struct LDKMonitorUpdateId *NONNULL_PTR orig);
19015 export function MonitorUpdateId_clone(orig: bigint): bigint {
19016 if(!isWasmInitialized) {
19017 throw new Error("initializeWasm() must be awaited first!");
19019 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone(orig);
19020 return nativeResponseValue;
19022 // uint64_t MonitorUpdateId_hash(const struct LDKMonitorUpdateId *NONNULL_PTR o);
19024 export function MonitorUpdateId_hash(o: bigint): bigint {
19025 if(!isWasmInitialized) {
19026 throw new Error("initializeWasm() must be awaited first!");
19028 const nativeResponseValue = wasm.TS_MonitorUpdateId_hash(o);
19029 return nativeResponseValue;
19031 // bool MonitorUpdateId_eq(const struct LDKMonitorUpdateId *NONNULL_PTR a, const struct LDKMonitorUpdateId *NONNULL_PTR b);
19033 export function MonitorUpdateId_eq(a: bigint, b: bigint): boolean {
19034 if(!isWasmInitialized) {
19035 throw new Error("initializeWasm() must be awaited first!");
19037 const nativeResponseValue = wasm.TS_MonitorUpdateId_eq(a, b);
19038 return nativeResponseValue;
19040 // void Persist_free(struct LDKPersist this_ptr);
19042 export function Persist_free(this_ptr: bigint): void {
19043 if(!isWasmInitialized) {
19044 throw new Error("initializeWasm() must be awaited first!");
19046 const nativeResponseValue = wasm.TS_Persist_free(this_ptr);
19047 // debug statements here
19049 // void LockedChannelMonitor_free(struct LDKLockedChannelMonitor this_obj);
19051 export function LockedChannelMonitor_free(this_obj: bigint): void {
19052 if(!isWasmInitialized) {
19053 throw new Error("initializeWasm() must be awaited first!");
19055 const nativeResponseValue = wasm.TS_LockedChannelMonitor_free(this_obj);
19056 // debug statements here
19058 // void ChainMonitor_free(struct LDKChainMonitor this_obj);
19060 export function ChainMonitor_free(this_obj: bigint): void {
19061 if(!isWasmInitialized) {
19062 throw new Error("initializeWasm() must be awaited first!");
19064 const nativeResponseValue = wasm.TS_ChainMonitor_free(this_obj);
19065 // debug statements here
19067 // MUST_USE_RES struct LDKChainMonitor ChainMonitor_new(struct LDKCOption_FilterZ chain_source, struct LDKBroadcasterInterface broadcaster, struct LDKLogger logger, struct LDKFeeEstimator feeest, struct LDKPersist persister);
19069 export function ChainMonitor_new(chain_source: bigint, broadcaster: bigint, logger: bigint, feeest: bigint, persister: bigint): bigint {
19070 if(!isWasmInitialized) {
19071 throw new Error("initializeWasm() must be awaited first!");
19073 const nativeResponseValue = wasm.TS_ChainMonitor_new(chain_source, broadcaster, logger, feeest, persister);
19074 return nativeResponseValue;
19076 // MUST_USE_RES struct LDKCVec_BalanceZ ChainMonitor_get_claimable_balances(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKCVec_ChannelDetailsZ ignored_channels);
19078 export function ChainMonitor_get_claimable_balances(this_arg: bigint, ignored_channels: number): number {
19079 if(!isWasmInitialized) {
19080 throw new Error("initializeWasm() must be awaited first!");
19082 const nativeResponseValue = wasm.TS_ChainMonitor_get_claimable_balances(this_arg, ignored_channels);
19083 return nativeResponseValue;
19085 // MUST_USE_RES struct LDKCResult_LockedChannelMonitorNoneZ ChainMonitor_get_monitor(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo);
19087 export function ChainMonitor_get_monitor(this_arg: bigint, funding_txo: bigint): bigint {
19088 if(!isWasmInitialized) {
19089 throw new Error("initializeWasm() must be awaited first!");
19091 const nativeResponseValue = wasm.TS_ChainMonitor_get_monitor(this_arg, funding_txo);
19092 return nativeResponseValue;
19094 // MUST_USE_RES struct LDKCVec_OutPointZ ChainMonitor_list_monitors(const struct LDKChainMonitor *NONNULL_PTR this_arg);
19096 export function ChainMonitor_list_monitors(this_arg: bigint): number {
19097 if(!isWasmInitialized) {
19098 throw new Error("initializeWasm() must be awaited first!");
19100 const nativeResponseValue = wasm.TS_ChainMonitor_list_monitors(this_arg);
19101 return nativeResponseValue;
19103 // 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);
19105 export function ChainMonitor_channel_monitor_updated(this_arg: bigint, funding_txo: bigint, completed_update_id: bigint): bigint {
19106 if(!isWasmInitialized) {
19107 throw new Error("initializeWasm() must be awaited first!");
19109 const nativeResponseValue = wasm.TS_ChainMonitor_channel_monitor_updated(this_arg, funding_txo, completed_update_id);
19110 return nativeResponseValue;
19112 // struct LDKListen ChainMonitor_as_Listen(const struct LDKChainMonitor *NONNULL_PTR this_arg);
19114 export function ChainMonitor_as_Listen(this_arg: bigint): bigint {
19115 if(!isWasmInitialized) {
19116 throw new Error("initializeWasm() must be awaited first!");
19118 const nativeResponseValue = wasm.TS_ChainMonitor_as_Listen(this_arg);
19119 return nativeResponseValue;
19121 // struct LDKConfirm ChainMonitor_as_Confirm(const struct LDKChainMonitor *NONNULL_PTR this_arg);
19123 export function ChainMonitor_as_Confirm(this_arg: bigint): bigint {
19124 if(!isWasmInitialized) {
19125 throw new Error("initializeWasm() must be awaited first!");
19127 const nativeResponseValue = wasm.TS_ChainMonitor_as_Confirm(this_arg);
19128 return nativeResponseValue;
19130 // struct LDKWatch ChainMonitor_as_Watch(const struct LDKChainMonitor *NONNULL_PTR this_arg);
19132 export function ChainMonitor_as_Watch(this_arg: bigint): bigint {
19133 if(!isWasmInitialized) {
19134 throw new Error("initializeWasm() must be awaited first!");
19136 const nativeResponseValue = wasm.TS_ChainMonitor_as_Watch(this_arg);
19137 return nativeResponseValue;
19139 // struct LDKEventsProvider ChainMonitor_as_EventsProvider(const struct LDKChainMonitor *NONNULL_PTR this_arg);
19141 export function ChainMonitor_as_EventsProvider(this_arg: bigint): bigint {
19142 if(!isWasmInitialized) {
19143 throw new Error("initializeWasm() must be awaited first!");
19145 const nativeResponseValue = wasm.TS_ChainMonitor_as_EventsProvider(this_arg);
19146 return nativeResponseValue;
19148 // void ChannelMonitorUpdate_free(struct LDKChannelMonitorUpdate this_obj);
19150 export function ChannelMonitorUpdate_free(this_obj: bigint): void {
19151 if(!isWasmInitialized) {
19152 throw new Error("initializeWasm() must be awaited first!");
19154 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_free(this_obj);
19155 // debug statements here
19157 // uint64_t ChannelMonitorUpdate_get_update_id(const struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr);
19159 export function ChannelMonitorUpdate_get_update_id(this_ptr: bigint): bigint {
19160 if(!isWasmInitialized) {
19161 throw new Error("initializeWasm() must be awaited first!");
19163 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_get_update_id(this_ptr);
19164 return nativeResponseValue;
19166 // void ChannelMonitorUpdate_set_update_id(struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr, uint64_t val);
19168 export function ChannelMonitorUpdate_set_update_id(this_ptr: bigint, val: bigint): void {
19169 if(!isWasmInitialized) {
19170 throw new Error("initializeWasm() must be awaited first!");
19172 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_set_update_id(this_ptr, val);
19173 // debug statements here
19175 // uint64_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg);
19177 export function ChannelMonitorUpdate_clone_ptr(arg: bigint): bigint {
19178 if(!isWasmInitialized) {
19179 throw new Error("initializeWasm() must be awaited first!");
19181 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone_ptr(arg);
19182 return nativeResponseValue;
19184 // struct LDKChannelMonitorUpdate ChannelMonitorUpdate_clone(const struct LDKChannelMonitorUpdate *NONNULL_PTR orig);
19186 export function ChannelMonitorUpdate_clone(orig: bigint): bigint {
19187 if(!isWasmInitialized) {
19188 throw new Error("initializeWasm() must be awaited first!");
19190 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone(orig);
19191 return nativeResponseValue;
19193 // struct LDKCVec_u8Z ChannelMonitorUpdate_write(const struct LDKChannelMonitorUpdate *NONNULL_PTR obj);
19195 export function ChannelMonitorUpdate_write(obj: bigint): number {
19196 if(!isWasmInitialized) {
19197 throw new Error("initializeWasm() must be awaited first!");
19199 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_write(obj);
19200 return nativeResponseValue;
19202 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ ChannelMonitorUpdate_read(struct LDKu8slice ser);
19204 export function ChannelMonitorUpdate_read(ser: number): bigint {
19205 if(!isWasmInitialized) {
19206 throw new Error("initializeWasm() must be awaited first!");
19208 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_read(ser);
19209 return nativeResponseValue;
19211 // void MonitorEvent_free(struct LDKMonitorEvent this_ptr);
19213 export function MonitorEvent_free(this_ptr: bigint): void {
19214 if(!isWasmInitialized) {
19215 throw new Error("initializeWasm() must be awaited first!");
19217 const nativeResponseValue = wasm.TS_MonitorEvent_free(this_ptr);
19218 // debug statements here
19220 // uint64_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg);
19222 export function MonitorEvent_clone_ptr(arg: bigint): bigint {
19223 if(!isWasmInitialized) {
19224 throw new Error("initializeWasm() must be awaited first!");
19226 const nativeResponseValue = wasm.TS_MonitorEvent_clone_ptr(arg);
19227 return nativeResponseValue;
19229 // struct LDKMonitorEvent MonitorEvent_clone(const struct LDKMonitorEvent *NONNULL_PTR orig);
19231 export function MonitorEvent_clone(orig: bigint): bigint {
19232 if(!isWasmInitialized) {
19233 throw new Error("initializeWasm() must be awaited first!");
19235 const nativeResponseValue = wasm.TS_MonitorEvent_clone(orig);
19236 return nativeResponseValue;
19238 // struct LDKMonitorEvent MonitorEvent_htlcevent(struct LDKHTLCUpdate a);
19240 export function MonitorEvent_htlcevent(a: bigint): bigint {
19241 if(!isWasmInitialized) {
19242 throw new Error("initializeWasm() must be awaited first!");
19244 const nativeResponseValue = wasm.TS_MonitorEvent_htlcevent(a);
19245 return nativeResponseValue;
19247 // struct LDKMonitorEvent MonitorEvent_commitment_tx_confirmed(struct LDKOutPoint a);
19249 export function MonitorEvent_commitment_tx_confirmed(a: bigint): bigint {
19250 if(!isWasmInitialized) {
19251 throw new Error("initializeWasm() must be awaited first!");
19253 const nativeResponseValue = wasm.TS_MonitorEvent_commitment_tx_confirmed(a);
19254 return nativeResponseValue;
19256 // struct LDKMonitorEvent MonitorEvent_completed(struct LDKOutPoint funding_txo, uint64_t monitor_update_id);
19258 export function MonitorEvent_completed(funding_txo: bigint, monitor_update_id: bigint): bigint {
19259 if(!isWasmInitialized) {
19260 throw new Error("initializeWasm() must be awaited first!");
19262 const nativeResponseValue = wasm.TS_MonitorEvent_completed(funding_txo, monitor_update_id);
19263 return nativeResponseValue;
19265 // struct LDKMonitorEvent MonitorEvent_update_failed(struct LDKOutPoint a);
19267 export function MonitorEvent_update_failed(a: bigint): bigint {
19268 if(!isWasmInitialized) {
19269 throw new Error("initializeWasm() must be awaited first!");
19271 const nativeResponseValue = wasm.TS_MonitorEvent_update_failed(a);
19272 return nativeResponseValue;
19274 // bool MonitorEvent_eq(const struct LDKMonitorEvent *NONNULL_PTR a, const struct LDKMonitorEvent *NONNULL_PTR b);
19276 export function MonitorEvent_eq(a: bigint, b: bigint): boolean {
19277 if(!isWasmInitialized) {
19278 throw new Error("initializeWasm() must be awaited first!");
19280 const nativeResponseValue = wasm.TS_MonitorEvent_eq(a, b);
19281 return nativeResponseValue;
19283 // struct LDKCVec_u8Z MonitorEvent_write(const struct LDKMonitorEvent *NONNULL_PTR obj);
19285 export function MonitorEvent_write(obj: bigint): number {
19286 if(!isWasmInitialized) {
19287 throw new Error("initializeWasm() must be awaited first!");
19289 const nativeResponseValue = wasm.TS_MonitorEvent_write(obj);
19290 return nativeResponseValue;
19292 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ MonitorEvent_read(struct LDKu8slice ser);
19294 export function MonitorEvent_read(ser: number): bigint {
19295 if(!isWasmInitialized) {
19296 throw new Error("initializeWasm() must be awaited first!");
19298 const nativeResponseValue = wasm.TS_MonitorEvent_read(ser);
19299 return nativeResponseValue;
19301 // void HTLCUpdate_free(struct LDKHTLCUpdate this_obj);
19303 export function HTLCUpdate_free(this_obj: bigint): void {
19304 if(!isWasmInitialized) {
19305 throw new Error("initializeWasm() must be awaited first!");
19307 const nativeResponseValue = wasm.TS_HTLCUpdate_free(this_obj);
19308 // debug statements here
19310 // uint64_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg);
19312 export function HTLCUpdate_clone_ptr(arg: bigint): bigint {
19313 if(!isWasmInitialized) {
19314 throw new Error("initializeWasm() must be awaited first!");
19316 const nativeResponseValue = wasm.TS_HTLCUpdate_clone_ptr(arg);
19317 return nativeResponseValue;
19319 // struct LDKHTLCUpdate HTLCUpdate_clone(const struct LDKHTLCUpdate *NONNULL_PTR orig);
19321 export function HTLCUpdate_clone(orig: bigint): bigint {
19322 if(!isWasmInitialized) {
19323 throw new Error("initializeWasm() must be awaited first!");
19325 const nativeResponseValue = wasm.TS_HTLCUpdate_clone(orig);
19326 return nativeResponseValue;
19328 // bool HTLCUpdate_eq(const struct LDKHTLCUpdate *NONNULL_PTR a, const struct LDKHTLCUpdate *NONNULL_PTR b);
19330 export function HTLCUpdate_eq(a: bigint, b: bigint): boolean {
19331 if(!isWasmInitialized) {
19332 throw new Error("initializeWasm() must be awaited first!");
19334 const nativeResponseValue = wasm.TS_HTLCUpdate_eq(a, b);
19335 return nativeResponseValue;
19337 // struct LDKCVec_u8Z HTLCUpdate_write(const struct LDKHTLCUpdate *NONNULL_PTR obj);
19339 export function HTLCUpdate_write(obj: bigint): number {
19340 if(!isWasmInitialized) {
19341 throw new Error("initializeWasm() must be awaited first!");
19343 const nativeResponseValue = wasm.TS_HTLCUpdate_write(obj);
19344 return nativeResponseValue;
19346 // struct LDKCResult_HTLCUpdateDecodeErrorZ HTLCUpdate_read(struct LDKu8slice ser);
19348 export function HTLCUpdate_read(ser: number): bigint {
19349 if(!isWasmInitialized) {
19350 throw new Error("initializeWasm() must be awaited first!");
19352 const nativeResponseValue = wasm.TS_HTLCUpdate_read(ser);
19353 return nativeResponseValue;
19355 // void Balance_free(struct LDKBalance this_ptr);
19357 export function Balance_free(this_ptr: bigint): void {
19358 if(!isWasmInitialized) {
19359 throw new Error("initializeWasm() must be awaited first!");
19361 const nativeResponseValue = wasm.TS_Balance_free(this_ptr);
19362 // debug statements here
19364 // uint64_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg);
19366 export function Balance_clone_ptr(arg: bigint): bigint {
19367 if(!isWasmInitialized) {
19368 throw new Error("initializeWasm() must be awaited first!");
19370 const nativeResponseValue = wasm.TS_Balance_clone_ptr(arg);
19371 return nativeResponseValue;
19373 // struct LDKBalance Balance_clone(const struct LDKBalance *NONNULL_PTR orig);
19375 export function Balance_clone(orig: bigint): bigint {
19376 if(!isWasmInitialized) {
19377 throw new Error("initializeWasm() must be awaited first!");
19379 const nativeResponseValue = wasm.TS_Balance_clone(orig);
19380 return nativeResponseValue;
19382 // struct LDKBalance Balance_claimable_on_channel_close(uint64_t claimable_amount_satoshis);
19384 export function Balance_claimable_on_channel_close(claimable_amount_satoshis: bigint): bigint {
19385 if(!isWasmInitialized) {
19386 throw new Error("initializeWasm() must be awaited first!");
19388 const nativeResponseValue = wasm.TS_Balance_claimable_on_channel_close(claimable_amount_satoshis);
19389 return nativeResponseValue;
19391 // struct LDKBalance Balance_claimable_awaiting_confirmations(uint64_t claimable_amount_satoshis, uint32_t confirmation_height);
19393 export function Balance_claimable_awaiting_confirmations(claimable_amount_satoshis: bigint, confirmation_height: number): bigint {
19394 if(!isWasmInitialized) {
19395 throw new Error("initializeWasm() must be awaited first!");
19397 const nativeResponseValue = wasm.TS_Balance_claimable_awaiting_confirmations(claimable_amount_satoshis, confirmation_height);
19398 return nativeResponseValue;
19400 // struct LDKBalance Balance_contentious_claimable(uint64_t claimable_amount_satoshis, uint32_t timeout_height);
19402 export function Balance_contentious_claimable(claimable_amount_satoshis: bigint, timeout_height: number): bigint {
19403 if(!isWasmInitialized) {
19404 throw new Error("initializeWasm() must be awaited first!");
19406 const nativeResponseValue = wasm.TS_Balance_contentious_claimable(claimable_amount_satoshis, timeout_height);
19407 return nativeResponseValue;
19409 // struct LDKBalance Balance_maybe_timeout_claimable_htlc(uint64_t claimable_amount_satoshis, uint32_t claimable_height);
19411 export function Balance_maybe_timeout_claimable_htlc(claimable_amount_satoshis: bigint, claimable_height: number): bigint {
19412 if(!isWasmInitialized) {
19413 throw new Error("initializeWasm() must be awaited first!");
19415 const nativeResponseValue = wasm.TS_Balance_maybe_timeout_claimable_htlc(claimable_amount_satoshis, claimable_height);
19416 return nativeResponseValue;
19418 // struct LDKBalance Balance_maybe_preimage_claimable_htlc(uint64_t claimable_amount_satoshis, uint32_t expiry_height);
19420 export function Balance_maybe_preimage_claimable_htlc(claimable_amount_satoshis: bigint, expiry_height: number): bigint {
19421 if(!isWasmInitialized) {
19422 throw new Error("initializeWasm() must be awaited first!");
19424 const nativeResponseValue = wasm.TS_Balance_maybe_preimage_claimable_htlc(claimable_amount_satoshis, expiry_height);
19425 return nativeResponseValue;
19427 // struct LDKBalance Balance_counterparty_revoked_output_claimable(uint64_t claimable_amount_satoshis);
19429 export function Balance_counterparty_revoked_output_claimable(claimable_amount_satoshis: bigint): bigint {
19430 if(!isWasmInitialized) {
19431 throw new Error("initializeWasm() must be awaited first!");
19433 const nativeResponseValue = wasm.TS_Balance_counterparty_revoked_output_claimable(claimable_amount_satoshis);
19434 return nativeResponseValue;
19436 // bool Balance_eq(const struct LDKBalance *NONNULL_PTR a, const struct LDKBalance *NONNULL_PTR b);
19438 export function Balance_eq(a: bigint, b: bigint): boolean {
19439 if(!isWasmInitialized) {
19440 throw new Error("initializeWasm() must be awaited first!");
19442 const nativeResponseValue = wasm.TS_Balance_eq(a, b);
19443 return nativeResponseValue;
19445 // void ChannelMonitor_free(struct LDKChannelMonitor this_obj);
19447 export function ChannelMonitor_free(this_obj: bigint): void {
19448 if(!isWasmInitialized) {
19449 throw new Error("initializeWasm() must be awaited first!");
19451 const nativeResponseValue = wasm.TS_ChannelMonitor_free(this_obj);
19452 // debug statements here
19454 // uint64_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg);
19456 export function ChannelMonitor_clone_ptr(arg: bigint): bigint {
19457 if(!isWasmInitialized) {
19458 throw new Error("initializeWasm() must be awaited first!");
19460 const nativeResponseValue = wasm.TS_ChannelMonitor_clone_ptr(arg);
19461 return nativeResponseValue;
19463 // struct LDKChannelMonitor ChannelMonitor_clone(const struct LDKChannelMonitor *NONNULL_PTR orig);
19465 export function ChannelMonitor_clone(orig: bigint): bigint {
19466 if(!isWasmInitialized) {
19467 throw new Error("initializeWasm() must be awaited first!");
19469 const nativeResponseValue = wasm.TS_ChannelMonitor_clone(orig);
19470 return nativeResponseValue;
19472 // struct LDKCVec_u8Z ChannelMonitor_write(const struct LDKChannelMonitor *NONNULL_PTR obj);
19474 export function ChannelMonitor_write(obj: bigint): number {
19475 if(!isWasmInitialized) {
19476 throw new Error("initializeWasm() must be awaited first!");
19478 const nativeResponseValue = wasm.TS_ChannelMonitor_write(obj);
19479 return nativeResponseValue;
19481 // 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);
19483 export function ChannelMonitor_update_monitor(this_arg: bigint, updates: bigint, broadcaster: bigint, fee_estimator: bigint, logger: bigint): bigint {
19484 if(!isWasmInitialized) {
19485 throw new Error("initializeWasm() must be awaited first!");
19487 const nativeResponseValue = wasm.TS_ChannelMonitor_update_monitor(this_arg, updates, broadcaster, fee_estimator, logger);
19488 return nativeResponseValue;
19490 // MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
19492 export function ChannelMonitor_get_latest_update_id(this_arg: bigint): bigint {
19493 if(!isWasmInitialized) {
19494 throw new Error("initializeWasm() must be awaited first!");
19496 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_update_id(this_arg);
19497 return nativeResponseValue;
19499 // MUST_USE_RES struct LDKC2Tuple_OutPointScriptZ ChannelMonitor_get_funding_txo(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
19501 export function ChannelMonitor_get_funding_txo(this_arg: bigint): bigint {
19502 if(!isWasmInitialized) {
19503 throw new Error("initializeWasm() must be awaited first!");
19505 const nativeResponseValue = wasm.TS_ChannelMonitor_get_funding_txo(this_arg);
19506 return nativeResponseValue;
19508 // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ChannelMonitor_get_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
19510 export function ChannelMonitor_get_outputs_to_watch(this_arg: bigint): number {
19511 if(!isWasmInitialized) {
19512 throw new Error("initializeWasm() must be awaited first!");
19514 const nativeResponseValue = wasm.TS_ChannelMonitor_get_outputs_to_watch(this_arg);
19515 return nativeResponseValue;
19517 // void ChannelMonitor_load_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKFilter *NONNULL_PTR filter);
19519 export function ChannelMonitor_load_outputs_to_watch(this_arg: bigint, filter: bigint): void {
19520 if(!isWasmInitialized) {
19521 throw new Error("initializeWasm() must be awaited first!");
19523 const nativeResponseValue = wasm.TS_ChannelMonitor_load_outputs_to_watch(this_arg, filter);
19524 // debug statements here
19526 // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
19528 export function ChannelMonitor_get_and_clear_pending_monitor_events(this_arg: bigint): number {
19529 if(!isWasmInitialized) {
19530 throw new Error("initializeWasm() must be awaited first!");
19532 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_monitor_events(this_arg);
19533 return nativeResponseValue;
19535 // MUST_USE_RES struct LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
19537 export function ChannelMonitor_get_and_clear_pending_events(this_arg: bigint): number {
19538 if(!isWasmInitialized) {
19539 throw new Error("initializeWasm() must be awaited first!");
19541 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_events(this_arg);
19542 return nativeResponseValue;
19544 // MUST_USE_RES struct LDKPublicKey ChannelMonitor_get_counterparty_node_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
19546 export function ChannelMonitor_get_counterparty_node_id(this_arg: bigint): number {
19547 if(!isWasmInitialized) {
19548 throw new Error("initializeWasm() must be awaited first!");
19550 const nativeResponseValue = wasm.TS_ChannelMonitor_get_counterparty_node_id(this_arg);
19551 return nativeResponseValue;
19553 // 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);
19555 export function ChannelMonitor_get_latest_holder_commitment_txn(this_arg: bigint, logger: bigint): number {
19556 if(!isWasmInitialized) {
19557 throw new Error("initializeWasm() must be awaited first!");
19559 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_holder_commitment_txn(this_arg, logger);
19560 return nativeResponseValue;
19562 // 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);
19564 export function ChannelMonitor_block_connected(this_arg: bigint, header: number, txdata: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
19565 if(!isWasmInitialized) {
19566 throw new Error("initializeWasm() must be awaited first!");
19568 const nativeResponseValue = wasm.TS_ChannelMonitor_block_connected(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
19569 return nativeResponseValue;
19571 // 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);
19573 export function ChannelMonitor_block_disconnected(this_arg: bigint, header: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
19574 if(!isWasmInitialized) {
19575 throw new Error("initializeWasm() must be awaited first!");
19577 const nativeResponseValue = wasm.TS_ChannelMonitor_block_disconnected(this_arg, header, height, broadcaster, fee_estimator, logger);
19578 // debug statements here
19580 // 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);
19582 export function ChannelMonitor_transactions_confirmed(this_arg: bigint, header: number, txdata: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
19583 if(!isWasmInitialized) {
19584 throw new Error("initializeWasm() must be awaited first!");
19586 const nativeResponseValue = wasm.TS_ChannelMonitor_transactions_confirmed(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
19587 return nativeResponseValue;
19589 // 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);
19591 export function ChannelMonitor_transaction_unconfirmed(this_arg: bigint, txid: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
19592 if(!isWasmInitialized) {
19593 throw new Error("initializeWasm() must be awaited first!");
19595 const nativeResponseValue = wasm.TS_ChannelMonitor_transaction_unconfirmed(this_arg, txid, broadcaster, fee_estimator, logger);
19596 // debug statements here
19598 // 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);
19600 export function ChannelMonitor_best_block_updated(this_arg: bigint, header: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
19601 if(!isWasmInitialized) {
19602 throw new Error("initializeWasm() must be awaited first!");
19604 const nativeResponseValue = wasm.TS_ChannelMonitor_best_block_updated(this_arg, header, height, broadcaster, fee_estimator, logger);
19605 return nativeResponseValue;
19607 // MUST_USE_RES struct LDKCVec_TxidZ ChannelMonitor_get_relevant_txids(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
19609 export function ChannelMonitor_get_relevant_txids(this_arg: bigint): number {
19610 if(!isWasmInitialized) {
19611 throw new Error("initializeWasm() must be awaited first!");
19613 const nativeResponseValue = wasm.TS_ChannelMonitor_get_relevant_txids(this_arg);
19614 return nativeResponseValue;
19616 // MUST_USE_RES struct LDKBestBlock ChannelMonitor_current_best_block(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
19618 export function ChannelMonitor_current_best_block(this_arg: bigint): bigint {
19619 if(!isWasmInitialized) {
19620 throw new Error("initializeWasm() must be awaited first!");
19622 const nativeResponseValue = wasm.TS_ChannelMonitor_current_best_block(this_arg);
19623 return nativeResponseValue;
19625 // MUST_USE_RES struct LDKCVec_BalanceZ ChannelMonitor_get_claimable_balances(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
19627 export function ChannelMonitor_get_claimable_balances(this_arg: bigint): number {
19628 if(!isWasmInitialized) {
19629 throw new Error("initializeWasm() must be awaited first!");
19631 const nativeResponseValue = wasm.TS_ChannelMonitor_get_claimable_balances(this_arg);
19632 return nativeResponseValue;
19634 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ C2Tuple_BlockHashChannelMonitorZ_read(struct LDKu8slice ser, const struct LDKKeysInterface *NONNULL_PTR arg);
19636 export function C2Tuple_BlockHashChannelMonitorZ_read(ser: number, arg: bigint): bigint {
19637 if(!isWasmInitialized) {
19638 throw new Error("initializeWasm() must be awaited first!");
19640 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_read(ser, arg);
19641 return nativeResponseValue;
19643 // void OutPoint_free(struct LDKOutPoint this_obj);
19645 export function OutPoint_free(this_obj: bigint): void {
19646 if(!isWasmInitialized) {
19647 throw new Error("initializeWasm() must be awaited first!");
19649 const nativeResponseValue = wasm.TS_OutPoint_free(this_obj);
19650 // debug statements here
19652 // const uint8_t (*OutPoint_get_txid(const struct LDKOutPoint *NONNULL_PTR this_ptr))[32];
19654 export function OutPoint_get_txid(this_ptr: bigint): number {
19655 if(!isWasmInitialized) {
19656 throw new Error("initializeWasm() must be awaited first!");
19658 const nativeResponseValue = wasm.TS_OutPoint_get_txid(this_ptr);
19659 return nativeResponseValue;
19661 // void OutPoint_set_txid(struct LDKOutPoint *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19663 export function OutPoint_set_txid(this_ptr: bigint, val: number): void {
19664 if(!isWasmInitialized) {
19665 throw new Error("initializeWasm() must be awaited first!");
19667 const nativeResponseValue = wasm.TS_OutPoint_set_txid(this_ptr, val);
19668 // debug statements here
19670 // uint16_t OutPoint_get_index(const struct LDKOutPoint *NONNULL_PTR this_ptr);
19672 export function OutPoint_get_index(this_ptr: bigint): number {
19673 if(!isWasmInitialized) {
19674 throw new Error("initializeWasm() must be awaited first!");
19676 const nativeResponseValue = wasm.TS_OutPoint_get_index(this_ptr);
19677 return nativeResponseValue;
19679 // void OutPoint_set_index(struct LDKOutPoint *NONNULL_PTR this_ptr, uint16_t val);
19681 export function OutPoint_set_index(this_ptr: bigint, val: number): void {
19682 if(!isWasmInitialized) {
19683 throw new Error("initializeWasm() must be awaited first!");
19685 const nativeResponseValue = wasm.TS_OutPoint_set_index(this_ptr, val);
19686 // debug statements here
19688 // MUST_USE_RES struct LDKOutPoint OutPoint_new(struct LDKThirtyTwoBytes txid_arg, uint16_t index_arg);
19690 export function OutPoint_new(txid_arg: number, index_arg: number): bigint {
19691 if(!isWasmInitialized) {
19692 throw new Error("initializeWasm() must be awaited first!");
19694 const nativeResponseValue = wasm.TS_OutPoint_new(txid_arg, index_arg);
19695 return nativeResponseValue;
19697 // uint64_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg);
19699 export function OutPoint_clone_ptr(arg: bigint): bigint {
19700 if(!isWasmInitialized) {
19701 throw new Error("initializeWasm() must be awaited first!");
19703 const nativeResponseValue = wasm.TS_OutPoint_clone_ptr(arg);
19704 return nativeResponseValue;
19706 // struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig);
19708 export function OutPoint_clone(orig: bigint): bigint {
19709 if(!isWasmInitialized) {
19710 throw new Error("initializeWasm() must be awaited first!");
19712 const nativeResponseValue = wasm.TS_OutPoint_clone(orig);
19713 return nativeResponseValue;
19715 // bool OutPoint_eq(const struct LDKOutPoint *NONNULL_PTR a, const struct LDKOutPoint *NONNULL_PTR b);
19717 export function OutPoint_eq(a: bigint, b: bigint): boolean {
19718 if(!isWasmInitialized) {
19719 throw new Error("initializeWasm() must be awaited first!");
19721 const nativeResponseValue = wasm.TS_OutPoint_eq(a, b);
19722 return nativeResponseValue;
19724 // uint64_t OutPoint_hash(const struct LDKOutPoint *NONNULL_PTR o);
19726 export function OutPoint_hash(o: bigint): bigint {
19727 if(!isWasmInitialized) {
19728 throw new Error("initializeWasm() must be awaited first!");
19730 const nativeResponseValue = wasm.TS_OutPoint_hash(o);
19731 return nativeResponseValue;
19733 // MUST_USE_RES struct LDKThirtyTwoBytes OutPoint_to_channel_id(const struct LDKOutPoint *NONNULL_PTR this_arg);
19735 export function OutPoint_to_channel_id(this_arg: bigint): number {
19736 if(!isWasmInitialized) {
19737 throw new Error("initializeWasm() must be awaited first!");
19739 const nativeResponseValue = wasm.TS_OutPoint_to_channel_id(this_arg);
19740 return nativeResponseValue;
19742 // struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj);
19744 export function OutPoint_write(obj: bigint): number {
19745 if(!isWasmInitialized) {
19746 throw new Error("initializeWasm() must be awaited first!");
19748 const nativeResponseValue = wasm.TS_OutPoint_write(obj);
19749 return nativeResponseValue;
19751 // struct LDKCResult_OutPointDecodeErrorZ OutPoint_read(struct LDKu8slice ser);
19753 export function OutPoint_read(ser: number): bigint {
19754 if(!isWasmInitialized) {
19755 throw new Error("initializeWasm() must be awaited first!");
19757 const nativeResponseValue = wasm.TS_OutPoint_read(ser);
19758 return nativeResponseValue;
19760 // void DelayedPaymentOutputDescriptor_free(struct LDKDelayedPaymentOutputDescriptor this_obj);
19762 export function DelayedPaymentOutputDescriptor_free(this_obj: bigint): void {
19763 if(!isWasmInitialized) {
19764 throw new Error("initializeWasm() must be awaited first!");
19766 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_free(this_obj);
19767 // debug statements here
19769 // struct LDKOutPoint DelayedPaymentOutputDescriptor_get_outpoint(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
19771 export function DelayedPaymentOutputDescriptor_get_outpoint(this_ptr: bigint): bigint {
19772 if(!isWasmInitialized) {
19773 throw new Error("initializeWasm() must be awaited first!");
19775 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_outpoint(this_ptr);
19776 return nativeResponseValue;
19778 // void DelayedPaymentOutputDescriptor_set_outpoint(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
19780 export function DelayedPaymentOutputDescriptor_set_outpoint(this_ptr: bigint, val: bigint): void {
19781 if(!isWasmInitialized) {
19782 throw new Error("initializeWasm() must be awaited first!");
19784 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_outpoint(this_ptr, val);
19785 // debug statements here
19787 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_per_commitment_point(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
19789 export function DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr: bigint): number {
19790 if(!isWasmInitialized) {
19791 throw new Error("initializeWasm() must be awaited first!");
19793 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr);
19794 return nativeResponseValue;
19796 // void DelayedPaymentOutputDescriptor_set_per_commitment_point(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19798 export function DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr: bigint, val: number): void {
19799 if(!isWasmInitialized) {
19800 throw new Error("initializeWasm() must be awaited first!");
19802 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr, val);
19803 // debug statements here
19805 // uint16_t DelayedPaymentOutputDescriptor_get_to_self_delay(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
19807 export function DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr: bigint): number {
19808 if(!isWasmInitialized) {
19809 throw new Error("initializeWasm() must be awaited first!");
19811 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr);
19812 return nativeResponseValue;
19814 // void DelayedPaymentOutputDescriptor_set_to_self_delay(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint16_t val);
19816 export function DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr: bigint, val: number): void {
19817 if(!isWasmInitialized) {
19818 throw new Error("initializeWasm() must be awaited first!");
19820 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr, val);
19821 // debug statements here
19823 // struct LDKTxOut DelayedPaymentOutputDescriptor_get_output(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
19825 export function DelayedPaymentOutputDescriptor_get_output(this_ptr: bigint): bigint {
19826 if(!isWasmInitialized) {
19827 throw new Error("initializeWasm() must be awaited first!");
19829 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_output(this_ptr);
19830 return nativeResponseValue;
19832 // void DelayedPaymentOutputDescriptor_set_output(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
19834 export function DelayedPaymentOutputDescriptor_set_output(this_ptr: bigint, val: bigint): void {
19835 if(!isWasmInitialized) {
19836 throw new Error("initializeWasm() must be awaited first!");
19838 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_output(this_ptr, val);
19839 // debug statements here
19841 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_revocation_pubkey(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
19843 export function DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr: bigint): number {
19844 if(!isWasmInitialized) {
19845 throw new Error("initializeWasm() must be awaited first!");
19847 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr);
19848 return nativeResponseValue;
19850 // void DelayedPaymentOutputDescriptor_set_revocation_pubkey(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19852 export function DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr: bigint, val: number): void {
19853 if(!isWasmInitialized) {
19854 throw new Error("initializeWasm() must be awaited first!");
19856 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr, val);
19857 // debug statements here
19859 // const uint8_t (*DelayedPaymentOutputDescriptor_get_channel_keys_id(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
19861 export function DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr: bigint): number {
19862 if(!isWasmInitialized) {
19863 throw new Error("initializeWasm() must be awaited first!");
19865 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
19866 return nativeResponseValue;
19868 // void DelayedPaymentOutputDescriptor_set_channel_keys_id(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19870 export function DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr: bigint, val: number): void {
19871 if(!isWasmInitialized) {
19872 throw new Error("initializeWasm() must be awaited first!");
19874 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
19875 // debug statements here
19877 // uint64_t DelayedPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
19879 export function DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: bigint): bigint {
19880 if(!isWasmInitialized) {
19881 throw new Error("initializeWasm() must be awaited first!");
19883 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
19884 return nativeResponseValue;
19886 // void DelayedPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
19888 export function DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
19889 if(!isWasmInitialized) {
19890 throw new Error("initializeWasm() must be awaited first!");
19892 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
19893 // debug statements here
19895 // 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);
19897 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 {
19898 if(!isWasmInitialized) {
19899 throw new Error("initializeWasm() must be awaited first!");
19901 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);
19902 return nativeResponseValue;
19904 // uint64_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg);
19906 export function DelayedPaymentOutputDescriptor_clone_ptr(arg: bigint): bigint {
19907 if(!isWasmInitialized) {
19908 throw new Error("initializeWasm() must be awaited first!");
19910 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone_ptr(arg);
19911 return nativeResponseValue;
19913 // struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_clone(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR orig);
19915 export function DelayedPaymentOutputDescriptor_clone(orig: bigint): bigint {
19916 if(!isWasmInitialized) {
19917 throw new Error("initializeWasm() must be awaited first!");
19919 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone(orig);
19920 return nativeResponseValue;
19922 // bool DelayedPaymentOutputDescriptor_eq(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR a, const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR b);
19924 export function DelayedPaymentOutputDescriptor_eq(a: bigint, b: bigint): boolean {
19925 if(!isWasmInitialized) {
19926 throw new Error("initializeWasm() must be awaited first!");
19928 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_eq(a, b);
19929 return nativeResponseValue;
19931 // struct LDKCVec_u8Z DelayedPaymentOutputDescriptor_write(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR obj);
19933 export function DelayedPaymentOutputDescriptor_write(obj: bigint): number {
19934 if(!isWasmInitialized) {
19935 throw new Error("initializeWasm() must be awaited first!");
19937 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_write(obj);
19938 return nativeResponseValue;
19940 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ DelayedPaymentOutputDescriptor_read(struct LDKu8slice ser);
19942 export function DelayedPaymentOutputDescriptor_read(ser: number): bigint {
19943 if(!isWasmInitialized) {
19944 throw new Error("initializeWasm() must be awaited first!");
19946 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_read(ser);
19947 return nativeResponseValue;
19949 // void StaticPaymentOutputDescriptor_free(struct LDKStaticPaymentOutputDescriptor this_obj);
19951 export function StaticPaymentOutputDescriptor_free(this_obj: bigint): void {
19952 if(!isWasmInitialized) {
19953 throw new Error("initializeWasm() must be awaited first!");
19955 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_free(this_obj);
19956 // debug statements here
19958 // struct LDKOutPoint StaticPaymentOutputDescriptor_get_outpoint(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
19960 export function StaticPaymentOutputDescriptor_get_outpoint(this_ptr: bigint): bigint {
19961 if(!isWasmInitialized) {
19962 throw new Error("initializeWasm() must be awaited first!");
19964 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_outpoint(this_ptr);
19965 return nativeResponseValue;
19967 // void StaticPaymentOutputDescriptor_set_outpoint(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
19969 export function StaticPaymentOutputDescriptor_set_outpoint(this_ptr: bigint, val: bigint): void {
19970 if(!isWasmInitialized) {
19971 throw new Error("initializeWasm() must be awaited first!");
19973 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_outpoint(this_ptr, val);
19974 // debug statements here
19976 // struct LDKTxOut StaticPaymentOutputDescriptor_get_output(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
19978 export function StaticPaymentOutputDescriptor_get_output(this_ptr: bigint): bigint {
19979 if(!isWasmInitialized) {
19980 throw new Error("initializeWasm() must be awaited first!");
19982 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_output(this_ptr);
19983 return nativeResponseValue;
19985 // void StaticPaymentOutputDescriptor_set_output(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
19987 export function StaticPaymentOutputDescriptor_set_output(this_ptr: bigint, val: bigint): void {
19988 if(!isWasmInitialized) {
19989 throw new Error("initializeWasm() must be awaited first!");
19991 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_output(this_ptr, val);
19992 // debug statements here
19994 // const uint8_t (*StaticPaymentOutputDescriptor_get_channel_keys_id(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
19996 export function StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr: bigint): number {
19997 if(!isWasmInitialized) {
19998 throw new Error("initializeWasm() must be awaited first!");
20000 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
20001 return nativeResponseValue;
20003 // void StaticPaymentOutputDescriptor_set_channel_keys_id(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20005 export function StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr: bigint, val: number): void {
20006 if(!isWasmInitialized) {
20007 throw new Error("initializeWasm() must be awaited first!");
20009 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
20010 // debug statements here
20012 // uint64_t StaticPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
20014 export function StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: bigint): bigint {
20015 if(!isWasmInitialized) {
20016 throw new Error("initializeWasm() must be awaited first!");
20018 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
20019 return nativeResponseValue;
20021 // void StaticPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
20023 export function StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
20024 if(!isWasmInitialized) {
20025 throw new Error("initializeWasm() must be awaited first!");
20027 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
20028 // debug statements here
20030 // 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);
20032 export function StaticPaymentOutputDescriptor_new(outpoint_arg: bigint, output_arg: bigint, channel_keys_id_arg: number, channel_value_satoshis_arg: bigint): bigint {
20033 if(!isWasmInitialized) {
20034 throw new Error("initializeWasm() must be awaited first!");
20036 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_new(outpoint_arg, output_arg, channel_keys_id_arg, channel_value_satoshis_arg);
20037 return nativeResponseValue;
20039 // uint64_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg);
20041 export function StaticPaymentOutputDescriptor_clone_ptr(arg: bigint): bigint {
20042 if(!isWasmInitialized) {
20043 throw new Error("initializeWasm() must be awaited first!");
20045 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone_ptr(arg);
20046 return nativeResponseValue;
20048 // struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_clone(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR orig);
20050 export function StaticPaymentOutputDescriptor_clone(orig: bigint): bigint {
20051 if(!isWasmInitialized) {
20052 throw new Error("initializeWasm() must be awaited first!");
20054 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone(orig);
20055 return nativeResponseValue;
20057 // bool StaticPaymentOutputDescriptor_eq(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR a, const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR b);
20059 export function StaticPaymentOutputDescriptor_eq(a: bigint, b: bigint): boolean {
20060 if(!isWasmInitialized) {
20061 throw new Error("initializeWasm() must be awaited first!");
20063 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_eq(a, b);
20064 return nativeResponseValue;
20066 // struct LDKCVec_u8Z StaticPaymentOutputDescriptor_write(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR obj);
20068 export function StaticPaymentOutputDescriptor_write(obj: bigint): number {
20069 if(!isWasmInitialized) {
20070 throw new Error("initializeWasm() must be awaited first!");
20072 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_write(obj);
20073 return nativeResponseValue;
20075 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ StaticPaymentOutputDescriptor_read(struct LDKu8slice ser);
20077 export function StaticPaymentOutputDescriptor_read(ser: number): bigint {
20078 if(!isWasmInitialized) {
20079 throw new Error("initializeWasm() must be awaited first!");
20081 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_read(ser);
20082 return nativeResponseValue;
20084 // void SpendableOutputDescriptor_free(struct LDKSpendableOutputDescriptor this_ptr);
20086 export function SpendableOutputDescriptor_free(this_ptr: bigint): void {
20087 if(!isWasmInitialized) {
20088 throw new Error("initializeWasm() must be awaited first!");
20090 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_free(this_ptr);
20091 // debug statements here
20093 // uint64_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg);
20095 export function SpendableOutputDescriptor_clone_ptr(arg: bigint): bigint {
20096 if(!isWasmInitialized) {
20097 throw new Error("initializeWasm() must be awaited first!");
20099 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone_ptr(arg);
20100 return nativeResponseValue;
20102 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_clone(const struct LDKSpendableOutputDescriptor *NONNULL_PTR orig);
20104 export function SpendableOutputDescriptor_clone(orig: bigint): bigint {
20105 if(!isWasmInitialized) {
20106 throw new Error("initializeWasm() must be awaited first!");
20108 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone(orig);
20109 return nativeResponseValue;
20111 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_output(struct LDKOutPoint outpoint, struct LDKTxOut output);
20113 export function SpendableOutputDescriptor_static_output(outpoint: bigint, output: bigint): bigint {
20114 if(!isWasmInitialized) {
20115 throw new Error("initializeWasm() must be awaited first!");
20117 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_output(outpoint, output);
20118 return nativeResponseValue;
20120 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_delayed_payment_output(struct LDKDelayedPaymentOutputDescriptor a);
20122 export function SpendableOutputDescriptor_delayed_payment_output(a: bigint): bigint {
20123 if(!isWasmInitialized) {
20124 throw new Error("initializeWasm() must be awaited first!");
20126 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_delayed_payment_output(a);
20127 return nativeResponseValue;
20129 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_payment_output(struct LDKStaticPaymentOutputDescriptor a);
20131 export function SpendableOutputDescriptor_static_payment_output(a: bigint): bigint {
20132 if(!isWasmInitialized) {
20133 throw new Error("initializeWasm() must be awaited first!");
20135 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_payment_output(a);
20136 return nativeResponseValue;
20138 // bool SpendableOutputDescriptor_eq(const struct LDKSpendableOutputDescriptor *NONNULL_PTR a, const struct LDKSpendableOutputDescriptor *NONNULL_PTR b);
20140 export function SpendableOutputDescriptor_eq(a: bigint, b: bigint): boolean {
20141 if(!isWasmInitialized) {
20142 throw new Error("initializeWasm() must be awaited first!");
20144 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_eq(a, b);
20145 return nativeResponseValue;
20147 // struct LDKCVec_u8Z SpendableOutputDescriptor_write(const struct LDKSpendableOutputDescriptor *NONNULL_PTR obj);
20149 export function SpendableOutputDescriptor_write(obj: bigint): number {
20150 if(!isWasmInitialized) {
20151 throw new Error("initializeWasm() must be awaited first!");
20153 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_write(obj);
20154 return nativeResponseValue;
20156 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ SpendableOutputDescriptor_read(struct LDKu8slice ser);
20158 export function SpendableOutputDescriptor_read(ser: number): bigint {
20159 if(!isWasmInitialized) {
20160 throw new Error("initializeWasm() must be awaited first!");
20162 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_read(ser);
20163 return nativeResponseValue;
20165 // void BaseSign_free(struct LDKBaseSign this_ptr);
20167 export function BaseSign_free(this_ptr: bigint): void {
20168 if(!isWasmInitialized) {
20169 throw new Error("initializeWasm() must be awaited first!");
20171 const nativeResponseValue = wasm.TS_BaseSign_free(this_ptr);
20172 // debug statements here
20174 // uint64_t Sign_clone_ptr(LDKSign *NONNULL_PTR arg);
20176 export function Sign_clone_ptr(arg: bigint): bigint {
20177 if(!isWasmInitialized) {
20178 throw new Error("initializeWasm() must be awaited first!");
20180 const nativeResponseValue = wasm.TS_Sign_clone_ptr(arg);
20181 return nativeResponseValue;
20183 // struct LDKSign Sign_clone(const struct LDKSign *NONNULL_PTR orig);
20185 export function Sign_clone(orig: bigint): bigint {
20186 if(!isWasmInitialized) {
20187 throw new Error("initializeWasm() must be awaited first!");
20189 const nativeResponseValue = wasm.TS_Sign_clone(orig);
20190 return nativeResponseValue;
20192 // void Sign_free(struct LDKSign this_ptr);
20194 export function Sign_free(this_ptr: bigint): void {
20195 if(!isWasmInitialized) {
20196 throw new Error("initializeWasm() must be awaited first!");
20198 const nativeResponseValue = wasm.TS_Sign_free(this_ptr);
20199 // debug statements here
20201 // enum LDKRecipient Recipient_clone(const enum LDKRecipient *NONNULL_PTR orig);
20203 export function Recipient_clone(orig: bigint): Recipient {
20204 if(!isWasmInitialized) {
20205 throw new Error("initializeWasm() must be awaited first!");
20207 const nativeResponseValue = wasm.TS_Recipient_clone(orig);
20208 return nativeResponseValue;
20210 // enum LDKRecipient Recipient_node(void);
20212 export function Recipient_node(): Recipient {
20213 if(!isWasmInitialized) {
20214 throw new Error("initializeWasm() must be awaited first!");
20216 const nativeResponseValue = wasm.TS_Recipient_node();
20217 return nativeResponseValue;
20219 // enum LDKRecipient Recipient_phantom_node(void);
20221 export function Recipient_phantom_node(): Recipient {
20222 if(!isWasmInitialized) {
20223 throw new Error("initializeWasm() must be awaited first!");
20225 const nativeResponseValue = wasm.TS_Recipient_phantom_node();
20226 return nativeResponseValue;
20228 // void KeysInterface_free(struct LDKKeysInterface this_ptr);
20230 export function KeysInterface_free(this_ptr: bigint): void {
20231 if(!isWasmInitialized) {
20232 throw new Error("initializeWasm() must be awaited first!");
20234 const nativeResponseValue = wasm.TS_KeysInterface_free(this_ptr);
20235 // debug statements here
20237 // void InMemorySigner_free(struct LDKInMemorySigner this_obj);
20239 export function InMemorySigner_free(this_obj: bigint): void {
20240 if(!isWasmInitialized) {
20241 throw new Error("initializeWasm() must be awaited first!");
20243 const nativeResponseValue = wasm.TS_InMemorySigner_free(this_obj);
20244 // debug statements here
20246 // const uint8_t (*InMemorySigner_get_funding_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
20248 export function InMemorySigner_get_funding_key(this_ptr: bigint): number {
20249 if(!isWasmInitialized) {
20250 throw new Error("initializeWasm() must be awaited first!");
20252 const nativeResponseValue = wasm.TS_InMemorySigner_get_funding_key(this_ptr);
20253 return nativeResponseValue;
20255 // void InMemorySigner_set_funding_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
20257 export function InMemorySigner_set_funding_key(this_ptr: bigint, val: number): void {
20258 if(!isWasmInitialized) {
20259 throw new Error("initializeWasm() must be awaited first!");
20261 const nativeResponseValue = wasm.TS_InMemorySigner_set_funding_key(this_ptr, val);
20262 // debug statements here
20264 // const uint8_t (*InMemorySigner_get_revocation_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
20266 export function InMemorySigner_get_revocation_base_key(this_ptr: bigint): number {
20267 if(!isWasmInitialized) {
20268 throw new Error("initializeWasm() must be awaited first!");
20270 const nativeResponseValue = wasm.TS_InMemorySigner_get_revocation_base_key(this_ptr);
20271 return nativeResponseValue;
20273 // void InMemorySigner_set_revocation_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
20275 export function InMemorySigner_set_revocation_base_key(this_ptr: bigint, val: number): void {
20276 if(!isWasmInitialized) {
20277 throw new Error("initializeWasm() must be awaited first!");
20279 const nativeResponseValue = wasm.TS_InMemorySigner_set_revocation_base_key(this_ptr, val);
20280 // debug statements here
20282 // const uint8_t (*InMemorySigner_get_payment_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
20284 export function InMemorySigner_get_payment_key(this_ptr: bigint): number {
20285 if(!isWasmInitialized) {
20286 throw new Error("initializeWasm() must be awaited first!");
20288 const nativeResponseValue = wasm.TS_InMemorySigner_get_payment_key(this_ptr);
20289 return nativeResponseValue;
20291 // void InMemorySigner_set_payment_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
20293 export function InMemorySigner_set_payment_key(this_ptr: bigint, val: number): void {
20294 if(!isWasmInitialized) {
20295 throw new Error("initializeWasm() must be awaited first!");
20297 const nativeResponseValue = wasm.TS_InMemorySigner_set_payment_key(this_ptr, val);
20298 // debug statements here
20300 // const uint8_t (*InMemorySigner_get_delayed_payment_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
20302 export function InMemorySigner_get_delayed_payment_base_key(this_ptr: bigint): number {
20303 if(!isWasmInitialized) {
20304 throw new Error("initializeWasm() must be awaited first!");
20306 const nativeResponseValue = wasm.TS_InMemorySigner_get_delayed_payment_base_key(this_ptr);
20307 return nativeResponseValue;
20309 // void InMemorySigner_set_delayed_payment_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
20311 export function InMemorySigner_set_delayed_payment_base_key(this_ptr: bigint, val: number): void {
20312 if(!isWasmInitialized) {
20313 throw new Error("initializeWasm() must be awaited first!");
20315 const nativeResponseValue = wasm.TS_InMemorySigner_set_delayed_payment_base_key(this_ptr, val);
20316 // debug statements here
20318 // const uint8_t (*InMemorySigner_get_htlc_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
20320 export function InMemorySigner_get_htlc_base_key(this_ptr: bigint): number {
20321 if(!isWasmInitialized) {
20322 throw new Error("initializeWasm() must be awaited first!");
20324 const nativeResponseValue = wasm.TS_InMemorySigner_get_htlc_base_key(this_ptr);
20325 return nativeResponseValue;
20327 // void InMemorySigner_set_htlc_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
20329 export function InMemorySigner_set_htlc_base_key(this_ptr: bigint, val: number): void {
20330 if(!isWasmInitialized) {
20331 throw new Error("initializeWasm() must be awaited first!");
20333 const nativeResponseValue = wasm.TS_InMemorySigner_set_htlc_base_key(this_ptr, val);
20334 // debug statements here
20336 // const uint8_t (*InMemorySigner_get_commitment_seed(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
20338 export function InMemorySigner_get_commitment_seed(this_ptr: bigint): number {
20339 if(!isWasmInitialized) {
20340 throw new Error("initializeWasm() must be awaited first!");
20342 const nativeResponseValue = wasm.TS_InMemorySigner_get_commitment_seed(this_ptr);
20343 return nativeResponseValue;
20345 // void InMemorySigner_set_commitment_seed(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20347 export function InMemorySigner_set_commitment_seed(this_ptr: bigint, val: number): void {
20348 if(!isWasmInitialized) {
20349 throw new Error("initializeWasm() must be awaited first!");
20351 const nativeResponseValue = wasm.TS_InMemorySigner_set_commitment_seed(this_ptr, val);
20352 // debug statements here
20354 // uint64_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg);
20356 export function InMemorySigner_clone_ptr(arg: bigint): bigint {
20357 if(!isWasmInitialized) {
20358 throw new Error("initializeWasm() must be awaited first!");
20360 const nativeResponseValue = wasm.TS_InMemorySigner_clone_ptr(arg);
20361 return nativeResponseValue;
20363 // struct LDKInMemorySigner InMemorySigner_clone(const struct LDKInMemorySigner *NONNULL_PTR orig);
20365 export function InMemorySigner_clone(orig: bigint): bigint {
20366 if(!isWasmInitialized) {
20367 throw new Error("initializeWasm() must be awaited first!");
20369 const nativeResponseValue = wasm.TS_InMemorySigner_clone(orig);
20370 return nativeResponseValue;
20372 // 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);
20374 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 {
20375 if(!isWasmInitialized) {
20376 throw new Error("initializeWasm() must be awaited first!");
20378 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);
20379 return nativeResponseValue;
20381 // MUST_USE_RES struct LDKChannelPublicKeys InMemorySigner_counterparty_pubkeys(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
20383 export function InMemorySigner_counterparty_pubkeys(this_arg: bigint): bigint {
20384 if(!isWasmInitialized) {
20385 throw new Error("initializeWasm() must be awaited first!");
20387 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_pubkeys(this_arg);
20388 return nativeResponseValue;
20390 // MUST_USE_RES uint16_t InMemorySigner_counterparty_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
20392 export function InMemorySigner_counterparty_selected_contest_delay(this_arg: bigint): number {
20393 if(!isWasmInitialized) {
20394 throw new Error("initializeWasm() must be awaited first!");
20396 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_selected_contest_delay(this_arg);
20397 return nativeResponseValue;
20399 // MUST_USE_RES uint16_t InMemorySigner_holder_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
20401 export function InMemorySigner_holder_selected_contest_delay(this_arg: bigint): number {
20402 if(!isWasmInitialized) {
20403 throw new Error("initializeWasm() must be awaited first!");
20405 const nativeResponseValue = wasm.TS_InMemorySigner_holder_selected_contest_delay(this_arg);
20406 return nativeResponseValue;
20408 // MUST_USE_RES bool InMemorySigner_is_outbound(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
20410 export function InMemorySigner_is_outbound(this_arg: bigint): boolean {
20411 if(!isWasmInitialized) {
20412 throw new Error("initializeWasm() must be awaited first!");
20414 const nativeResponseValue = wasm.TS_InMemorySigner_is_outbound(this_arg);
20415 return nativeResponseValue;
20417 // MUST_USE_RES struct LDKOutPoint InMemorySigner_funding_outpoint(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
20419 export function InMemorySigner_funding_outpoint(this_arg: bigint): bigint {
20420 if(!isWasmInitialized) {
20421 throw new Error("initializeWasm() must be awaited first!");
20423 const nativeResponseValue = wasm.TS_InMemorySigner_funding_outpoint(this_arg);
20424 return nativeResponseValue;
20426 // MUST_USE_RES struct LDKChannelTransactionParameters InMemorySigner_get_channel_parameters(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
20428 export function InMemorySigner_get_channel_parameters(this_arg: bigint): bigint {
20429 if(!isWasmInitialized) {
20430 throw new Error("initializeWasm() must be awaited first!");
20432 const nativeResponseValue = wasm.TS_InMemorySigner_get_channel_parameters(this_arg);
20433 return nativeResponseValue;
20435 // MUST_USE_RES bool InMemorySigner_opt_anchors(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
20437 export function InMemorySigner_opt_anchors(this_arg: bigint): boolean {
20438 if(!isWasmInitialized) {
20439 throw new Error("initializeWasm() must be awaited first!");
20441 const nativeResponseValue = wasm.TS_InMemorySigner_opt_anchors(this_arg);
20442 return nativeResponseValue;
20444 // 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);
20446 export function InMemorySigner_sign_counterparty_payment_input(this_arg: bigint, spend_tx: number, input_idx: number, descriptor: bigint): bigint {
20447 if(!isWasmInitialized) {
20448 throw new Error("initializeWasm() must be awaited first!");
20450 const nativeResponseValue = wasm.TS_InMemorySigner_sign_counterparty_payment_input(this_arg, spend_tx, input_idx, descriptor);
20451 return nativeResponseValue;
20453 // 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);
20455 export function InMemorySigner_sign_dynamic_p2wsh_input(this_arg: bigint, spend_tx: number, input_idx: number, descriptor: bigint): bigint {
20456 if(!isWasmInitialized) {
20457 throw new Error("initializeWasm() must be awaited first!");
20459 const nativeResponseValue = wasm.TS_InMemorySigner_sign_dynamic_p2wsh_input(this_arg, spend_tx, input_idx, descriptor);
20460 return nativeResponseValue;
20462 // struct LDKBaseSign InMemorySigner_as_BaseSign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
20464 export function InMemorySigner_as_BaseSign(this_arg: bigint): bigint {
20465 if(!isWasmInitialized) {
20466 throw new Error("initializeWasm() must be awaited first!");
20468 const nativeResponseValue = wasm.TS_InMemorySigner_as_BaseSign(this_arg);
20469 return nativeResponseValue;
20471 // struct LDKSign InMemorySigner_as_Sign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
20473 export function InMemorySigner_as_Sign(this_arg: bigint): bigint {
20474 if(!isWasmInitialized) {
20475 throw new Error("initializeWasm() must be awaited first!");
20477 const nativeResponseValue = wasm.TS_InMemorySigner_as_Sign(this_arg);
20478 return nativeResponseValue;
20480 // struct LDKCVec_u8Z InMemorySigner_write(const struct LDKInMemorySigner *NONNULL_PTR obj);
20482 export function InMemorySigner_write(obj: bigint): number {
20483 if(!isWasmInitialized) {
20484 throw new Error("initializeWasm() must be awaited first!");
20486 const nativeResponseValue = wasm.TS_InMemorySigner_write(obj);
20487 return nativeResponseValue;
20489 // struct LDKCResult_InMemorySignerDecodeErrorZ InMemorySigner_read(struct LDKu8slice ser, struct LDKSecretKey arg);
20491 export function InMemorySigner_read(ser: number, arg: number): bigint {
20492 if(!isWasmInitialized) {
20493 throw new Error("initializeWasm() must be awaited first!");
20495 const nativeResponseValue = wasm.TS_InMemorySigner_read(ser, arg);
20496 return nativeResponseValue;
20498 // void KeysManager_free(struct LDKKeysManager this_obj);
20500 export function KeysManager_free(this_obj: bigint): void {
20501 if(!isWasmInitialized) {
20502 throw new Error("initializeWasm() must be awaited first!");
20504 const nativeResponseValue = wasm.TS_KeysManager_free(this_obj);
20505 // debug statements here
20507 // MUST_USE_RES struct LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], uint64_t starting_time_secs, uint32_t starting_time_nanos);
20509 export function KeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number): bigint {
20510 if(!isWasmInitialized) {
20511 throw new Error("initializeWasm() must be awaited first!");
20513 const nativeResponseValue = wasm.TS_KeysManager_new(seed, starting_time_secs, starting_time_nanos);
20514 return nativeResponseValue;
20516 // 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]);
20518 export function KeysManager_derive_channel_keys(this_arg: bigint, channel_value_satoshis: bigint, params: number): bigint {
20519 if(!isWasmInitialized) {
20520 throw new Error("initializeWasm() must be awaited first!");
20522 const nativeResponseValue = wasm.TS_KeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
20523 return nativeResponseValue;
20525 // 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);
20527 export function KeysManager_spend_spendable_outputs(this_arg: bigint, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): bigint {
20528 if(!isWasmInitialized) {
20529 throw new Error("initializeWasm() must be awaited first!");
20531 const nativeResponseValue = wasm.TS_KeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
20532 return nativeResponseValue;
20534 // struct LDKKeysInterface KeysManager_as_KeysInterface(const struct LDKKeysManager *NONNULL_PTR this_arg);
20536 export function KeysManager_as_KeysInterface(this_arg: bigint): bigint {
20537 if(!isWasmInitialized) {
20538 throw new Error("initializeWasm() must be awaited first!");
20540 const nativeResponseValue = wasm.TS_KeysManager_as_KeysInterface(this_arg);
20541 return nativeResponseValue;
20543 // void PhantomKeysManager_free(struct LDKPhantomKeysManager this_obj);
20545 export function PhantomKeysManager_free(this_obj: bigint): void {
20546 if(!isWasmInitialized) {
20547 throw new Error("initializeWasm() must be awaited first!");
20549 const nativeResponseValue = wasm.TS_PhantomKeysManager_free(this_obj);
20550 // debug statements here
20552 // struct LDKKeysInterface PhantomKeysManager_as_KeysInterface(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
20554 export function PhantomKeysManager_as_KeysInterface(this_arg: bigint): bigint {
20555 if(!isWasmInitialized) {
20556 throw new Error("initializeWasm() must be awaited first!");
20558 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_KeysInterface(this_arg);
20559 return nativeResponseValue;
20561 // 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]);
20563 export function PhantomKeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number, cross_node_seed: number): bigint {
20564 if(!isWasmInitialized) {
20565 throw new Error("initializeWasm() must be awaited first!");
20567 const nativeResponseValue = wasm.TS_PhantomKeysManager_new(seed, starting_time_secs, starting_time_nanos, cross_node_seed);
20568 return nativeResponseValue;
20570 // 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);
20572 export function PhantomKeysManager_spend_spendable_outputs(this_arg: bigint, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): bigint {
20573 if(!isWasmInitialized) {
20574 throw new Error("initializeWasm() must be awaited first!");
20576 const nativeResponseValue = wasm.TS_PhantomKeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
20577 return nativeResponseValue;
20579 // 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]);
20581 export function PhantomKeysManager_derive_channel_keys(this_arg: bigint, channel_value_satoshis: bigint, params: number): bigint {
20582 if(!isWasmInitialized) {
20583 throw new Error("initializeWasm() must be awaited first!");
20585 const nativeResponseValue = wasm.TS_PhantomKeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
20586 return nativeResponseValue;
20588 // void ChannelManager_free(struct LDKChannelManager this_obj);
20590 export function ChannelManager_free(this_obj: bigint): void {
20591 if(!isWasmInitialized) {
20592 throw new Error("initializeWasm() must be awaited first!");
20594 const nativeResponseValue = wasm.TS_ChannelManager_free(this_obj);
20595 // debug statements here
20597 // void ChainParameters_free(struct LDKChainParameters this_obj);
20599 export function ChainParameters_free(this_obj: bigint): void {
20600 if(!isWasmInitialized) {
20601 throw new Error("initializeWasm() must be awaited first!");
20603 const nativeResponseValue = wasm.TS_ChainParameters_free(this_obj);
20604 // debug statements here
20606 // enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr);
20608 export function ChainParameters_get_network(this_ptr: bigint): Network {
20609 if(!isWasmInitialized) {
20610 throw new Error("initializeWasm() must be awaited first!");
20612 const nativeResponseValue = wasm.TS_ChainParameters_get_network(this_ptr);
20613 return nativeResponseValue;
20615 // void ChainParameters_set_network(struct LDKChainParameters *NONNULL_PTR this_ptr, enum LDKNetwork val);
20617 export function ChainParameters_set_network(this_ptr: bigint, val: Network): void {
20618 if(!isWasmInitialized) {
20619 throw new Error("initializeWasm() must be awaited first!");
20621 const nativeResponseValue = wasm.TS_ChainParameters_set_network(this_ptr, val);
20622 // debug statements here
20624 // struct LDKBestBlock ChainParameters_get_best_block(const struct LDKChainParameters *NONNULL_PTR this_ptr);
20626 export function ChainParameters_get_best_block(this_ptr: bigint): bigint {
20627 if(!isWasmInitialized) {
20628 throw new Error("initializeWasm() must be awaited first!");
20630 const nativeResponseValue = wasm.TS_ChainParameters_get_best_block(this_ptr);
20631 return nativeResponseValue;
20633 // void ChainParameters_set_best_block(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKBestBlock val);
20635 export function ChainParameters_set_best_block(this_ptr: bigint, val: bigint): void {
20636 if(!isWasmInitialized) {
20637 throw new Error("initializeWasm() must be awaited first!");
20639 const nativeResponseValue = wasm.TS_ChainParameters_set_best_block(this_ptr, val);
20640 // debug statements here
20642 // MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKBestBlock best_block_arg);
20644 export function ChainParameters_new(network_arg: Network, best_block_arg: bigint): bigint {
20645 if(!isWasmInitialized) {
20646 throw new Error("initializeWasm() must be awaited first!");
20648 const nativeResponseValue = wasm.TS_ChainParameters_new(network_arg, best_block_arg);
20649 return nativeResponseValue;
20651 // uint64_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg);
20653 export function ChainParameters_clone_ptr(arg: bigint): bigint {
20654 if(!isWasmInitialized) {
20655 throw new Error("initializeWasm() must be awaited first!");
20657 const nativeResponseValue = wasm.TS_ChainParameters_clone_ptr(arg);
20658 return nativeResponseValue;
20660 // struct LDKChainParameters ChainParameters_clone(const struct LDKChainParameters *NONNULL_PTR orig);
20662 export function ChainParameters_clone(orig: bigint): bigint {
20663 if(!isWasmInitialized) {
20664 throw new Error("initializeWasm() must be awaited first!");
20666 const nativeResponseValue = wasm.TS_ChainParameters_clone(orig);
20667 return nativeResponseValue;
20669 // void CounterpartyForwardingInfo_free(struct LDKCounterpartyForwardingInfo this_obj);
20671 export function CounterpartyForwardingInfo_free(this_obj: bigint): void {
20672 if(!isWasmInitialized) {
20673 throw new Error("initializeWasm() must be awaited first!");
20675 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_free(this_obj);
20676 // debug statements here
20678 // uint32_t CounterpartyForwardingInfo_get_fee_base_msat(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
20680 export function CounterpartyForwardingInfo_get_fee_base_msat(this_ptr: bigint): number {
20681 if(!isWasmInitialized) {
20682 throw new Error("initializeWasm() must be awaited first!");
20684 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_base_msat(this_ptr);
20685 return nativeResponseValue;
20687 // void CounterpartyForwardingInfo_set_fee_base_msat(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
20689 export function CounterpartyForwardingInfo_set_fee_base_msat(this_ptr: bigint, val: number): void {
20690 if(!isWasmInitialized) {
20691 throw new Error("initializeWasm() must be awaited first!");
20693 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_base_msat(this_ptr, val);
20694 // debug statements here
20696 // uint32_t CounterpartyForwardingInfo_get_fee_proportional_millionths(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
20698 export function CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr: bigint): number {
20699 if(!isWasmInitialized) {
20700 throw new Error("initializeWasm() must be awaited first!");
20702 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr);
20703 return nativeResponseValue;
20705 // void CounterpartyForwardingInfo_set_fee_proportional_millionths(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
20707 export function CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
20708 if(!isWasmInitialized) {
20709 throw new Error("initializeWasm() must be awaited first!");
20711 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr, val);
20712 // debug statements here
20714 // uint16_t CounterpartyForwardingInfo_get_cltv_expiry_delta(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
20716 export function CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
20717 if(!isWasmInitialized) {
20718 throw new Error("initializeWasm() must be awaited first!");
20720 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr);
20721 return nativeResponseValue;
20723 // void CounterpartyForwardingInfo_set_cltv_expiry_delta(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint16_t val);
20725 export function CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
20726 if(!isWasmInitialized) {
20727 throw new Error("initializeWasm() must be awaited first!");
20729 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr, val);
20730 // debug statements here
20732 // 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);
20734 export function CounterpartyForwardingInfo_new(fee_base_msat_arg: number, fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number): bigint {
20735 if(!isWasmInitialized) {
20736 throw new Error("initializeWasm() must be awaited first!");
20738 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
20739 return nativeResponseValue;
20741 // uint64_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg);
20743 export function CounterpartyForwardingInfo_clone_ptr(arg: bigint): bigint {
20744 if(!isWasmInitialized) {
20745 throw new Error("initializeWasm() must be awaited first!");
20747 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone_ptr(arg);
20748 return nativeResponseValue;
20750 // struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_clone(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR orig);
20752 export function CounterpartyForwardingInfo_clone(orig: bigint): bigint {
20753 if(!isWasmInitialized) {
20754 throw new Error("initializeWasm() must be awaited first!");
20756 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone(orig);
20757 return nativeResponseValue;
20759 // void ChannelCounterparty_free(struct LDKChannelCounterparty this_obj);
20761 export function ChannelCounterparty_free(this_obj: bigint): void {
20762 if(!isWasmInitialized) {
20763 throw new Error("initializeWasm() must be awaited first!");
20765 const nativeResponseValue = wasm.TS_ChannelCounterparty_free(this_obj);
20766 // debug statements here
20768 // struct LDKPublicKey ChannelCounterparty_get_node_id(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
20770 export function ChannelCounterparty_get_node_id(this_ptr: bigint): number {
20771 if(!isWasmInitialized) {
20772 throw new Error("initializeWasm() must be awaited first!");
20774 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_node_id(this_ptr);
20775 return nativeResponseValue;
20777 // void ChannelCounterparty_set_node_id(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20779 export function ChannelCounterparty_set_node_id(this_ptr: bigint, val: number): void {
20780 if(!isWasmInitialized) {
20781 throw new Error("initializeWasm() must be awaited first!");
20783 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_node_id(this_ptr, val);
20784 // debug statements here
20786 // struct LDKInitFeatures ChannelCounterparty_get_features(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
20788 export function ChannelCounterparty_get_features(this_ptr: bigint): bigint {
20789 if(!isWasmInitialized) {
20790 throw new Error("initializeWasm() must be awaited first!");
20792 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_features(this_ptr);
20793 return nativeResponseValue;
20795 // void ChannelCounterparty_set_features(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
20797 export function ChannelCounterparty_set_features(this_ptr: bigint, val: bigint): void {
20798 if(!isWasmInitialized) {
20799 throw new Error("initializeWasm() must be awaited first!");
20801 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_features(this_ptr, val);
20802 // debug statements here
20804 // uint64_t ChannelCounterparty_get_unspendable_punishment_reserve(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
20806 export function ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr: bigint): bigint {
20807 if(!isWasmInitialized) {
20808 throw new Error("initializeWasm() must be awaited first!");
20810 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr);
20811 return nativeResponseValue;
20813 // void ChannelCounterparty_set_unspendable_punishment_reserve(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, uint64_t val);
20815 export function ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr: bigint, val: bigint): void {
20816 if(!isWasmInitialized) {
20817 throw new Error("initializeWasm() must be awaited first!");
20819 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr, val);
20820 // debug statements here
20822 // struct LDKCounterpartyForwardingInfo ChannelCounterparty_get_forwarding_info(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
20824 export function ChannelCounterparty_get_forwarding_info(this_ptr: bigint): bigint {
20825 if(!isWasmInitialized) {
20826 throw new Error("initializeWasm() must be awaited first!");
20828 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_forwarding_info(this_ptr);
20829 return nativeResponseValue;
20831 // void ChannelCounterparty_set_forwarding_info(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCounterpartyForwardingInfo val);
20833 export function ChannelCounterparty_set_forwarding_info(this_ptr: bigint, val: bigint): void {
20834 if(!isWasmInitialized) {
20835 throw new Error("initializeWasm() must be awaited first!");
20837 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_forwarding_info(this_ptr, val);
20838 // debug statements here
20840 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_minimum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
20842 export function ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr: bigint): bigint {
20843 if(!isWasmInitialized) {
20844 throw new Error("initializeWasm() must be awaited first!");
20846 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr);
20847 return nativeResponseValue;
20849 // void ChannelCounterparty_set_outbound_htlc_minimum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
20851 export function ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
20852 if(!isWasmInitialized) {
20853 throw new Error("initializeWasm() must be awaited first!");
20855 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr, val);
20856 // debug statements here
20858 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_maximum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
20860 export function ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr: bigint): bigint {
20861 if(!isWasmInitialized) {
20862 throw new Error("initializeWasm() must be awaited first!");
20864 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr);
20865 return nativeResponseValue;
20867 // void ChannelCounterparty_set_outbound_htlc_maximum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
20869 export function ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
20870 if(!isWasmInitialized) {
20871 throw new Error("initializeWasm() must be awaited first!");
20873 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr, val);
20874 // debug statements here
20876 // 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);
20878 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 {
20879 if(!isWasmInitialized) {
20880 throw new Error("initializeWasm() must be awaited first!");
20882 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);
20883 return nativeResponseValue;
20885 // uint64_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg);
20887 export function ChannelCounterparty_clone_ptr(arg: bigint): bigint {
20888 if(!isWasmInitialized) {
20889 throw new Error("initializeWasm() must be awaited first!");
20891 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone_ptr(arg);
20892 return nativeResponseValue;
20894 // struct LDKChannelCounterparty ChannelCounterparty_clone(const struct LDKChannelCounterparty *NONNULL_PTR orig);
20896 export function ChannelCounterparty_clone(orig: bigint): bigint {
20897 if(!isWasmInitialized) {
20898 throw new Error("initializeWasm() must be awaited first!");
20900 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone(orig);
20901 return nativeResponseValue;
20903 // void ChannelDetails_free(struct LDKChannelDetails this_obj);
20905 export function ChannelDetails_free(this_obj: bigint): void {
20906 if(!isWasmInitialized) {
20907 throw new Error("initializeWasm() must be awaited first!");
20909 const nativeResponseValue = wasm.TS_ChannelDetails_free(this_obj);
20910 // debug statements here
20912 // const uint8_t (*ChannelDetails_get_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr))[32];
20914 export function ChannelDetails_get_channel_id(this_ptr: bigint): number {
20915 if(!isWasmInitialized) {
20916 throw new Error("initializeWasm() must be awaited first!");
20918 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_id(this_ptr);
20919 return nativeResponseValue;
20921 // void ChannelDetails_set_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20923 export function ChannelDetails_set_channel_id(this_ptr: bigint, val: number): void {
20924 if(!isWasmInitialized) {
20925 throw new Error("initializeWasm() must be awaited first!");
20927 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_id(this_ptr, val);
20928 // debug statements here
20930 // struct LDKChannelCounterparty ChannelDetails_get_counterparty(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
20932 export function ChannelDetails_get_counterparty(this_ptr: bigint): bigint {
20933 if(!isWasmInitialized) {
20934 throw new Error("initializeWasm() must be awaited first!");
20936 const nativeResponseValue = wasm.TS_ChannelDetails_get_counterparty(this_ptr);
20937 return nativeResponseValue;
20939 // void ChannelDetails_set_counterparty(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelCounterparty val);
20941 export function ChannelDetails_set_counterparty(this_ptr: bigint, val: bigint): void {
20942 if(!isWasmInitialized) {
20943 throw new Error("initializeWasm() must be awaited first!");
20945 const nativeResponseValue = wasm.TS_ChannelDetails_set_counterparty(this_ptr, val);
20946 // debug statements here
20948 // struct LDKOutPoint ChannelDetails_get_funding_txo(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
20950 export function ChannelDetails_get_funding_txo(this_ptr: bigint): bigint {
20951 if(!isWasmInitialized) {
20952 throw new Error("initializeWasm() must be awaited first!");
20954 const nativeResponseValue = wasm.TS_ChannelDetails_get_funding_txo(this_ptr);
20955 return nativeResponseValue;
20957 // void ChannelDetails_set_funding_txo(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKOutPoint val);
20959 export function ChannelDetails_set_funding_txo(this_ptr: bigint, val: bigint): void {
20960 if(!isWasmInitialized) {
20961 throw new Error("initializeWasm() must be awaited first!");
20963 const nativeResponseValue = wasm.TS_ChannelDetails_set_funding_txo(this_ptr, val);
20964 // debug statements here
20966 // struct LDKChannelTypeFeatures ChannelDetails_get_channel_type(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
20968 export function ChannelDetails_get_channel_type(this_ptr: bigint): bigint {
20969 if(!isWasmInitialized) {
20970 throw new Error("initializeWasm() must be awaited first!");
20972 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_type(this_ptr);
20973 return nativeResponseValue;
20975 // void ChannelDetails_set_channel_type(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
20977 export function ChannelDetails_set_channel_type(this_ptr: bigint, val: bigint): void {
20978 if(!isWasmInitialized) {
20979 throw new Error("initializeWasm() must be awaited first!");
20981 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_type(this_ptr, val);
20982 // debug statements here
20984 // struct LDKCOption_u64Z ChannelDetails_get_short_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
20986 export function ChannelDetails_get_short_channel_id(this_ptr: bigint): bigint {
20987 if(!isWasmInitialized) {
20988 throw new Error("initializeWasm() must be awaited first!");
20990 const nativeResponseValue = wasm.TS_ChannelDetails_get_short_channel_id(this_ptr);
20991 return nativeResponseValue;
20993 // void ChannelDetails_set_short_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
20995 export function ChannelDetails_set_short_channel_id(this_ptr: bigint, val: bigint): void {
20996 if(!isWasmInitialized) {
20997 throw new Error("initializeWasm() must be awaited first!");
20999 const nativeResponseValue = wasm.TS_ChannelDetails_set_short_channel_id(this_ptr, val);
21000 // debug statements here
21002 // struct LDKCOption_u64Z ChannelDetails_get_outbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21004 export function ChannelDetails_get_outbound_scid_alias(this_ptr: bigint): bigint {
21005 if(!isWasmInitialized) {
21006 throw new Error("initializeWasm() must be awaited first!");
21008 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_scid_alias(this_ptr);
21009 return nativeResponseValue;
21011 // void ChannelDetails_set_outbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
21013 export function ChannelDetails_set_outbound_scid_alias(this_ptr: bigint, val: bigint): void {
21014 if(!isWasmInitialized) {
21015 throw new Error("initializeWasm() must be awaited first!");
21017 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_scid_alias(this_ptr, val);
21018 // debug statements here
21020 // struct LDKCOption_u64Z ChannelDetails_get_inbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21022 export function ChannelDetails_get_inbound_scid_alias(this_ptr: bigint): bigint {
21023 if(!isWasmInitialized) {
21024 throw new Error("initializeWasm() must be awaited first!");
21026 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_scid_alias(this_ptr);
21027 return nativeResponseValue;
21029 // void ChannelDetails_set_inbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
21031 export function ChannelDetails_set_inbound_scid_alias(this_ptr: bigint, val: bigint): void {
21032 if(!isWasmInitialized) {
21033 throw new Error("initializeWasm() must be awaited first!");
21035 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_scid_alias(this_ptr, val);
21036 // debug statements here
21038 // uint64_t ChannelDetails_get_channel_value_satoshis(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21040 export function ChannelDetails_get_channel_value_satoshis(this_ptr: bigint): bigint {
21041 if(!isWasmInitialized) {
21042 throw new Error("initializeWasm() must be awaited first!");
21044 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_value_satoshis(this_ptr);
21045 return nativeResponseValue;
21047 // void ChannelDetails_set_channel_value_satoshis(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
21049 export function ChannelDetails_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
21050 if(!isWasmInitialized) {
21051 throw new Error("initializeWasm() must be awaited first!");
21053 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_value_satoshis(this_ptr, val);
21054 // debug statements here
21056 // struct LDKCOption_u64Z ChannelDetails_get_unspendable_punishment_reserve(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21058 export function ChannelDetails_get_unspendable_punishment_reserve(this_ptr: bigint): bigint {
21059 if(!isWasmInitialized) {
21060 throw new Error("initializeWasm() must be awaited first!");
21062 const nativeResponseValue = wasm.TS_ChannelDetails_get_unspendable_punishment_reserve(this_ptr);
21063 return nativeResponseValue;
21065 // void ChannelDetails_set_unspendable_punishment_reserve(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
21067 export function ChannelDetails_set_unspendable_punishment_reserve(this_ptr: bigint, val: bigint): void {
21068 if(!isWasmInitialized) {
21069 throw new Error("initializeWasm() must be awaited first!");
21071 const nativeResponseValue = wasm.TS_ChannelDetails_set_unspendable_punishment_reserve(this_ptr, val);
21072 // debug statements here
21074 // uint64_t ChannelDetails_get_user_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21076 export function ChannelDetails_get_user_channel_id(this_ptr: bigint): bigint {
21077 if(!isWasmInitialized) {
21078 throw new Error("initializeWasm() must be awaited first!");
21080 const nativeResponseValue = wasm.TS_ChannelDetails_get_user_channel_id(this_ptr);
21081 return nativeResponseValue;
21083 // void ChannelDetails_set_user_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
21085 export function ChannelDetails_set_user_channel_id(this_ptr: bigint, val: bigint): void {
21086 if(!isWasmInitialized) {
21087 throw new Error("initializeWasm() must be awaited first!");
21089 const nativeResponseValue = wasm.TS_ChannelDetails_set_user_channel_id(this_ptr, val);
21090 // debug statements here
21092 // uint64_t ChannelDetails_get_balance_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21094 export function ChannelDetails_get_balance_msat(this_ptr: bigint): bigint {
21095 if(!isWasmInitialized) {
21096 throw new Error("initializeWasm() must be awaited first!");
21098 const nativeResponseValue = wasm.TS_ChannelDetails_get_balance_msat(this_ptr);
21099 return nativeResponseValue;
21101 // void ChannelDetails_set_balance_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
21103 export function ChannelDetails_set_balance_msat(this_ptr: bigint, val: bigint): void {
21104 if(!isWasmInitialized) {
21105 throw new Error("initializeWasm() must be awaited first!");
21107 const nativeResponseValue = wasm.TS_ChannelDetails_set_balance_msat(this_ptr, val);
21108 // debug statements here
21110 // uint64_t ChannelDetails_get_outbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21112 export function ChannelDetails_get_outbound_capacity_msat(this_ptr: bigint): bigint {
21113 if(!isWasmInitialized) {
21114 throw new Error("initializeWasm() must be awaited first!");
21116 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_capacity_msat(this_ptr);
21117 return nativeResponseValue;
21119 // void ChannelDetails_set_outbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
21121 export function ChannelDetails_set_outbound_capacity_msat(this_ptr: bigint, val: bigint): void {
21122 if(!isWasmInitialized) {
21123 throw new Error("initializeWasm() must be awaited first!");
21125 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_capacity_msat(this_ptr, val);
21126 // debug statements here
21128 // uint64_t ChannelDetails_get_next_outbound_htlc_limit_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21130 export function ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr: bigint): bigint {
21131 if(!isWasmInitialized) {
21132 throw new Error("initializeWasm() must be awaited first!");
21134 const nativeResponseValue = wasm.TS_ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr);
21135 return nativeResponseValue;
21137 // void ChannelDetails_set_next_outbound_htlc_limit_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
21139 export function ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr: bigint, val: bigint): void {
21140 if(!isWasmInitialized) {
21141 throw new Error("initializeWasm() must be awaited first!");
21143 const nativeResponseValue = wasm.TS_ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr, val);
21144 // debug statements here
21146 // uint64_t ChannelDetails_get_inbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21148 export function ChannelDetails_get_inbound_capacity_msat(this_ptr: bigint): bigint {
21149 if(!isWasmInitialized) {
21150 throw new Error("initializeWasm() must be awaited first!");
21152 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_capacity_msat(this_ptr);
21153 return nativeResponseValue;
21155 // void ChannelDetails_set_inbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
21157 export function ChannelDetails_set_inbound_capacity_msat(this_ptr: bigint, val: bigint): void {
21158 if(!isWasmInitialized) {
21159 throw new Error("initializeWasm() must be awaited first!");
21161 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_capacity_msat(this_ptr, val);
21162 // debug statements here
21164 // struct LDKCOption_u32Z ChannelDetails_get_confirmations_required(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21166 export function ChannelDetails_get_confirmations_required(this_ptr: bigint): bigint {
21167 if(!isWasmInitialized) {
21168 throw new Error("initializeWasm() must be awaited first!");
21170 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations_required(this_ptr);
21171 return nativeResponseValue;
21173 // void ChannelDetails_set_confirmations_required(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
21175 export function ChannelDetails_set_confirmations_required(this_ptr: bigint, val: bigint): void {
21176 if(!isWasmInitialized) {
21177 throw new Error("initializeWasm() must be awaited first!");
21179 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations_required(this_ptr, val);
21180 // debug statements here
21182 // struct LDKCOption_u16Z ChannelDetails_get_force_close_spend_delay(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21184 export function ChannelDetails_get_force_close_spend_delay(this_ptr: bigint): bigint {
21185 if(!isWasmInitialized) {
21186 throw new Error("initializeWasm() must be awaited first!");
21188 const nativeResponseValue = wasm.TS_ChannelDetails_get_force_close_spend_delay(this_ptr);
21189 return nativeResponseValue;
21191 // void ChannelDetails_set_force_close_spend_delay(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
21193 export function ChannelDetails_set_force_close_spend_delay(this_ptr: bigint, val: bigint): void {
21194 if(!isWasmInitialized) {
21195 throw new Error("initializeWasm() must be awaited first!");
21197 const nativeResponseValue = wasm.TS_ChannelDetails_set_force_close_spend_delay(this_ptr, val);
21198 // debug statements here
21200 // bool ChannelDetails_get_is_outbound(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21202 export function ChannelDetails_get_is_outbound(this_ptr: bigint): boolean {
21203 if(!isWasmInitialized) {
21204 throw new Error("initializeWasm() must be awaited first!");
21206 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_outbound(this_ptr);
21207 return nativeResponseValue;
21209 // void ChannelDetails_set_is_outbound(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
21211 export function ChannelDetails_set_is_outbound(this_ptr: bigint, val: boolean): void {
21212 if(!isWasmInitialized) {
21213 throw new Error("initializeWasm() must be awaited first!");
21215 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_outbound(this_ptr, val);
21216 // debug statements here
21218 // bool ChannelDetails_get_is_channel_ready(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21220 export function ChannelDetails_get_is_channel_ready(this_ptr: bigint): boolean {
21221 if(!isWasmInitialized) {
21222 throw new Error("initializeWasm() must be awaited first!");
21224 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_channel_ready(this_ptr);
21225 return nativeResponseValue;
21227 // void ChannelDetails_set_is_channel_ready(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
21229 export function ChannelDetails_set_is_channel_ready(this_ptr: bigint, val: boolean): void {
21230 if(!isWasmInitialized) {
21231 throw new Error("initializeWasm() must be awaited first!");
21233 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_channel_ready(this_ptr, val);
21234 // debug statements here
21236 // bool ChannelDetails_get_is_usable(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21238 export function ChannelDetails_get_is_usable(this_ptr: bigint): boolean {
21239 if(!isWasmInitialized) {
21240 throw new Error("initializeWasm() must be awaited first!");
21242 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_usable(this_ptr);
21243 return nativeResponseValue;
21245 // void ChannelDetails_set_is_usable(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
21247 export function ChannelDetails_set_is_usable(this_ptr: bigint, val: boolean): void {
21248 if(!isWasmInitialized) {
21249 throw new Error("initializeWasm() must be awaited first!");
21251 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_usable(this_ptr, val);
21252 // debug statements here
21254 // bool ChannelDetails_get_is_public(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21256 export function ChannelDetails_get_is_public(this_ptr: bigint): boolean {
21257 if(!isWasmInitialized) {
21258 throw new Error("initializeWasm() must be awaited first!");
21260 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_public(this_ptr);
21261 return nativeResponseValue;
21263 // void ChannelDetails_set_is_public(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
21265 export function ChannelDetails_set_is_public(this_ptr: bigint, val: boolean): void {
21266 if(!isWasmInitialized) {
21267 throw new Error("initializeWasm() must be awaited first!");
21269 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_public(this_ptr, val);
21270 // debug statements here
21272 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_minimum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21274 export function ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr: bigint): bigint {
21275 if(!isWasmInitialized) {
21276 throw new Error("initializeWasm() must be awaited first!");
21278 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr);
21279 return nativeResponseValue;
21281 // void ChannelDetails_set_inbound_htlc_minimum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
21283 export function ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
21284 if(!isWasmInitialized) {
21285 throw new Error("initializeWasm() must be awaited first!");
21287 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr, val);
21288 // debug statements here
21290 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_maximum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21292 export function ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr: bigint): bigint {
21293 if(!isWasmInitialized) {
21294 throw new Error("initializeWasm() must be awaited first!");
21296 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr);
21297 return nativeResponseValue;
21299 // void ChannelDetails_set_inbound_htlc_maximum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
21301 export function ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
21302 if(!isWasmInitialized) {
21303 throw new Error("initializeWasm() must be awaited first!");
21305 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr, val);
21306 // debug statements here
21308 // struct LDKChannelConfig ChannelDetails_get_config(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21310 export function ChannelDetails_get_config(this_ptr: bigint): bigint {
21311 if(!isWasmInitialized) {
21312 throw new Error("initializeWasm() must be awaited first!");
21314 const nativeResponseValue = wasm.TS_ChannelDetails_get_config(this_ptr);
21315 return nativeResponseValue;
21317 // void ChannelDetails_set_config(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
21319 export function ChannelDetails_set_config(this_ptr: bigint, val: bigint): void {
21320 if(!isWasmInitialized) {
21321 throw new Error("initializeWasm() must be awaited first!");
21323 const nativeResponseValue = wasm.TS_ChannelDetails_set_config(this_ptr, val);
21324 // debug statements here
21326 // 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);
21328 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 {
21329 if(!isWasmInitialized) {
21330 throw new Error("initializeWasm() must be awaited first!");
21332 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);
21333 return nativeResponseValue;
21335 // uint64_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg);
21337 export function ChannelDetails_clone_ptr(arg: bigint): bigint {
21338 if(!isWasmInitialized) {
21339 throw new Error("initializeWasm() must be awaited first!");
21341 const nativeResponseValue = wasm.TS_ChannelDetails_clone_ptr(arg);
21342 return nativeResponseValue;
21344 // struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
21346 export function ChannelDetails_clone(orig: bigint): bigint {
21347 if(!isWasmInitialized) {
21348 throw new Error("initializeWasm() must be awaited first!");
21350 const nativeResponseValue = wasm.TS_ChannelDetails_clone(orig);
21351 return nativeResponseValue;
21353 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_inbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
21355 export function ChannelDetails_get_inbound_payment_scid(this_arg: bigint): bigint {
21356 if(!isWasmInitialized) {
21357 throw new Error("initializeWasm() must be awaited first!");
21359 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_payment_scid(this_arg);
21360 return nativeResponseValue;
21362 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_outbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
21364 export function ChannelDetails_get_outbound_payment_scid(this_arg: bigint): bigint {
21365 if(!isWasmInitialized) {
21366 throw new Error("initializeWasm() must be awaited first!");
21368 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_payment_scid(this_arg);
21369 return nativeResponseValue;
21371 // void PaymentSendFailure_free(struct LDKPaymentSendFailure this_ptr);
21373 export function PaymentSendFailure_free(this_ptr: bigint): void {
21374 if(!isWasmInitialized) {
21375 throw new Error("initializeWasm() must be awaited first!");
21377 const nativeResponseValue = wasm.TS_PaymentSendFailure_free(this_ptr);
21378 // debug statements here
21380 // uint64_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg);
21382 export function PaymentSendFailure_clone_ptr(arg: bigint): bigint {
21383 if(!isWasmInitialized) {
21384 throw new Error("initializeWasm() must be awaited first!");
21386 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone_ptr(arg);
21387 return nativeResponseValue;
21389 // struct LDKPaymentSendFailure PaymentSendFailure_clone(const struct LDKPaymentSendFailure *NONNULL_PTR orig);
21391 export function PaymentSendFailure_clone(orig: bigint): bigint {
21392 if(!isWasmInitialized) {
21393 throw new Error("initializeWasm() must be awaited first!");
21395 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone(orig);
21396 return nativeResponseValue;
21398 // struct LDKPaymentSendFailure PaymentSendFailure_parameter_error(struct LDKAPIError a);
21400 export function PaymentSendFailure_parameter_error(a: bigint): bigint {
21401 if(!isWasmInitialized) {
21402 throw new Error("initializeWasm() must be awaited first!");
21404 const nativeResponseValue = wasm.TS_PaymentSendFailure_parameter_error(a);
21405 return nativeResponseValue;
21407 // struct LDKPaymentSendFailure PaymentSendFailure_path_parameter_error(struct LDKCVec_CResult_NoneAPIErrorZZ a);
21409 export function PaymentSendFailure_path_parameter_error(a: number): bigint {
21410 if(!isWasmInitialized) {
21411 throw new Error("initializeWasm() must be awaited first!");
21413 const nativeResponseValue = wasm.TS_PaymentSendFailure_path_parameter_error(a);
21414 return nativeResponseValue;
21416 // struct LDKPaymentSendFailure PaymentSendFailure_all_failed_retry_safe(struct LDKCVec_APIErrorZ a);
21418 export function PaymentSendFailure_all_failed_retry_safe(a: number): bigint {
21419 if(!isWasmInitialized) {
21420 throw new Error("initializeWasm() must be awaited first!");
21422 const nativeResponseValue = wasm.TS_PaymentSendFailure_all_failed_retry_safe(a);
21423 return nativeResponseValue;
21425 // struct LDKPaymentSendFailure PaymentSendFailure_partial_failure(struct LDKCVec_CResult_NoneAPIErrorZZ results, struct LDKRouteParameters failed_paths_retry, struct LDKThirtyTwoBytes payment_id);
21427 export function PaymentSendFailure_partial_failure(results: number, failed_paths_retry: bigint, payment_id: number): bigint {
21428 if(!isWasmInitialized) {
21429 throw new Error("initializeWasm() must be awaited first!");
21431 const nativeResponseValue = wasm.TS_PaymentSendFailure_partial_failure(results, failed_paths_retry, payment_id);
21432 return nativeResponseValue;
21434 // void PhantomRouteHints_free(struct LDKPhantomRouteHints this_obj);
21436 export function PhantomRouteHints_free(this_obj: bigint): void {
21437 if(!isWasmInitialized) {
21438 throw new Error("initializeWasm() must be awaited first!");
21440 const nativeResponseValue = wasm.TS_PhantomRouteHints_free(this_obj);
21441 // debug statements here
21443 // struct LDKCVec_ChannelDetailsZ PhantomRouteHints_get_channels(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
21445 export function PhantomRouteHints_get_channels(this_ptr: bigint): number {
21446 if(!isWasmInitialized) {
21447 throw new Error("initializeWasm() must be awaited first!");
21449 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_channels(this_ptr);
21450 return nativeResponseValue;
21452 // void PhantomRouteHints_set_channels(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKCVec_ChannelDetailsZ val);
21454 export function PhantomRouteHints_set_channels(this_ptr: bigint, val: number): void {
21455 if(!isWasmInitialized) {
21456 throw new Error("initializeWasm() must be awaited first!");
21458 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_channels(this_ptr, val);
21459 // debug statements here
21461 // uint64_t PhantomRouteHints_get_phantom_scid(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
21463 export function PhantomRouteHints_get_phantom_scid(this_ptr: bigint): bigint {
21464 if(!isWasmInitialized) {
21465 throw new Error("initializeWasm() must be awaited first!");
21467 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_phantom_scid(this_ptr);
21468 return nativeResponseValue;
21470 // void PhantomRouteHints_set_phantom_scid(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, uint64_t val);
21472 export function PhantomRouteHints_set_phantom_scid(this_ptr: bigint, val: bigint): void {
21473 if(!isWasmInitialized) {
21474 throw new Error("initializeWasm() must be awaited first!");
21476 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_phantom_scid(this_ptr, val);
21477 // debug statements here
21479 // struct LDKPublicKey PhantomRouteHints_get_real_node_pubkey(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
21481 export function PhantomRouteHints_get_real_node_pubkey(this_ptr: bigint): number {
21482 if(!isWasmInitialized) {
21483 throw new Error("initializeWasm() must be awaited first!");
21485 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_real_node_pubkey(this_ptr);
21486 return nativeResponseValue;
21488 // void PhantomRouteHints_set_real_node_pubkey(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21490 export function PhantomRouteHints_set_real_node_pubkey(this_ptr: bigint, val: number): void {
21491 if(!isWasmInitialized) {
21492 throw new Error("initializeWasm() must be awaited first!");
21494 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_real_node_pubkey(this_ptr, val);
21495 // debug statements here
21497 // MUST_USE_RES struct LDKPhantomRouteHints PhantomRouteHints_new(struct LDKCVec_ChannelDetailsZ channels_arg, uint64_t phantom_scid_arg, struct LDKPublicKey real_node_pubkey_arg);
21499 export function PhantomRouteHints_new(channels_arg: number, phantom_scid_arg: bigint, real_node_pubkey_arg: number): bigint {
21500 if(!isWasmInitialized) {
21501 throw new Error("initializeWasm() must be awaited first!");
21503 const nativeResponseValue = wasm.TS_PhantomRouteHints_new(channels_arg, phantom_scid_arg, real_node_pubkey_arg);
21504 return nativeResponseValue;
21506 // uint64_t PhantomRouteHints_clone_ptr(LDKPhantomRouteHints *NONNULL_PTR arg);
21508 export function PhantomRouteHints_clone_ptr(arg: bigint): bigint {
21509 if(!isWasmInitialized) {
21510 throw new Error("initializeWasm() must be awaited first!");
21512 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone_ptr(arg);
21513 return nativeResponseValue;
21515 // struct LDKPhantomRouteHints PhantomRouteHints_clone(const struct LDKPhantomRouteHints *NONNULL_PTR orig);
21517 export function PhantomRouteHints_clone(orig: bigint): bigint {
21518 if(!isWasmInitialized) {
21519 throw new Error("initializeWasm() must be awaited first!");
21521 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone(orig);
21522 return nativeResponseValue;
21524 // 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);
21526 export function ChannelManager_new(fee_est: bigint, chain_monitor: bigint, tx_broadcaster: bigint, logger: bigint, keys_manager: bigint, config: bigint, params: bigint): bigint {
21527 if(!isWasmInitialized) {
21528 throw new Error("initializeWasm() must be awaited first!");
21530 const nativeResponseValue = wasm.TS_ChannelManager_new(fee_est, chain_monitor, tx_broadcaster, logger, keys_manager, config, params);
21531 return nativeResponseValue;
21533 // MUST_USE_RES struct LDKUserConfig ChannelManager_get_current_default_configuration(const struct LDKChannelManager *NONNULL_PTR this_arg);
21535 export function ChannelManager_get_current_default_configuration(this_arg: bigint): bigint {
21536 if(!isWasmInitialized) {
21537 throw new Error("initializeWasm() must be awaited first!");
21539 const nativeResponseValue = wasm.TS_ChannelManager_get_current_default_configuration(this_arg);
21540 return nativeResponseValue;
21542 // 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);
21544 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 {
21545 if(!isWasmInitialized) {
21546 throw new Error("initializeWasm() must be awaited first!");
21548 const nativeResponseValue = wasm.TS_ChannelManager_create_channel(this_arg, their_network_key, channel_value_satoshis, push_msat, user_channel_id, override_config);
21549 return nativeResponseValue;
21551 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
21553 export function ChannelManager_list_channels(this_arg: bigint): number {
21554 if(!isWasmInitialized) {
21555 throw new Error("initializeWasm() must be awaited first!");
21557 const nativeResponseValue = wasm.TS_ChannelManager_list_channels(this_arg);
21558 return nativeResponseValue;
21560 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_usable_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
21562 export function ChannelManager_list_usable_channels(this_arg: bigint): number {
21563 if(!isWasmInitialized) {
21564 throw new Error("initializeWasm() must be awaited first!");
21566 const nativeResponseValue = wasm.TS_ChannelManager_list_usable_channels(this_arg);
21567 return nativeResponseValue;
21569 // 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);
21571 export function ChannelManager_close_channel(this_arg: bigint, channel_id: number, counterparty_node_id: number): bigint {
21572 if(!isWasmInitialized) {
21573 throw new Error("initializeWasm() must be awaited first!");
21575 const nativeResponseValue = wasm.TS_ChannelManager_close_channel(this_arg, channel_id, counterparty_node_id);
21576 return nativeResponseValue;
21578 // 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);
21580 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 {
21581 if(!isWasmInitialized) {
21582 throw new Error("initializeWasm() must be awaited first!");
21584 const nativeResponseValue = wasm.TS_ChannelManager_close_channel_with_target_feerate(this_arg, channel_id, counterparty_node_id, target_feerate_sats_per_1000_weight);
21585 return nativeResponseValue;
21587 // 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);
21589 export function ChannelManager_force_close_broadcasting_latest_txn(this_arg: bigint, channel_id: number, counterparty_node_id: number): bigint {
21590 if(!isWasmInitialized) {
21591 throw new Error("initializeWasm() must be awaited first!");
21593 const nativeResponseValue = wasm.TS_ChannelManager_force_close_broadcasting_latest_txn(this_arg, channel_id, counterparty_node_id);
21594 return nativeResponseValue;
21596 // 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);
21598 export function ChannelManager_force_close_without_broadcasting_txn(this_arg: bigint, channel_id: number, counterparty_node_id: number): bigint {
21599 if(!isWasmInitialized) {
21600 throw new Error("initializeWasm() must be awaited first!");
21602 const nativeResponseValue = wasm.TS_ChannelManager_force_close_without_broadcasting_txn(this_arg, channel_id, counterparty_node_id);
21603 return nativeResponseValue;
21605 // void ChannelManager_force_close_all_channels_broadcasting_latest_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
21607 export function ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg: bigint): void {
21608 if(!isWasmInitialized) {
21609 throw new Error("initializeWasm() must be awaited first!");
21611 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg);
21612 // debug statements here
21614 // void ChannelManager_force_close_all_channels_without_broadcasting_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
21616 export function ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg: bigint): void {
21617 if(!isWasmInitialized) {
21618 throw new Error("initializeWasm() must be awaited first!");
21620 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg);
21621 // debug statements here
21623 // 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);
21625 export function ChannelManager_send_payment(this_arg: bigint, route: bigint, payment_hash: number, payment_secret: number): bigint {
21626 if(!isWasmInitialized) {
21627 throw new Error("initializeWasm() must be awaited first!");
21629 const nativeResponseValue = wasm.TS_ChannelManager_send_payment(this_arg, route, payment_hash, payment_secret);
21630 return nativeResponseValue;
21632 // 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);
21634 export function ChannelManager_retry_payment(this_arg: bigint, route: bigint, payment_id: number): bigint {
21635 if(!isWasmInitialized) {
21636 throw new Error("initializeWasm() must be awaited first!");
21638 const nativeResponseValue = wasm.TS_ChannelManager_retry_payment(this_arg, route, payment_id);
21639 return nativeResponseValue;
21641 // void ChannelManager_abandon_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id);
21643 export function ChannelManager_abandon_payment(this_arg: bigint, payment_id: number): void {
21644 if(!isWasmInitialized) {
21645 throw new Error("initializeWasm() must be awaited first!");
21647 const nativeResponseValue = wasm.TS_ChannelManager_abandon_payment(this_arg, payment_id);
21648 // debug statements here
21650 // 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);
21652 export function ChannelManager_send_spontaneous_payment(this_arg: bigint, route: bigint, payment_preimage: number): bigint {
21653 if(!isWasmInitialized) {
21654 throw new Error("initializeWasm() must be awaited first!");
21656 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment(this_arg, route, payment_preimage);
21657 return nativeResponseValue;
21659 // MUST_USE_RES struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ ChannelManager_send_probe(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ hops);
21661 export function ChannelManager_send_probe(this_arg: bigint, hops: number): bigint {
21662 if(!isWasmInitialized) {
21663 throw new Error("initializeWasm() must be awaited first!");
21665 const nativeResponseValue = wasm.TS_ChannelManager_send_probe(this_arg, hops);
21666 return nativeResponseValue;
21668 // 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);
21670 export function ChannelManager_funding_transaction_generated(this_arg: bigint, temporary_channel_id: number, counterparty_node_id: number, funding_transaction: number): bigint {
21671 if(!isWasmInitialized) {
21672 throw new Error("initializeWasm() must be awaited first!");
21674 const nativeResponseValue = wasm.TS_ChannelManager_funding_transaction_generated(this_arg, temporary_channel_id, counterparty_node_id, funding_transaction);
21675 return nativeResponseValue;
21677 // 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);
21679 export function ChannelManager_update_channel_config(this_arg: bigint, counterparty_node_id: number, channel_ids: number, config: bigint): bigint {
21680 if(!isWasmInitialized) {
21681 throw new Error("initializeWasm() must be awaited first!");
21683 const nativeResponseValue = wasm.TS_ChannelManager_update_channel_config(this_arg, counterparty_node_id, channel_ids, config);
21684 return nativeResponseValue;
21686 // void ChannelManager_process_pending_htlc_forwards(const struct LDKChannelManager *NONNULL_PTR this_arg);
21688 export function ChannelManager_process_pending_htlc_forwards(this_arg: bigint): void {
21689 if(!isWasmInitialized) {
21690 throw new Error("initializeWasm() must be awaited first!");
21692 const nativeResponseValue = wasm.TS_ChannelManager_process_pending_htlc_forwards(this_arg);
21693 // debug statements here
21695 // void ChannelManager_timer_tick_occurred(const struct LDKChannelManager *NONNULL_PTR this_arg);
21697 export function ChannelManager_timer_tick_occurred(this_arg: bigint): void {
21698 if(!isWasmInitialized) {
21699 throw new Error("initializeWasm() must be awaited first!");
21701 const nativeResponseValue = wasm.TS_ChannelManager_timer_tick_occurred(this_arg);
21702 // debug statements here
21704 // void ChannelManager_fail_htlc_backwards(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
21706 export function ChannelManager_fail_htlc_backwards(this_arg: bigint, payment_hash: number): void {
21707 if(!isWasmInitialized) {
21708 throw new Error("initializeWasm() must be awaited first!");
21710 const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards(this_arg, payment_hash);
21711 // debug statements here
21713 // void ChannelManager_claim_funds(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
21715 export function ChannelManager_claim_funds(this_arg: bigint, payment_preimage: number): void {
21716 if(!isWasmInitialized) {
21717 throw new Error("initializeWasm() must be awaited first!");
21719 const nativeResponseValue = wasm.TS_ChannelManager_claim_funds(this_arg, payment_preimage);
21720 // debug statements here
21722 // MUST_USE_RES struct LDKPublicKey ChannelManager_get_our_node_id(const struct LDKChannelManager *NONNULL_PTR this_arg);
21724 export function ChannelManager_get_our_node_id(this_arg: bigint): number {
21725 if(!isWasmInitialized) {
21726 throw new Error("initializeWasm() must be awaited first!");
21728 const nativeResponseValue = wasm.TS_ChannelManager_get_our_node_id(this_arg);
21729 return nativeResponseValue;
21731 // 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);
21733 export function ChannelManager_accept_inbound_channel(this_arg: bigint, temporary_channel_id: number, counterparty_node_id: number, user_channel_id: bigint): bigint {
21734 if(!isWasmInitialized) {
21735 throw new Error("initializeWasm() must be awaited first!");
21737 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
21738 return nativeResponseValue;
21740 // 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);
21742 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 {
21743 if(!isWasmInitialized) {
21744 throw new Error("initializeWasm() must be awaited first!");
21746 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
21747 return nativeResponseValue;
21749 // 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);
21751 export function ChannelManager_create_inbound_payment(this_arg: bigint, min_value_msat: bigint, invoice_expiry_delta_secs: number): bigint {
21752 if(!isWasmInitialized) {
21753 throw new Error("initializeWasm() must be awaited first!");
21755 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment(this_arg, min_value_msat, invoice_expiry_delta_secs);
21756 return nativeResponseValue;
21758 // 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);
21760 export function ChannelManager_create_inbound_payment_legacy(this_arg: bigint, min_value_msat: bigint, invoice_expiry_delta_secs: number): bigint {
21761 if(!isWasmInitialized) {
21762 throw new Error("initializeWasm() must be awaited first!");
21764 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_legacy(this_arg, min_value_msat, invoice_expiry_delta_secs);
21765 return nativeResponseValue;
21767 // 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);
21769 export function ChannelManager_create_inbound_payment_for_hash(this_arg: bigint, payment_hash: number, min_value_msat: bigint, invoice_expiry_delta_secs: number): bigint {
21770 if(!isWasmInitialized) {
21771 throw new Error("initializeWasm() must be awaited first!");
21773 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
21774 return nativeResponseValue;
21776 // 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);
21778 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 {
21779 if(!isWasmInitialized) {
21780 throw new Error("initializeWasm() must be awaited first!");
21782 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash_legacy(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
21783 return nativeResponseValue;
21785 // 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);
21787 export function ChannelManager_get_payment_preimage(this_arg: bigint, payment_hash: number, payment_secret: number): bigint {
21788 if(!isWasmInitialized) {
21789 throw new Error("initializeWasm() must be awaited first!");
21791 const nativeResponseValue = wasm.TS_ChannelManager_get_payment_preimage(this_arg, payment_hash, payment_secret);
21792 return nativeResponseValue;
21794 // MUST_USE_RES uint64_t ChannelManager_get_phantom_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
21796 export function ChannelManager_get_phantom_scid(this_arg: bigint): bigint {
21797 if(!isWasmInitialized) {
21798 throw new Error("initializeWasm() must be awaited first!");
21800 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_scid(this_arg);
21801 return nativeResponseValue;
21803 // MUST_USE_RES struct LDKPhantomRouteHints ChannelManager_get_phantom_route_hints(const struct LDKChannelManager *NONNULL_PTR this_arg);
21805 export function ChannelManager_get_phantom_route_hints(this_arg: bigint): bigint {
21806 if(!isWasmInitialized) {
21807 throw new Error("initializeWasm() must be awaited first!");
21809 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_route_hints(this_arg);
21810 return nativeResponseValue;
21812 // struct LDKMessageSendEventsProvider ChannelManager_as_MessageSendEventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
21814 export function ChannelManager_as_MessageSendEventsProvider(this_arg: bigint): bigint {
21815 if(!isWasmInitialized) {
21816 throw new Error("initializeWasm() must be awaited first!");
21818 const nativeResponseValue = wasm.TS_ChannelManager_as_MessageSendEventsProvider(this_arg);
21819 return nativeResponseValue;
21821 // struct LDKEventsProvider ChannelManager_as_EventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
21823 export function ChannelManager_as_EventsProvider(this_arg: bigint): bigint {
21824 if(!isWasmInitialized) {
21825 throw new Error("initializeWasm() must be awaited first!");
21827 const nativeResponseValue = wasm.TS_ChannelManager_as_EventsProvider(this_arg);
21828 return nativeResponseValue;
21830 // struct LDKListen ChannelManager_as_Listen(const struct LDKChannelManager *NONNULL_PTR this_arg);
21832 export function ChannelManager_as_Listen(this_arg: bigint): bigint {
21833 if(!isWasmInitialized) {
21834 throw new Error("initializeWasm() must be awaited first!");
21836 const nativeResponseValue = wasm.TS_ChannelManager_as_Listen(this_arg);
21837 return nativeResponseValue;
21839 // struct LDKConfirm ChannelManager_as_Confirm(const struct LDKChannelManager *NONNULL_PTR this_arg);
21841 export function ChannelManager_as_Confirm(this_arg: bigint): bigint {
21842 if(!isWasmInitialized) {
21843 throw new Error("initializeWasm() must be awaited first!");
21845 const nativeResponseValue = wasm.TS_ChannelManager_as_Confirm(this_arg);
21846 return nativeResponseValue;
21848 // void ChannelManager_await_persistable_update(const struct LDKChannelManager *NONNULL_PTR this_arg);
21850 export function ChannelManager_await_persistable_update(this_arg: bigint): void {
21851 if(!isWasmInitialized) {
21852 throw new Error("initializeWasm() must be awaited first!");
21854 const nativeResponseValue = wasm.TS_ChannelManager_await_persistable_update(this_arg);
21855 // debug statements here
21857 // MUST_USE_RES struct LDKFuture ChannelManager_get_persistable_update_future(const struct LDKChannelManager *NONNULL_PTR this_arg);
21859 export function ChannelManager_get_persistable_update_future(this_arg: bigint): bigint {
21860 if(!isWasmInitialized) {
21861 throw new Error("initializeWasm() must be awaited first!");
21863 const nativeResponseValue = wasm.TS_ChannelManager_get_persistable_update_future(this_arg);
21864 return nativeResponseValue;
21866 // MUST_USE_RES struct LDKBestBlock ChannelManager_current_best_block(const struct LDKChannelManager *NONNULL_PTR this_arg);
21868 export function ChannelManager_current_best_block(this_arg: bigint): bigint {
21869 if(!isWasmInitialized) {
21870 throw new Error("initializeWasm() must be awaited first!");
21872 const nativeResponseValue = wasm.TS_ChannelManager_current_best_block(this_arg);
21873 return nativeResponseValue;
21875 // struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
21877 export function ChannelManager_as_ChannelMessageHandler(this_arg: bigint): bigint {
21878 if(!isWasmInitialized) {
21879 throw new Error("initializeWasm() must be awaited first!");
21881 const nativeResponseValue = wasm.TS_ChannelManager_as_ChannelMessageHandler(this_arg);
21882 return nativeResponseValue;
21884 // struct LDKNodeFeatures provided_node_features(void);
21886 export function provided_node_features(): bigint {
21887 if(!isWasmInitialized) {
21888 throw new Error("initializeWasm() must be awaited first!");
21890 const nativeResponseValue = wasm.TS_provided_node_features();
21891 return nativeResponseValue;
21893 // struct LDKChannelFeatures provided_channel_features(void);
21895 export function provided_channel_features(): bigint {
21896 if(!isWasmInitialized) {
21897 throw new Error("initializeWasm() must be awaited first!");
21899 const nativeResponseValue = wasm.TS_provided_channel_features();
21900 return nativeResponseValue;
21902 // struct LDKInitFeatures provided_init_features(void);
21904 export function provided_init_features(): bigint {
21905 if(!isWasmInitialized) {
21906 throw new Error("initializeWasm() must be awaited first!");
21908 const nativeResponseValue = wasm.TS_provided_init_features();
21909 return nativeResponseValue;
21911 // struct LDKCVec_u8Z CounterpartyForwardingInfo_write(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR obj);
21913 export function CounterpartyForwardingInfo_write(obj: bigint): number {
21914 if(!isWasmInitialized) {
21915 throw new Error("initializeWasm() must be awaited first!");
21917 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_write(obj);
21918 return nativeResponseValue;
21920 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CounterpartyForwardingInfo_read(struct LDKu8slice ser);
21922 export function CounterpartyForwardingInfo_read(ser: number): bigint {
21923 if(!isWasmInitialized) {
21924 throw new Error("initializeWasm() must be awaited first!");
21926 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_read(ser);
21927 return nativeResponseValue;
21929 // struct LDKCVec_u8Z ChannelCounterparty_write(const struct LDKChannelCounterparty *NONNULL_PTR obj);
21931 export function ChannelCounterparty_write(obj: bigint): number {
21932 if(!isWasmInitialized) {
21933 throw new Error("initializeWasm() must be awaited first!");
21935 const nativeResponseValue = wasm.TS_ChannelCounterparty_write(obj);
21936 return nativeResponseValue;
21938 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ ChannelCounterparty_read(struct LDKu8slice ser);
21940 export function ChannelCounterparty_read(ser: number): bigint {
21941 if(!isWasmInitialized) {
21942 throw new Error("initializeWasm() must be awaited first!");
21944 const nativeResponseValue = wasm.TS_ChannelCounterparty_read(ser);
21945 return nativeResponseValue;
21947 // struct LDKCVec_u8Z ChannelDetails_write(const struct LDKChannelDetails *NONNULL_PTR obj);
21949 export function ChannelDetails_write(obj: bigint): number {
21950 if(!isWasmInitialized) {
21951 throw new Error("initializeWasm() must be awaited first!");
21953 const nativeResponseValue = wasm.TS_ChannelDetails_write(obj);
21954 return nativeResponseValue;
21956 // struct LDKCResult_ChannelDetailsDecodeErrorZ ChannelDetails_read(struct LDKu8slice ser);
21958 export function ChannelDetails_read(ser: number): bigint {
21959 if(!isWasmInitialized) {
21960 throw new Error("initializeWasm() must be awaited first!");
21962 const nativeResponseValue = wasm.TS_ChannelDetails_read(ser);
21963 return nativeResponseValue;
21965 // struct LDKCVec_u8Z PhantomRouteHints_write(const struct LDKPhantomRouteHints *NONNULL_PTR obj);
21967 export function PhantomRouteHints_write(obj: bigint): number {
21968 if(!isWasmInitialized) {
21969 throw new Error("initializeWasm() must be awaited first!");
21971 const nativeResponseValue = wasm.TS_PhantomRouteHints_write(obj);
21972 return nativeResponseValue;
21974 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ PhantomRouteHints_read(struct LDKu8slice ser);
21976 export function PhantomRouteHints_read(ser: number): bigint {
21977 if(!isWasmInitialized) {
21978 throw new Error("initializeWasm() must be awaited first!");
21980 const nativeResponseValue = wasm.TS_PhantomRouteHints_read(ser);
21981 return nativeResponseValue;
21983 // struct LDKCVec_u8Z ChannelManager_write(const struct LDKChannelManager *NONNULL_PTR obj);
21985 export function ChannelManager_write(obj: bigint): number {
21986 if(!isWasmInitialized) {
21987 throw new Error("initializeWasm() must be awaited first!");
21989 const nativeResponseValue = wasm.TS_ChannelManager_write(obj);
21990 return nativeResponseValue;
21992 // void ChannelManagerReadArgs_free(struct LDKChannelManagerReadArgs this_obj);
21994 export function ChannelManagerReadArgs_free(this_obj: bigint): void {
21995 if(!isWasmInitialized) {
21996 throw new Error("initializeWasm() must be awaited first!");
21998 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_free(this_obj);
21999 // debug statements here
22001 // const struct LDKKeysInterface *ChannelManagerReadArgs_get_keys_manager(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
22003 export function ChannelManagerReadArgs_get_keys_manager(this_ptr: bigint): bigint {
22004 if(!isWasmInitialized) {
22005 throw new Error("initializeWasm() must be awaited first!");
22007 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_keys_manager(this_ptr);
22008 return nativeResponseValue;
22010 // void ChannelManagerReadArgs_set_keys_manager(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKKeysInterface val);
22012 export function ChannelManagerReadArgs_set_keys_manager(this_ptr: bigint, val: bigint): void {
22013 if(!isWasmInitialized) {
22014 throw new Error("initializeWasm() must be awaited first!");
22016 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_keys_manager(this_ptr, val);
22017 // debug statements here
22019 // const struct LDKFeeEstimator *ChannelManagerReadArgs_get_fee_estimator(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
22021 export function ChannelManagerReadArgs_get_fee_estimator(this_ptr: bigint): bigint {
22022 if(!isWasmInitialized) {
22023 throw new Error("initializeWasm() must be awaited first!");
22025 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_fee_estimator(this_ptr);
22026 return nativeResponseValue;
22028 // void ChannelManagerReadArgs_set_fee_estimator(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKFeeEstimator val);
22030 export function ChannelManagerReadArgs_set_fee_estimator(this_ptr: bigint, val: bigint): void {
22031 if(!isWasmInitialized) {
22032 throw new Error("initializeWasm() must be awaited first!");
22034 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_fee_estimator(this_ptr, val);
22035 // debug statements here
22037 // const struct LDKWatch *ChannelManagerReadArgs_get_chain_monitor(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
22039 export function ChannelManagerReadArgs_get_chain_monitor(this_ptr: bigint): bigint {
22040 if(!isWasmInitialized) {
22041 throw new Error("initializeWasm() must be awaited first!");
22043 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_chain_monitor(this_ptr);
22044 return nativeResponseValue;
22046 // void ChannelManagerReadArgs_set_chain_monitor(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKWatch val);
22048 export function ChannelManagerReadArgs_set_chain_monitor(this_ptr: bigint, val: bigint): void {
22049 if(!isWasmInitialized) {
22050 throw new Error("initializeWasm() must be awaited first!");
22052 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_chain_monitor(this_ptr, val);
22053 // debug statements here
22055 // const struct LDKBroadcasterInterface *ChannelManagerReadArgs_get_tx_broadcaster(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
22057 export function ChannelManagerReadArgs_get_tx_broadcaster(this_ptr: bigint): bigint {
22058 if(!isWasmInitialized) {
22059 throw new Error("initializeWasm() must be awaited first!");
22061 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_tx_broadcaster(this_ptr);
22062 return nativeResponseValue;
22064 // void ChannelManagerReadArgs_set_tx_broadcaster(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKBroadcasterInterface val);
22066 export function ChannelManagerReadArgs_set_tx_broadcaster(this_ptr: bigint, val: bigint): void {
22067 if(!isWasmInitialized) {
22068 throw new Error("initializeWasm() must be awaited first!");
22070 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_tx_broadcaster(this_ptr, val);
22071 // debug statements here
22073 // const struct LDKLogger *ChannelManagerReadArgs_get_logger(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
22075 export function ChannelManagerReadArgs_get_logger(this_ptr: bigint): bigint {
22076 if(!isWasmInitialized) {
22077 throw new Error("initializeWasm() must be awaited first!");
22079 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_logger(this_ptr);
22080 return nativeResponseValue;
22082 // void ChannelManagerReadArgs_set_logger(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKLogger val);
22084 export function ChannelManagerReadArgs_set_logger(this_ptr: bigint, val: bigint): void {
22085 if(!isWasmInitialized) {
22086 throw new Error("initializeWasm() must be awaited first!");
22088 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_logger(this_ptr, val);
22089 // debug statements here
22091 // struct LDKUserConfig ChannelManagerReadArgs_get_default_config(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
22093 export function ChannelManagerReadArgs_get_default_config(this_ptr: bigint): bigint {
22094 if(!isWasmInitialized) {
22095 throw new Error("initializeWasm() must be awaited first!");
22097 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_default_config(this_ptr);
22098 return nativeResponseValue;
22100 // void ChannelManagerReadArgs_set_default_config(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKUserConfig val);
22102 export function ChannelManagerReadArgs_set_default_config(this_ptr: bigint, val: bigint): void {
22103 if(!isWasmInitialized) {
22104 throw new Error("initializeWasm() must be awaited first!");
22106 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_default_config(this_ptr, val);
22107 // debug statements here
22109 // 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);
22111 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 {
22112 if(!isWasmInitialized) {
22113 throw new Error("initializeWasm() must be awaited first!");
22115 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_new(keys_manager, fee_estimator, chain_monitor, tx_broadcaster, logger, default_config, channel_monitors);
22116 return nativeResponseValue;
22118 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ C2Tuple_BlockHashChannelManagerZ_read(struct LDKu8slice ser, struct LDKChannelManagerReadArgs arg);
22120 export function C2Tuple_BlockHashChannelManagerZ_read(ser: number, arg: bigint): bigint {
22121 if(!isWasmInitialized) {
22122 throw new Error("initializeWasm() must be awaited first!");
22124 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_read(ser, arg);
22125 return nativeResponseValue;
22127 // void ExpandedKey_free(struct LDKExpandedKey this_obj);
22129 export function ExpandedKey_free(this_obj: bigint): void {
22130 if(!isWasmInitialized) {
22131 throw new Error("initializeWasm() must be awaited first!");
22133 const nativeResponseValue = wasm.TS_ExpandedKey_free(this_obj);
22134 // debug statements here
22136 // MUST_USE_RES struct LDKExpandedKey ExpandedKey_new(const uint8_t (*key_material)[32]);
22138 export function ExpandedKey_new(key_material: number): bigint {
22139 if(!isWasmInitialized) {
22140 throw new Error("initializeWasm() must be awaited first!");
22142 const nativeResponseValue = wasm.TS_ExpandedKey_new(key_material);
22143 return nativeResponseValue;
22145 // 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);
22147 export function create(keys: bigint, min_value_msat: bigint, invoice_expiry_delta_secs: number, keys_manager: bigint, current_time: bigint): bigint {
22148 if(!isWasmInitialized) {
22149 throw new Error("initializeWasm() must be awaited first!");
22151 const nativeResponseValue = wasm.TS_create(keys, min_value_msat, invoice_expiry_delta_secs, keys_manager, current_time);
22152 return nativeResponseValue;
22154 // 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);
22156 export function create_from_hash(keys: bigint, min_value_msat: bigint, payment_hash: number, invoice_expiry_delta_secs: number, current_time: bigint): bigint {
22157 if(!isWasmInitialized) {
22158 throw new Error("initializeWasm() must be awaited first!");
22160 const nativeResponseValue = wasm.TS_create_from_hash(keys, min_value_msat, payment_hash, invoice_expiry_delta_secs, current_time);
22161 return nativeResponseValue;
22163 // void DecodeError_free(struct LDKDecodeError this_ptr);
22165 export function DecodeError_free(this_ptr: bigint): void {
22166 if(!isWasmInitialized) {
22167 throw new Error("initializeWasm() must be awaited first!");
22169 const nativeResponseValue = wasm.TS_DecodeError_free(this_ptr);
22170 // debug statements here
22172 // uint64_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg);
22174 export function DecodeError_clone_ptr(arg: bigint): bigint {
22175 if(!isWasmInitialized) {
22176 throw new Error("initializeWasm() must be awaited first!");
22178 const nativeResponseValue = wasm.TS_DecodeError_clone_ptr(arg);
22179 return nativeResponseValue;
22181 // struct LDKDecodeError DecodeError_clone(const struct LDKDecodeError *NONNULL_PTR orig);
22183 export function DecodeError_clone(orig: bigint): bigint {
22184 if(!isWasmInitialized) {
22185 throw new Error("initializeWasm() must be awaited first!");
22187 const nativeResponseValue = wasm.TS_DecodeError_clone(orig);
22188 return nativeResponseValue;
22190 // struct LDKDecodeError DecodeError_unknown_version(void);
22192 export function DecodeError_unknown_version(): bigint {
22193 if(!isWasmInitialized) {
22194 throw new Error("initializeWasm() must be awaited first!");
22196 const nativeResponseValue = wasm.TS_DecodeError_unknown_version();
22197 return nativeResponseValue;
22199 // struct LDKDecodeError DecodeError_unknown_required_feature(void);
22201 export function DecodeError_unknown_required_feature(): bigint {
22202 if(!isWasmInitialized) {
22203 throw new Error("initializeWasm() must be awaited first!");
22205 const nativeResponseValue = wasm.TS_DecodeError_unknown_required_feature();
22206 return nativeResponseValue;
22208 // struct LDKDecodeError DecodeError_invalid_value(void);
22210 export function DecodeError_invalid_value(): bigint {
22211 if(!isWasmInitialized) {
22212 throw new Error("initializeWasm() must be awaited first!");
22214 const nativeResponseValue = wasm.TS_DecodeError_invalid_value();
22215 return nativeResponseValue;
22217 // struct LDKDecodeError DecodeError_short_read(void);
22219 export function DecodeError_short_read(): bigint {
22220 if(!isWasmInitialized) {
22221 throw new Error("initializeWasm() must be awaited first!");
22223 const nativeResponseValue = wasm.TS_DecodeError_short_read();
22224 return nativeResponseValue;
22226 // struct LDKDecodeError DecodeError_bad_length_descriptor(void);
22228 export function DecodeError_bad_length_descriptor(): bigint {
22229 if(!isWasmInitialized) {
22230 throw new Error("initializeWasm() must be awaited first!");
22232 const nativeResponseValue = wasm.TS_DecodeError_bad_length_descriptor();
22233 return nativeResponseValue;
22235 // struct LDKDecodeError DecodeError_io(enum LDKIOError a);
22237 export function DecodeError_io(a: IOError): bigint {
22238 if(!isWasmInitialized) {
22239 throw new Error("initializeWasm() must be awaited first!");
22241 const nativeResponseValue = wasm.TS_DecodeError_io(a);
22242 return nativeResponseValue;
22244 // struct LDKDecodeError DecodeError_unsupported_compression(void);
22246 export function DecodeError_unsupported_compression(): bigint {
22247 if(!isWasmInitialized) {
22248 throw new Error("initializeWasm() must be awaited first!");
22250 const nativeResponseValue = wasm.TS_DecodeError_unsupported_compression();
22251 return nativeResponseValue;
22253 // bool DecodeError_eq(const struct LDKDecodeError *NONNULL_PTR a, const struct LDKDecodeError *NONNULL_PTR b);
22255 export function DecodeError_eq(a: bigint, b: bigint): boolean {
22256 if(!isWasmInitialized) {
22257 throw new Error("initializeWasm() must be awaited first!");
22259 const nativeResponseValue = wasm.TS_DecodeError_eq(a, b);
22260 return nativeResponseValue;
22262 // void Init_free(struct LDKInit this_obj);
22264 export function Init_free(this_obj: bigint): void {
22265 if(!isWasmInitialized) {
22266 throw new Error("initializeWasm() must be awaited first!");
22268 const nativeResponseValue = wasm.TS_Init_free(this_obj);
22269 // debug statements here
22271 // struct LDKInitFeatures Init_get_features(const struct LDKInit *NONNULL_PTR this_ptr);
22273 export function Init_get_features(this_ptr: bigint): bigint {
22274 if(!isWasmInitialized) {
22275 throw new Error("initializeWasm() must be awaited first!");
22277 const nativeResponseValue = wasm.TS_Init_get_features(this_ptr);
22278 return nativeResponseValue;
22280 // void Init_set_features(struct LDKInit *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
22282 export function Init_set_features(this_ptr: bigint, val: bigint): void {
22283 if(!isWasmInitialized) {
22284 throw new Error("initializeWasm() must be awaited first!");
22286 const nativeResponseValue = wasm.TS_Init_set_features(this_ptr, val);
22287 // debug statements here
22289 // struct LDKCOption_NetAddressZ Init_get_remote_network_address(const struct LDKInit *NONNULL_PTR this_ptr);
22291 export function Init_get_remote_network_address(this_ptr: bigint): bigint {
22292 if(!isWasmInitialized) {
22293 throw new Error("initializeWasm() must be awaited first!");
22295 const nativeResponseValue = wasm.TS_Init_get_remote_network_address(this_ptr);
22296 return nativeResponseValue;
22298 // void Init_set_remote_network_address(struct LDKInit *NONNULL_PTR this_ptr, struct LDKCOption_NetAddressZ val);
22300 export function Init_set_remote_network_address(this_ptr: bigint, val: bigint): void {
22301 if(!isWasmInitialized) {
22302 throw new Error("initializeWasm() must be awaited first!");
22304 const nativeResponseValue = wasm.TS_Init_set_remote_network_address(this_ptr, val);
22305 // debug statements here
22307 // MUST_USE_RES struct LDKInit Init_new(struct LDKInitFeatures features_arg, struct LDKCOption_NetAddressZ remote_network_address_arg);
22309 export function Init_new(features_arg: bigint, remote_network_address_arg: bigint): bigint {
22310 if(!isWasmInitialized) {
22311 throw new Error("initializeWasm() must be awaited first!");
22313 const nativeResponseValue = wasm.TS_Init_new(features_arg, remote_network_address_arg);
22314 return nativeResponseValue;
22316 // uint64_t Init_clone_ptr(LDKInit *NONNULL_PTR arg);
22318 export function Init_clone_ptr(arg: bigint): bigint {
22319 if(!isWasmInitialized) {
22320 throw new Error("initializeWasm() must be awaited first!");
22322 const nativeResponseValue = wasm.TS_Init_clone_ptr(arg);
22323 return nativeResponseValue;
22325 // struct LDKInit Init_clone(const struct LDKInit *NONNULL_PTR orig);
22327 export function Init_clone(orig: bigint): bigint {
22328 if(!isWasmInitialized) {
22329 throw new Error("initializeWasm() must be awaited first!");
22331 const nativeResponseValue = wasm.TS_Init_clone(orig);
22332 return nativeResponseValue;
22334 // bool Init_eq(const struct LDKInit *NONNULL_PTR a, const struct LDKInit *NONNULL_PTR b);
22336 export function Init_eq(a: bigint, b: bigint): boolean {
22337 if(!isWasmInitialized) {
22338 throw new Error("initializeWasm() must be awaited first!");
22340 const nativeResponseValue = wasm.TS_Init_eq(a, b);
22341 return nativeResponseValue;
22343 // void ErrorMessage_free(struct LDKErrorMessage this_obj);
22345 export function ErrorMessage_free(this_obj: bigint): void {
22346 if(!isWasmInitialized) {
22347 throw new Error("initializeWasm() must be awaited first!");
22349 const nativeResponseValue = wasm.TS_ErrorMessage_free(this_obj);
22350 // debug statements here
22352 // const uint8_t (*ErrorMessage_get_channel_id(const struct LDKErrorMessage *NONNULL_PTR this_ptr))[32];
22354 export function ErrorMessage_get_channel_id(this_ptr: bigint): number {
22355 if(!isWasmInitialized) {
22356 throw new Error("initializeWasm() must be awaited first!");
22358 const nativeResponseValue = wasm.TS_ErrorMessage_get_channel_id(this_ptr);
22359 return nativeResponseValue;
22361 // void ErrorMessage_set_channel_id(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22363 export function ErrorMessage_set_channel_id(this_ptr: bigint, val: number): void {
22364 if(!isWasmInitialized) {
22365 throw new Error("initializeWasm() must be awaited first!");
22367 const nativeResponseValue = wasm.TS_ErrorMessage_set_channel_id(this_ptr, val);
22368 // debug statements here
22370 // struct LDKStr ErrorMessage_get_data(const struct LDKErrorMessage *NONNULL_PTR this_ptr);
22372 export function ErrorMessage_get_data(this_ptr: bigint): number {
22373 if(!isWasmInitialized) {
22374 throw new Error("initializeWasm() must be awaited first!");
22376 const nativeResponseValue = wasm.TS_ErrorMessage_get_data(this_ptr);
22377 return nativeResponseValue;
22379 // void ErrorMessage_set_data(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKStr val);
22381 export function ErrorMessage_set_data(this_ptr: bigint, val: number): void {
22382 if(!isWasmInitialized) {
22383 throw new Error("initializeWasm() must be awaited first!");
22385 const nativeResponseValue = wasm.TS_ErrorMessage_set_data(this_ptr, val);
22386 // debug statements here
22388 // MUST_USE_RES struct LDKErrorMessage ErrorMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
22390 export function ErrorMessage_new(channel_id_arg: number, data_arg: number): bigint {
22391 if(!isWasmInitialized) {
22392 throw new Error("initializeWasm() must be awaited first!");
22394 const nativeResponseValue = wasm.TS_ErrorMessage_new(channel_id_arg, data_arg);
22395 return nativeResponseValue;
22397 // uint64_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg);
22399 export function ErrorMessage_clone_ptr(arg: bigint): bigint {
22400 if(!isWasmInitialized) {
22401 throw new Error("initializeWasm() must be awaited first!");
22403 const nativeResponseValue = wasm.TS_ErrorMessage_clone_ptr(arg);
22404 return nativeResponseValue;
22406 // struct LDKErrorMessage ErrorMessage_clone(const struct LDKErrorMessage *NONNULL_PTR orig);
22408 export function ErrorMessage_clone(orig: bigint): bigint {
22409 if(!isWasmInitialized) {
22410 throw new Error("initializeWasm() must be awaited first!");
22412 const nativeResponseValue = wasm.TS_ErrorMessage_clone(orig);
22413 return nativeResponseValue;
22415 // bool ErrorMessage_eq(const struct LDKErrorMessage *NONNULL_PTR a, const struct LDKErrorMessage *NONNULL_PTR b);
22417 export function ErrorMessage_eq(a: bigint, b: bigint): boolean {
22418 if(!isWasmInitialized) {
22419 throw new Error("initializeWasm() must be awaited first!");
22421 const nativeResponseValue = wasm.TS_ErrorMessage_eq(a, b);
22422 return nativeResponseValue;
22424 // void WarningMessage_free(struct LDKWarningMessage this_obj);
22426 export function WarningMessage_free(this_obj: bigint): void {
22427 if(!isWasmInitialized) {
22428 throw new Error("initializeWasm() must be awaited first!");
22430 const nativeResponseValue = wasm.TS_WarningMessage_free(this_obj);
22431 // debug statements here
22433 // const uint8_t (*WarningMessage_get_channel_id(const struct LDKWarningMessage *NONNULL_PTR this_ptr))[32];
22435 export function WarningMessage_get_channel_id(this_ptr: bigint): number {
22436 if(!isWasmInitialized) {
22437 throw new Error("initializeWasm() must be awaited first!");
22439 const nativeResponseValue = wasm.TS_WarningMessage_get_channel_id(this_ptr);
22440 return nativeResponseValue;
22442 // void WarningMessage_set_channel_id(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22444 export function WarningMessage_set_channel_id(this_ptr: bigint, val: number): void {
22445 if(!isWasmInitialized) {
22446 throw new Error("initializeWasm() must be awaited first!");
22448 const nativeResponseValue = wasm.TS_WarningMessage_set_channel_id(this_ptr, val);
22449 // debug statements here
22451 // struct LDKStr WarningMessage_get_data(const struct LDKWarningMessage *NONNULL_PTR this_ptr);
22453 export function WarningMessage_get_data(this_ptr: bigint): number {
22454 if(!isWasmInitialized) {
22455 throw new Error("initializeWasm() must be awaited first!");
22457 const nativeResponseValue = wasm.TS_WarningMessage_get_data(this_ptr);
22458 return nativeResponseValue;
22460 // void WarningMessage_set_data(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKStr val);
22462 export function WarningMessage_set_data(this_ptr: bigint, val: number): void {
22463 if(!isWasmInitialized) {
22464 throw new Error("initializeWasm() must be awaited first!");
22466 const nativeResponseValue = wasm.TS_WarningMessage_set_data(this_ptr, val);
22467 // debug statements here
22469 // MUST_USE_RES struct LDKWarningMessage WarningMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
22471 export function WarningMessage_new(channel_id_arg: number, data_arg: number): bigint {
22472 if(!isWasmInitialized) {
22473 throw new Error("initializeWasm() must be awaited first!");
22475 const nativeResponseValue = wasm.TS_WarningMessage_new(channel_id_arg, data_arg);
22476 return nativeResponseValue;
22478 // uint64_t WarningMessage_clone_ptr(LDKWarningMessage *NONNULL_PTR arg);
22480 export function WarningMessage_clone_ptr(arg: bigint): bigint {
22481 if(!isWasmInitialized) {
22482 throw new Error("initializeWasm() must be awaited first!");
22484 const nativeResponseValue = wasm.TS_WarningMessage_clone_ptr(arg);
22485 return nativeResponseValue;
22487 // struct LDKWarningMessage WarningMessage_clone(const struct LDKWarningMessage *NONNULL_PTR orig);
22489 export function WarningMessage_clone(orig: bigint): bigint {
22490 if(!isWasmInitialized) {
22491 throw new Error("initializeWasm() must be awaited first!");
22493 const nativeResponseValue = wasm.TS_WarningMessage_clone(orig);
22494 return nativeResponseValue;
22496 // bool WarningMessage_eq(const struct LDKWarningMessage *NONNULL_PTR a, const struct LDKWarningMessage *NONNULL_PTR b);
22498 export function WarningMessage_eq(a: bigint, b: bigint): boolean {
22499 if(!isWasmInitialized) {
22500 throw new Error("initializeWasm() must be awaited first!");
22502 const nativeResponseValue = wasm.TS_WarningMessage_eq(a, b);
22503 return nativeResponseValue;
22505 // void Ping_free(struct LDKPing this_obj);
22507 export function Ping_free(this_obj: bigint): void {
22508 if(!isWasmInitialized) {
22509 throw new Error("initializeWasm() must be awaited first!");
22511 const nativeResponseValue = wasm.TS_Ping_free(this_obj);
22512 // debug statements here
22514 // uint16_t Ping_get_ponglen(const struct LDKPing *NONNULL_PTR this_ptr);
22516 export function Ping_get_ponglen(this_ptr: bigint): number {
22517 if(!isWasmInitialized) {
22518 throw new Error("initializeWasm() must be awaited first!");
22520 const nativeResponseValue = wasm.TS_Ping_get_ponglen(this_ptr);
22521 return nativeResponseValue;
22523 // void Ping_set_ponglen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
22525 export function Ping_set_ponglen(this_ptr: bigint, val: number): void {
22526 if(!isWasmInitialized) {
22527 throw new Error("initializeWasm() must be awaited first!");
22529 const nativeResponseValue = wasm.TS_Ping_set_ponglen(this_ptr, val);
22530 // debug statements here
22532 // uint16_t Ping_get_byteslen(const struct LDKPing *NONNULL_PTR this_ptr);
22534 export function Ping_get_byteslen(this_ptr: bigint): number {
22535 if(!isWasmInitialized) {
22536 throw new Error("initializeWasm() must be awaited first!");
22538 const nativeResponseValue = wasm.TS_Ping_get_byteslen(this_ptr);
22539 return nativeResponseValue;
22541 // void Ping_set_byteslen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
22543 export function Ping_set_byteslen(this_ptr: bigint, val: number): void {
22544 if(!isWasmInitialized) {
22545 throw new Error("initializeWasm() must be awaited first!");
22547 const nativeResponseValue = wasm.TS_Ping_set_byteslen(this_ptr, val);
22548 // debug statements here
22550 // MUST_USE_RES struct LDKPing Ping_new(uint16_t ponglen_arg, uint16_t byteslen_arg);
22552 export function Ping_new(ponglen_arg: number, byteslen_arg: number): bigint {
22553 if(!isWasmInitialized) {
22554 throw new Error("initializeWasm() must be awaited first!");
22556 const nativeResponseValue = wasm.TS_Ping_new(ponglen_arg, byteslen_arg);
22557 return nativeResponseValue;
22559 // uint64_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg);
22561 export function Ping_clone_ptr(arg: bigint): bigint {
22562 if(!isWasmInitialized) {
22563 throw new Error("initializeWasm() must be awaited first!");
22565 const nativeResponseValue = wasm.TS_Ping_clone_ptr(arg);
22566 return nativeResponseValue;
22568 // struct LDKPing Ping_clone(const struct LDKPing *NONNULL_PTR orig);
22570 export function Ping_clone(orig: bigint): bigint {
22571 if(!isWasmInitialized) {
22572 throw new Error("initializeWasm() must be awaited first!");
22574 const nativeResponseValue = wasm.TS_Ping_clone(orig);
22575 return nativeResponseValue;
22577 // bool Ping_eq(const struct LDKPing *NONNULL_PTR a, const struct LDKPing *NONNULL_PTR b);
22579 export function Ping_eq(a: bigint, b: bigint): boolean {
22580 if(!isWasmInitialized) {
22581 throw new Error("initializeWasm() must be awaited first!");
22583 const nativeResponseValue = wasm.TS_Ping_eq(a, b);
22584 return nativeResponseValue;
22586 // void Pong_free(struct LDKPong this_obj);
22588 export function Pong_free(this_obj: bigint): void {
22589 if(!isWasmInitialized) {
22590 throw new Error("initializeWasm() must be awaited first!");
22592 const nativeResponseValue = wasm.TS_Pong_free(this_obj);
22593 // debug statements here
22595 // uint16_t Pong_get_byteslen(const struct LDKPong *NONNULL_PTR this_ptr);
22597 export function Pong_get_byteslen(this_ptr: bigint): number {
22598 if(!isWasmInitialized) {
22599 throw new Error("initializeWasm() must be awaited first!");
22601 const nativeResponseValue = wasm.TS_Pong_get_byteslen(this_ptr);
22602 return nativeResponseValue;
22604 // void Pong_set_byteslen(struct LDKPong *NONNULL_PTR this_ptr, uint16_t val);
22606 export function Pong_set_byteslen(this_ptr: bigint, val: number): void {
22607 if(!isWasmInitialized) {
22608 throw new Error("initializeWasm() must be awaited first!");
22610 const nativeResponseValue = wasm.TS_Pong_set_byteslen(this_ptr, val);
22611 // debug statements here
22613 // MUST_USE_RES struct LDKPong Pong_new(uint16_t byteslen_arg);
22615 export function Pong_new(byteslen_arg: number): bigint {
22616 if(!isWasmInitialized) {
22617 throw new Error("initializeWasm() must be awaited first!");
22619 const nativeResponseValue = wasm.TS_Pong_new(byteslen_arg);
22620 return nativeResponseValue;
22622 // uint64_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg);
22624 export function Pong_clone_ptr(arg: bigint): bigint {
22625 if(!isWasmInitialized) {
22626 throw new Error("initializeWasm() must be awaited first!");
22628 const nativeResponseValue = wasm.TS_Pong_clone_ptr(arg);
22629 return nativeResponseValue;
22631 // struct LDKPong Pong_clone(const struct LDKPong *NONNULL_PTR orig);
22633 export function Pong_clone(orig: bigint): bigint {
22634 if(!isWasmInitialized) {
22635 throw new Error("initializeWasm() must be awaited first!");
22637 const nativeResponseValue = wasm.TS_Pong_clone(orig);
22638 return nativeResponseValue;
22640 // bool Pong_eq(const struct LDKPong *NONNULL_PTR a, const struct LDKPong *NONNULL_PTR b);
22642 export function Pong_eq(a: bigint, b: bigint): boolean {
22643 if(!isWasmInitialized) {
22644 throw new Error("initializeWasm() must be awaited first!");
22646 const nativeResponseValue = wasm.TS_Pong_eq(a, b);
22647 return nativeResponseValue;
22649 // void OpenChannel_free(struct LDKOpenChannel this_obj);
22651 export function OpenChannel_free(this_obj: bigint): void {
22652 if(!isWasmInitialized) {
22653 throw new Error("initializeWasm() must be awaited first!");
22655 const nativeResponseValue = wasm.TS_OpenChannel_free(this_obj);
22656 // debug statements here
22658 // const uint8_t (*OpenChannel_get_chain_hash(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
22660 export function OpenChannel_get_chain_hash(this_ptr: bigint): number {
22661 if(!isWasmInitialized) {
22662 throw new Error("initializeWasm() must be awaited first!");
22664 const nativeResponseValue = wasm.TS_OpenChannel_get_chain_hash(this_ptr);
22665 return nativeResponseValue;
22667 // void OpenChannel_set_chain_hash(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22669 export function OpenChannel_set_chain_hash(this_ptr: bigint, val: number): void {
22670 if(!isWasmInitialized) {
22671 throw new Error("initializeWasm() must be awaited first!");
22673 const nativeResponseValue = wasm.TS_OpenChannel_set_chain_hash(this_ptr, val);
22674 // debug statements here
22676 // const uint8_t (*OpenChannel_get_temporary_channel_id(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
22678 export function OpenChannel_get_temporary_channel_id(this_ptr: bigint): number {
22679 if(!isWasmInitialized) {
22680 throw new Error("initializeWasm() must be awaited first!");
22682 const nativeResponseValue = wasm.TS_OpenChannel_get_temporary_channel_id(this_ptr);
22683 return nativeResponseValue;
22685 // void OpenChannel_set_temporary_channel_id(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22687 export function OpenChannel_set_temporary_channel_id(this_ptr: bigint, val: number): void {
22688 if(!isWasmInitialized) {
22689 throw new Error("initializeWasm() must be awaited first!");
22691 const nativeResponseValue = wasm.TS_OpenChannel_set_temporary_channel_id(this_ptr, val);
22692 // debug statements here
22694 // uint64_t OpenChannel_get_funding_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22696 export function OpenChannel_get_funding_satoshis(this_ptr: bigint): bigint {
22697 if(!isWasmInitialized) {
22698 throw new Error("initializeWasm() must be awaited first!");
22700 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_satoshis(this_ptr);
22701 return nativeResponseValue;
22703 // void OpenChannel_set_funding_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
22705 export function OpenChannel_set_funding_satoshis(this_ptr: bigint, val: bigint): void {
22706 if(!isWasmInitialized) {
22707 throw new Error("initializeWasm() must be awaited first!");
22709 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_satoshis(this_ptr, val);
22710 // debug statements here
22712 // uint64_t OpenChannel_get_push_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22714 export function OpenChannel_get_push_msat(this_ptr: bigint): bigint {
22715 if(!isWasmInitialized) {
22716 throw new Error("initializeWasm() must be awaited first!");
22718 const nativeResponseValue = wasm.TS_OpenChannel_get_push_msat(this_ptr);
22719 return nativeResponseValue;
22721 // void OpenChannel_set_push_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
22723 export function OpenChannel_set_push_msat(this_ptr: bigint, val: bigint): void {
22724 if(!isWasmInitialized) {
22725 throw new Error("initializeWasm() must be awaited first!");
22727 const nativeResponseValue = wasm.TS_OpenChannel_set_push_msat(this_ptr, val);
22728 // debug statements here
22730 // uint64_t OpenChannel_get_dust_limit_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22732 export function OpenChannel_get_dust_limit_satoshis(this_ptr: bigint): bigint {
22733 if(!isWasmInitialized) {
22734 throw new Error("initializeWasm() must be awaited first!");
22736 const nativeResponseValue = wasm.TS_OpenChannel_get_dust_limit_satoshis(this_ptr);
22737 return nativeResponseValue;
22739 // void OpenChannel_set_dust_limit_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
22741 export function OpenChannel_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
22742 if(!isWasmInitialized) {
22743 throw new Error("initializeWasm() must be awaited first!");
22745 const nativeResponseValue = wasm.TS_OpenChannel_set_dust_limit_satoshis(this_ptr, val);
22746 // debug statements here
22748 // uint64_t OpenChannel_get_max_htlc_value_in_flight_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22750 export function OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
22751 if(!isWasmInitialized) {
22752 throw new Error("initializeWasm() must be awaited first!");
22754 const nativeResponseValue = wasm.TS_OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr);
22755 return nativeResponseValue;
22757 // void OpenChannel_set_max_htlc_value_in_flight_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
22759 export function OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
22760 if(!isWasmInitialized) {
22761 throw new Error("initializeWasm() must be awaited first!");
22763 const nativeResponseValue = wasm.TS_OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
22764 // debug statements here
22766 // uint64_t OpenChannel_get_channel_reserve_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22768 export function OpenChannel_get_channel_reserve_satoshis(this_ptr: bigint): bigint {
22769 if(!isWasmInitialized) {
22770 throw new Error("initializeWasm() must be awaited first!");
22772 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_reserve_satoshis(this_ptr);
22773 return nativeResponseValue;
22775 // void OpenChannel_set_channel_reserve_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
22777 export function OpenChannel_set_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
22778 if(!isWasmInitialized) {
22779 throw new Error("initializeWasm() must be awaited first!");
22781 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_reserve_satoshis(this_ptr, val);
22782 // debug statements here
22784 // uint64_t OpenChannel_get_htlc_minimum_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22786 export function OpenChannel_get_htlc_minimum_msat(this_ptr: bigint): bigint {
22787 if(!isWasmInitialized) {
22788 throw new Error("initializeWasm() must be awaited first!");
22790 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_minimum_msat(this_ptr);
22791 return nativeResponseValue;
22793 // void OpenChannel_set_htlc_minimum_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
22795 export function OpenChannel_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
22796 if(!isWasmInitialized) {
22797 throw new Error("initializeWasm() must be awaited first!");
22799 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_minimum_msat(this_ptr, val);
22800 // debug statements here
22802 // uint32_t OpenChannel_get_feerate_per_kw(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22804 export function OpenChannel_get_feerate_per_kw(this_ptr: bigint): number {
22805 if(!isWasmInitialized) {
22806 throw new Error("initializeWasm() must be awaited first!");
22808 const nativeResponseValue = wasm.TS_OpenChannel_get_feerate_per_kw(this_ptr);
22809 return nativeResponseValue;
22811 // void OpenChannel_set_feerate_per_kw(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint32_t val);
22813 export function OpenChannel_set_feerate_per_kw(this_ptr: bigint, val: number): void {
22814 if(!isWasmInitialized) {
22815 throw new Error("initializeWasm() must be awaited first!");
22817 const nativeResponseValue = wasm.TS_OpenChannel_set_feerate_per_kw(this_ptr, val);
22818 // debug statements here
22820 // uint16_t OpenChannel_get_to_self_delay(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22822 export function OpenChannel_get_to_self_delay(this_ptr: bigint): number {
22823 if(!isWasmInitialized) {
22824 throw new Error("initializeWasm() must be awaited first!");
22826 const nativeResponseValue = wasm.TS_OpenChannel_get_to_self_delay(this_ptr);
22827 return nativeResponseValue;
22829 // void OpenChannel_set_to_self_delay(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
22831 export function OpenChannel_set_to_self_delay(this_ptr: bigint, val: number): void {
22832 if(!isWasmInitialized) {
22833 throw new Error("initializeWasm() must be awaited first!");
22835 const nativeResponseValue = wasm.TS_OpenChannel_set_to_self_delay(this_ptr, val);
22836 // debug statements here
22838 // uint16_t OpenChannel_get_max_accepted_htlcs(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22840 export function OpenChannel_get_max_accepted_htlcs(this_ptr: bigint): number {
22841 if(!isWasmInitialized) {
22842 throw new Error("initializeWasm() must be awaited first!");
22844 const nativeResponseValue = wasm.TS_OpenChannel_get_max_accepted_htlcs(this_ptr);
22845 return nativeResponseValue;
22847 // void OpenChannel_set_max_accepted_htlcs(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
22849 export function OpenChannel_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
22850 if(!isWasmInitialized) {
22851 throw new Error("initializeWasm() must be awaited first!");
22853 const nativeResponseValue = wasm.TS_OpenChannel_set_max_accepted_htlcs(this_ptr, val);
22854 // debug statements here
22856 // struct LDKPublicKey OpenChannel_get_funding_pubkey(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22858 export function OpenChannel_get_funding_pubkey(this_ptr: bigint): number {
22859 if(!isWasmInitialized) {
22860 throw new Error("initializeWasm() must be awaited first!");
22862 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_pubkey(this_ptr);
22863 return nativeResponseValue;
22865 // void OpenChannel_set_funding_pubkey(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22867 export function OpenChannel_set_funding_pubkey(this_ptr: bigint, val: number): void {
22868 if(!isWasmInitialized) {
22869 throw new Error("initializeWasm() must be awaited first!");
22871 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_pubkey(this_ptr, val);
22872 // debug statements here
22874 // struct LDKPublicKey OpenChannel_get_revocation_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22876 export function OpenChannel_get_revocation_basepoint(this_ptr: bigint): number {
22877 if(!isWasmInitialized) {
22878 throw new Error("initializeWasm() must be awaited first!");
22880 const nativeResponseValue = wasm.TS_OpenChannel_get_revocation_basepoint(this_ptr);
22881 return nativeResponseValue;
22883 // void OpenChannel_set_revocation_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22885 export function OpenChannel_set_revocation_basepoint(this_ptr: bigint, val: number): void {
22886 if(!isWasmInitialized) {
22887 throw new Error("initializeWasm() must be awaited first!");
22889 const nativeResponseValue = wasm.TS_OpenChannel_set_revocation_basepoint(this_ptr, val);
22890 // debug statements here
22892 // struct LDKPublicKey OpenChannel_get_payment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22894 export function OpenChannel_get_payment_point(this_ptr: bigint): number {
22895 if(!isWasmInitialized) {
22896 throw new Error("initializeWasm() must be awaited first!");
22898 const nativeResponseValue = wasm.TS_OpenChannel_get_payment_point(this_ptr);
22899 return nativeResponseValue;
22901 // void OpenChannel_set_payment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22903 export function OpenChannel_set_payment_point(this_ptr: bigint, val: number): void {
22904 if(!isWasmInitialized) {
22905 throw new Error("initializeWasm() must be awaited first!");
22907 const nativeResponseValue = wasm.TS_OpenChannel_set_payment_point(this_ptr, val);
22908 // debug statements here
22910 // struct LDKPublicKey OpenChannel_get_delayed_payment_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22912 export function OpenChannel_get_delayed_payment_basepoint(this_ptr: bigint): number {
22913 if(!isWasmInitialized) {
22914 throw new Error("initializeWasm() must be awaited first!");
22916 const nativeResponseValue = wasm.TS_OpenChannel_get_delayed_payment_basepoint(this_ptr);
22917 return nativeResponseValue;
22919 // void OpenChannel_set_delayed_payment_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22921 export function OpenChannel_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
22922 if(!isWasmInitialized) {
22923 throw new Error("initializeWasm() must be awaited first!");
22925 const nativeResponseValue = wasm.TS_OpenChannel_set_delayed_payment_basepoint(this_ptr, val);
22926 // debug statements here
22928 // struct LDKPublicKey OpenChannel_get_htlc_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22930 export function OpenChannel_get_htlc_basepoint(this_ptr: bigint): number {
22931 if(!isWasmInitialized) {
22932 throw new Error("initializeWasm() must be awaited first!");
22934 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_basepoint(this_ptr);
22935 return nativeResponseValue;
22937 // void OpenChannel_set_htlc_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22939 export function OpenChannel_set_htlc_basepoint(this_ptr: bigint, val: number): void {
22940 if(!isWasmInitialized) {
22941 throw new Error("initializeWasm() must be awaited first!");
22943 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_basepoint(this_ptr, val);
22944 // debug statements here
22946 // struct LDKPublicKey OpenChannel_get_first_per_commitment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22948 export function OpenChannel_get_first_per_commitment_point(this_ptr: bigint): number {
22949 if(!isWasmInitialized) {
22950 throw new Error("initializeWasm() must be awaited first!");
22952 const nativeResponseValue = wasm.TS_OpenChannel_get_first_per_commitment_point(this_ptr);
22953 return nativeResponseValue;
22955 // void OpenChannel_set_first_per_commitment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22957 export function OpenChannel_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
22958 if(!isWasmInitialized) {
22959 throw new Error("initializeWasm() must be awaited first!");
22961 const nativeResponseValue = wasm.TS_OpenChannel_set_first_per_commitment_point(this_ptr, val);
22962 // debug statements here
22964 // uint8_t OpenChannel_get_channel_flags(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22966 export function OpenChannel_get_channel_flags(this_ptr: bigint): number {
22967 if(!isWasmInitialized) {
22968 throw new Error("initializeWasm() must be awaited first!");
22970 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_flags(this_ptr);
22971 return nativeResponseValue;
22973 // void OpenChannel_set_channel_flags(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint8_t val);
22975 export function OpenChannel_set_channel_flags(this_ptr: bigint, val: number): void {
22976 if(!isWasmInitialized) {
22977 throw new Error("initializeWasm() must be awaited first!");
22979 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_flags(this_ptr, val);
22980 // debug statements here
22982 // struct LDKChannelTypeFeatures OpenChannel_get_channel_type(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
22984 export function OpenChannel_get_channel_type(this_ptr: bigint): bigint {
22985 if(!isWasmInitialized) {
22986 throw new Error("initializeWasm() must be awaited first!");
22988 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_type(this_ptr);
22989 return nativeResponseValue;
22991 // void OpenChannel_set_channel_type(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
22993 export function OpenChannel_set_channel_type(this_ptr: bigint, val: bigint): void {
22994 if(!isWasmInitialized) {
22995 throw new Error("initializeWasm() must be awaited first!");
22997 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_type(this_ptr, val);
22998 // debug statements here
23000 // uint64_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg);
23002 export function OpenChannel_clone_ptr(arg: bigint): bigint {
23003 if(!isWasmInitialized) {
23004 throw new Error("initializeWasm() must be awaited first!");
23006 const nativeResponseValue = wasm.TS_OpenChannel_clone_ptr(arg);
23007 return nativeResponseValue;
23009 // struct LDKOpenChannel OpenChannel_clone(const struct LDKOpenChannel *NONNULL_PTR orig);
23011 export function OpenChannel_clone(orig: bigint): bigint {
23012 if(!isWasmInitialized) {
23013 throw new Error("initializeWasm() must be awaited first!");
23015 const nativeResponseValue = wasm.TS_OpenChannel_clone(orig);
23016 return nativeResponseValue;
23018 // bool OpenChannel_eq(const struct LDKOpenChannel *NONNULL_PTR a, const struct LDKOpenChannel *NONNULL_PTR b);
23020 export function OpenChannel_eq(a: bigint, b: bigint): boolean {
23021 if(!isWasmInitialized) {
23022 throw new Error("initializeWasm() must be awaited first!");
23024 const nativeResponseValue = wasm.TS_OpenChannel_eq(a, b);
23025 return nativeResponseValue;
23027 // void AcceptChannel_free(struct LDKAcceptChannel this_obj);
23029 export function AcceptChannel_free(this_obj: bigint): void {
23030 if(!isWasmInitialized) {
23031 throw new Error("initializeWasm() must be awaited first!");
23033 const nativeResponseValue = wasm.TS_AcceptChannel_free(this_obj);
23034 // debug statements here
23036 // const uint8_t (*AcceptChannel_get_temporary_channel_id(const struct LDKAcceptChannel *NONNULL_PTR this_ptr))[32];
23038 export function AcceptChannel_get_temporary_channel_id(this_ptr: bigint): number {
23039 if(!isWasmInitialized) {
23040 throw new Error("initializeWasm() must be awaited first!");
23042 const nativeResponseValue = wasm.TS_AcceptChannel_get_temporary_channel_id(this_ptr);
23043 return nativeResponseValue;
23045 // void AcceptChannel_set_temporary_channel_id(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23047 export function AcceptChannel_set_temporary_channel_id(this_ptr: bigint, val: number): void {
23048 if(!isWasmInitialized) {
23049 throw new Error("initializeWasm() must be awaited first!");
23051 const nativeResponseValue = wasm.TS_AcceptChannel_set_temporary_channel_id(this_ptr, val);
23052 // debug statements here
23054 // uint64_t AcceptChannel_get_dust_limit_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
23056 export function AcceptChannel_get_dust_limit_satoshis(this_ptr: bigint): bigint {
23057 if(!isWasmInitialized) {
23058 throw new Error("initializeWasm() must be awaited first!");
23060 const nativeResponseValue = wasm.TS_AcceptChannel_get_dust_limit_satoshis(this_ptr);
23061 return nativeResponseValue;
23063 // void AcceptChannel_set_dust_limit_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
23065 export function AcceptChannel_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
23066 if(!isWasmInitialized) {
23067 throw new Error("initializeWasm() must be awaited first!");
23069 const nativeResponseValue = wasm.TS_AcceptChannel_set_dust_limit_satoshis(this_ptr, val);
23070 // debug statements here
23072 // uint64_t AcceptChannel_get_max_htlc_value_in_flight_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
23074 export function AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
23075 if(!isWasmInitialized) {
23076 throw new Error("initializeWasm() must be awaited first!");
23078 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr);
23079 return nativeResponseValue;
23081 // void AcceptChannel_set_max_htlc_value_in_flight_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
23083 export function AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
23084 if(!isWasmInitialized) {
23085 throw new Error("initializeWasm() must be awaited first!");
23087 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
23088 // debug statements here
23090 // uint64_t AcceptChannel_get_channel_reserve_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
23092 export function AcceptChannel_get_channel_reserve_satoshis(this_ptr: bigint): bigint {
23093 if(!isWasmInitialized) {
23094 throw new Error("initializeWasm() must be awaited first!");
23096 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_reserve_satoshis(this_ptr);
23097 return nativeResponseValue;
23099 // void AcceptChannel_set_channel_reserve_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
23101 export function AcceptChannel_set_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
23102 if(!isWasmInitialized) {
23103 throw new Error("initializeWasm() must be awaited first!");
23105 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_reserve_satoshis(this_ptr, val);
23106 // debug statements here
23108 // uint64_t AcceptChannel_get_htlc_minimum_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
23110 export function AcceptChannel_get_htlc_minimum_msat(this_ptr: bigint): bigint {
23111 if(!isWasmInitialized) {
23112 throw new Error("initializeWasm() must be awaited first!");
23114 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_minimum_msat(this_ptr);
23115 return nativeResponseValue;
23117 // void AcceptChannel_set_htlc_minimum_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
23119 export function AcceptChannel_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
23120 if(!isWasmInitialized) {
23121 throw new Error("initializeWasm() must be awaited first!");
23123 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_minimum_msat(this_ptr, val);
23124 // debug statements here
23126 // uint32_t AcceptChannel_get_minimum_depth(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
23128 export function AcceptChannel_get_minimum_depth(this_ptr: bigint): number {
23129 if(!isWasmInitialized) {
23130 throw new Error("initializeWasm() must be awaited first!");
23132 const nativeResponseValue = wasm.TS_AcceptChannel_get_minimum_depth(this_ptr);
23133 return nativeResponseValue;
23135 // void AcceptChannel_set_minimum_depth(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint32_t val);
23137 export function AcceptChannel_set_minimum_depth(this_ptr: bigint, val: number): void {
23138 if(!isWasmInitialized) {
23139 throw new Error("initializeWasm() must be awaited first!");
23141 const nativeResponseValue = wasm.TS_AcceptChannel_set_minimum_depth(this_ptr, val);
23142 // debug statements here
23144 // uint16_t AcceptChannel_get_to_self_delay(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
23146 export function AcceptChannel_get_to_self_delay(this_ptr: bigint): number {
23147 if(!isWasmInitialized) {
23148 throw new Error("initializeWasm() must be awaited first!");
23150 const nativeResponseValue = wasm.TS_AcceptChannel_get_to_self_delay(this_ptr);
23151 return nativeResponseValue;
23153 // void AcceptChannel_set_to_self_delay(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
23155 export function AcceptChannel_set_to_self_delay(this_ptr: bigint, val: number): void {
23156 if(!isWasmInitialized) {
23157 throw new Error("initializeWasm() must be awaited first!");
23159 const nativeResponseValue = wasm.TS_AcceptChannel_set_to_self_delay(this_ptr, val);
23160 // debug statements here
23162 // uint16_t AcceptChannel_get_max_accepted_htlcs(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
23164 export function AcceptChannel_get_max_accepted_htlcs(this_ptr: bigint): number {
23165 if(!isWasmInitialized) {
23166 throw new Error("initializeWasm() must be awaited first!");
23168 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_accepted_htlcs(this_ptr);
23169 return nativeResponseValue;
23171 // void AcceptChannel_set_max_accepted_htlcs(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
23173 export function AcceptChannel_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
23174 if(!isWasmInitialized) {
23175 throw new Error("initializeWasm() must be awaited first!");
23177 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_accepted_htlcs(this_ptr, val);
23178 // debug statements here
23180 // struct LDKPublicKey AcceptChannel_get_funding_pubkey(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
23182 export function AcceptChannel_get_funding_pubkey(this_ptr: bigint): number {
23183 if(!isWasmInitialized) {
23184 throw new Error("initializeWasm() must be awaited first!");
23186 const nativeResponseValue = wasm.TS_AcceptChannel_get_funding_pubkey(this_ptr);
23187 return nativeResponseValue;
23189 // void AcceptChannel_set_funding_pubkey(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23191 export function AcceptChannel_set_funding_pubkey(this_ptr: bigint, val: number): void {
23192 if(!isWasmInitialized) {
23193 throw new Error("initializeWasm() must be awaited first!");
23195 const nativeResponseValue = wasm.TS_AcceptChannel_set_funding_pubkey(this_ptr, val);
23196 // debug statements here
23198 // struct LDKPublicKey AcceptChannel_get_revocation_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
23200 export function AcceptChannel_get_revocation_basepoint(this_ptr: bigint): number {
23201 if(!isWasmInitialized) {
23202 throw new Error("initializeWasm() must be awaited first!");
23204 const nativeResponseValue = wasm.TS_AcceptChannel_get_revocation_basepoint(this_ptr);
23205 return nativeResponseValue;
23207 // void AcceptChannel_set_revocation_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23209 export function AcceptChannel_set_revocation_basepoint(this_ptr: bigint, val: number): void {
23210 if(!isWasmInitialized) {
23211 throw new Error("initializeWasm() must be awaited first!");
23213 const nativeResponseValue = wasm.TS_AcceptChannel_set_revocation_basepoint(this_ptr, val);
23214 // debug statements here
23216 // struct LDKPublicKey AcceptChannel_get_payment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
23218 export function AcceptChannel_get_payment_point(this_ptr: bigint): number {
23219 if(!isWasmInitialized) {
23220 throw new Error("initializeWasm() must be awaited first!");
23222 const nativeResponseValue = wasm.TS_AcceptChannel_get_payment_point(this_ptr);
23223 return nativeResponseValue;
23225 // void AcceptChannel_set_payment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23227 export function AcceptChannel_set_payment_point(this_ptr: bigint, val: number): void {
23228 if(!isWasmInitialized) {
23229 throw new Error("initializeWasm() must be awaited first!");
23231 const nativeResponseValue = wasm.TS_AcceptChannel_set_payment_point(this_ptr, val);
23232 // debug statements here
23234 // struct LDKPublicKey AcceptChannel_get_delayed_payment_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
23236 export function AcceptChannel_get_delayed_payment_basepoint(this_ptr: bigint): number {
23237 if(!isWasmInitialized) {
23238 throw new Error("initializeWasm() must be awaited first!");
23240 const nativeResponseValue = wasm.TS_AcceptChannel_get_delayed_payment_basepoint(this_ptr);
23241 return nativeResponseValue;
23243 // void AcceptChannel_set_delayed_payment_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23245 export function AcceptChannel_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
23246 if(!isWasmInitialized) {
23247 throw new Error("initializeWasm() must be awaited first!");
23249 const nativeResponseValue = wasm.TS_AcceptChannel_set_delayed_payment_basepoint(this_ptr, val);
23250 // debug statements here
23252 // struct LDKPublicKey AcceptChannel_get_htlc_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
23254 export function AcceptChannel_get_htlc_basepoint(this_ptr: bigint): number {
23255 if(!isWasmInitialized) {
23256 throw new Error("initializeWasm() must be awaited first!");
23258 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_basepoint(this_ptr);
23259 return nativeResponseValue;
23261 // void AcceptChannel_set_htlc_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23263 export function AcceptChannel_set_htlc_basepoint(this_ptr: bigint, val: number): void {
23264 if(!isWasmInitialized) {
23265 throw new Error("initializeWasm() must be awaited first!");
23267 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_basepoint(this_ptr, val);
23268 // debug statements here
23270 // struct LDKPublicKey AcceptChannel_get_first_per_commitment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
23272 export function AcceptChannel_get_first_per_commitment_point(this_ptr: bigint): number {
23273 if(!isWasmInitialized) {
23274 throw new Error("initializeWasm() must be awaited first!");
23276 const nativeResponseValue = wasm.TS_AcceptChannel_get_first_per_commitment_point(this_ptr);
23277 return nativeResponseValue;
23279 // void AcceptChannel_set_first_per_commitment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23281 export function AcceptChannel_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
23282 if(!isWasmInitialized) {
23283 throw new Error("initializeWasm() must be awaited first!");
23285 const nativeResponseValue = wasm.TS_AcceptChannel_set_first_per_commitment_point(this_ptr, val);
23286 // debug statements here
23288 // struct LDKChannelTypeFeatures AcceptChannel_get_channel_type(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
23290 export function AcceptChannel_get_channel_type(this_ptr: bigint): bigint {
23291 if(!isWasmInitialized) {
23292 throw new Error("initializeWasm() must be awaited first!");
23294 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_type(this_ptr);
23295 return nativeResponseValue;
23297 // void AcceptChannel_set_channel_type(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
23299 export function AcceptChannel_set_channel_type(this_ptr: bigint, val: bigint): void {
23300 if(!isWasmInitialized) {
23301 throw new Error("initializeWasm() must be awaited first!");
23303 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_type(this_ptr, val);
23304 // debug statements here
23306 // uint64_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg);
23308 export function AcceptChannel_clone_ptr(arg: bigint): bigint {
23309 if(!isWasmInitialized) {
23310 throw new Error("initializeWasm() must be awaited first!");
23312 const nativeResponseValue = wasm.TS_AcceptChannel_clone_ptr(arg);
23313 return nativeResponseValue;
23315 // struct LDKAcceptChannel AcceptChannel_clone(const struct LDKAcceptChannel *NONNULL_PTR orig);
23317 export function AcceptChannel_clone(orig: bigint): bigint {
23318 if(!isWasmInitialized) {
23319 throw new Error("initializeWasm() must be awaited first!");
23321 const nativeResponseValue = wasm.TS_AcceptChannel_clone(orig);
23322 return nativeResponseValue;
23324 // bool AcceptChannel_eq(const struct LDKAcceptChannel *NONNULL_PTR a, const struct LDKAcceptChannel *NONNULL_PTR b);
23326 export function AcceptChannel_eq(a: bigint, b: bigint): boolean {
23327 if(!isWasmInitialized) {
23328 throw new Error("initializeWasm() must be awaited first!");
23330 const nativeResponseValue = wasm.TS_AcceptChannel_eq(a, b);
23331 return nativeResponseValue;
23333 // void FundingCreated_free(struct LDKFundingCreated this_obj);
23335 export function FundingCreated_free(this_obj: bigint): void {
23336 if(!isWasmInitialized) {
23337 throw new Error("initializeWasm() must be awaited first!");
23339 const nativeResponseValue = wasm.TS_FundingCreated_free(this_obj);
23340 // debug statements here
23342 // const uint8_t (*FundingCreated_get_temporary_channel_id(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
23344 export function FundingCreated_get_temporary_channel_id(this_ptr: bigint): number {
23345 if(!isWasmInitialized) {
23346 throw new Error("initializeWasm() must be awaited first!");
23348 const nativeResponseValue = wasm.TS_FundingCreated_get_temporary_channel_id(this_ptr);
23349 return nativeResponseValue;
23351 // void FundingCreated_set_temporary_channel_id(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23353 export function FundingCreated_set_temporary_channel_id(this_ptr: bigint, val: number): void {
23354 if(!isWasmInitialized) {
23355 throw new Error("initializeWasm() must be awaited first!");
23357 const nativeResponseValue = wasm.TS_FundingCreated_set_temporary_channel_id(this_ptr, val);
23358 // debug statements here
23360 // const uint8_t (*FundingCreated_get_funding_txid(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
23362 export function FundingCreated_get_funding_txid(this_ptr: bigint): number {
23363 if(!isWasmInitialized) {
23364 throw new Error("initializeWasm() must be awaited first!");
23366 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_txid(this_ptr);
23367 return nativeResponseValue;
23369 // void FundingCreated_set_funding_txid(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23371 export function FundingCreated_set_funding_txid(this_ptr: bigint, val: number): void {
23372 if(!isWasmInitialized) {
23373 throw new Error("initializeWasm() must be awaited first!");
23375 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_txid(this_ptr, val);
23376 // debug statements here
23378 // uint16_t FundingCreated_get_funding_output_index(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
23380 export function FundingCreated_get_funding_output_index(this_ptr: bigint): number {
23381 if(!isWasmInitialized) {
23382 throw new Error("initializeWasm() must be awaited first!");
23384 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_output_index(this_ptr);
23385 return nativeResponseValue;
23387 // void FundingCreated_set_funding_output_index(struct LDKFundingCreated *NONNULL_PTR this_ptr, uint16_t val);
23389 export function FundingCreated_set_funding_output_index(this_ptr: bigint, val: number): void {
23390 if(!isWasmInitialized) {
23391 throw new Error("initializeWasm() must be awaited first!");
23393 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_output_index(this_ptr, val);
23394 // debug statements here
23396 // struct LDKSignature FundingCreated_get_signature(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
23398 export function FundingCreated_get_signature(this_ptr: bigint): number {
23399 if(!isWasmInitialized) {
23400 throw new Error("initializeWasm() must be awaited first!");
23402 const nativeResponseValue = wasm.TS_FundingCreated_get_signature(this_ptr);
23403 return nativeResponseValue;
23405 // void FundingCreated_set_signature(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKSignature val);
23407 export function FundingCreated_set_signature(this_ptr: bigint, val: number): void {
23408 if(!isWasmInitialized) {
23409 throw new Error("initializeWasm() must be awaited first!");
23411 const nativeResponseValue = wasm.TS_FundingCreated_set_signature(this_ptr, val);
23412 // debug statements here
23414 // 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);
23416 export function FundingCreated_new(temporary_channel_id_arg: number, funding_txid_arg: number, funding_output_index_arg: number, signature_arg: number): bigint {
23417 if(!isWasmInitialized) {
23418 throw new Error("initializeWasm() must be awaited first!");
23420 const nativeResponseValue = wasm.TS_FundingCreated_new(temporary_channel_id_arg, funding_txid_arg, funding_output_index_arg, signature_arg);
23421 return nativeResponseValue;
23423 // uint64_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg);
23425 export function FundingCreated_clone_ptr(arg: bigint): bigint {
23426 if(!isWasmInitialized) {
23427 throw new Error("initializeWasm() must be awaited first!");
23429 const nativeResponseValue = wasm.TS_FundingCreated_clone_ptr(arg);
23430 return nativeResponseValue;
23432 // struct LDKFundingCreated FundingCreated_clone(const struct LDKFundingCreated *NONNULL_PTR orig);
23434 export function FundingCreated_clone(orig: bigint): bigint {
23435 if(!isWasmInitialized) {
23436 throw new Error("initializeWasm() must be awaited first!");
23438 const nativeResponseValue = wasm.TS_FundingCreated_clone(orig);
23439 return nativeResponseValue;
23441 // bool FundingCreated_eq(const struct LDKFundingCreated *NONNULL_PTR a, const struct LDKFundingCreated *NONNULL_PTR b);
23443 export function FundingCreated_eq(a: bigint, b: bigint): boolean {
23444 if(!isWasmInitialized) {
23445 throw new Error("initializeWasm() must be awaited first!");
23447 const nativeResponseValue = wasm.TS_FundingCreated_eq(a, b);
23448 return nativeResponseValue;
23450 // void FundingSigned_free(struct LDKFundingSigned this_obj);
23452 export function FundingSigned_free(this_obj: bigint): void {
23453 if(!isWasmInitialized) {
23454 throw new Error("initializeWasm() must be awaited first!");
23456 const nativeResponseValue = wasm.TS_FundingSigned_free(this_obj);
23457 // debug statements here
23459 // const uint8_t (*FundingSigned_get_channel_id(const struct LDKFundingSigned *NONNULL_PTR this_ptr))[32];
23461 export function FundingSigned_get_channel_id(this_ptr: bigint): number {
23462 if(!isWasmInitialized) {
23463 throw new Error("initializeWasm() must be awaited first!");
23465 const nativeResponseValue = wasm.TS_FundingSigned_get_channel_id(this_ptr);
23466 return nativeResponseValue;
23468 // void FundingSigned_set_channel_id(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23470 export function FundingSigned_set_channel_id(this_ptr: bigint, val: number): void {
23471 if(!isWasmInitialized) {
23472 throw new Error("initializeWasm() must be awaited first!");
23474 const nativeResponseValue = wasm.TS_FundingSigned_set_channel_id(this_ptr, val);
23475 // debug statements here
23477 // struct LDKSignature FundingSigned_get_signature(const struct LDKFundingSigned *NONNULL_PTR this_ptr);
23479 export function FundingSigned_get_signature(this_ptr: bigint): number {
23480 if(!isWasmInitialized) {
23481 throw new Error("initializeWasm() must be awaited first!");
23483 const nativeResponseValue = wasm.TS_FundingSigned_get_signature(this_ptr);
23484 return nativeResponseValue;
23486 // void FundingSigned_set_signature(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
23488 export function FundingSigned_set_signature(this_ptr: bigint, val: number): void {
23489 if(!isWasmInitialized) {
23490 throw new Error("initializeWasm() must be awaited first!");
23492 const nativeResponseValue = wasm.TS_FundingSigned_set_signature(this_ptr, val);
23493 // debug statements here
23495 // MUST_USE_RES struct LDKFundingSigned FundingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg);
23497 export function FundingSigned_new(channel_id_arg: number, signature_arg: number): bigint {
23498 if(!isWasmInitialized) {
23499 throw new Error("initializeWasm() must be awaited first!");
23501 const nativeResponseValue = wasm.TS_FundingSigned_new(channel_id_arg, signature_arg);
23502 return nativeResponseValue;
23504 // uint64_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg);
23506 export function FundingSigned_clone_ptr(arg: bigint): bigint {
23507 if(!isWasmInitialized) {
23508 throw new Error("initializeWasm() must be awaited first!");
23510 const nativeResponseValue = wasm.TS_FundingSigned_clone_ptr(arg);
23511 return nativeResponseValue;
23513 // struct LDKFundingSigned FundingSigned_clone(const struct LDKFundingSigned *NONNULL_PTR orig);
23515 export function FundingSigned_clone(orig: bigint): bigint {
23516 if(!isWasmInitialized) {
23517 throw new Error("initializeWasm() must be awaited first!");
23519 const nativeResponseValue = wasm.TS_FundingSigned_clone(orig);
23520 return nativeResponseValue;
23522 // bool FundingSigned_eq(const struct LDKFundingSigned *NONNULL_PTR a, const struct LDKFundingSigned *NONNULL_PTR b);
23524 export function FundingSigned_eq(a: bigint, b: bigint): boolean {
23525 if(!isWasmInitialized) {
23526 throw new Error("initializeWasm() must be awaited first!");
23528 const nativeResponseValue = wasm.TS_FundingSigned_eq(a, b);
23529 return nativeResponseValue;
23531 // void ChannelReady_free(struct LDKChannelReady this_obj);
23533 export function ChannelReady_free(this_obj: bigint): void {
23534 if(!isWasmInitialized) {
23535 throw new Error("initializeWasm() must be awaited first!");
23537 const nativeResponseValue = wasm.TS_ChannelReady_free(this_obj);
23538 // debug statements here
23540 // const uint8_t (*ChannelReady_get_channel_id(const struct LDKChannelReady *NONNULL_PTR this_ptr))[32];
23542 export function ChannelReady_get_channel_id(this_ptr: bigint): number {
23543 if(!isWasmInitialized) {
23544 throw new Error("initializeWasm() must be awaited first!");
23546 const nativeResponseValue = wasm.TS_ChannelReady_get_channel_id(this_ptr);
23547 return nativeResponseValue;
23549 // void ChannelReady_set_channel_id(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23551 export function ChannelReady_set_channel_id(this_ptr: bigint, val: number): void {
23552 if(!isWasmInitialized) {
23553 throw new Error("initializeWasm() must be awaited first!");
23555 const nativeResponseValue = wasm.TS_ChannelReady_set_channel_id(this_ptr, val);
23556 // debug statements here
23558 // struct LDKPublicKey ChannelReady_get_next_per_commitment_point(const struct LDKChannelReady *NONNULL_PTR this_ptr);
23560 export function ChannelReady_get_next_per_commitment_point(this_ptr: bigint): number {
23561 if(!isWasmInitialized) {
23562 throw new Error("initializeWasm() must be awaited first!");
23564 const nativeResponseValue = wasm.TS_ChannelReady_get_next_per_commitment_point(this_ptr);
23565 return nativeResponseValue;
23567 // void ChannelReady_set_next_per_commitment_point(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23569 export function ChannelReady_set_next_per_commitment_point(this_ptr: bigint, val: number): void {
23570 if(!isWasmInitialized) {
23571 throw new Error("initializeWasm() must be awaited first!");
23573 const nativeResponseValue = wasm.TS_ChannelReady_set_next_per_commitment_point(this_ptr, val);
23574 // debug statements here
23576 // struct LDKCOption_u64Z ChannelReady_get_short_channel_id_alias(const struct LDKChannelReady *NONNULL_PTR this_ptr);
23578 export function ChannelReady_get_short_channel_id_alias(this_ptr: bigint): bigint {
23579 if(!isWasmInitialized) {
23580 throw new Error("initializeWasm() must be awaited first!");
23582 const nativeResponseValue = wasm.TS_ChannelReady_get_short_channel_id_alias(this_ptr);
23583 return nativeResponseValue;
23585 // void ChannelReady_set_short_channel_id_alias(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
23587 export function ChannelReady_set_short_channel_id_alias(this_ptr: bigint, val: bigint): void {
23588 if(!isWasmInitialized) {
23589 throw new Error("initializeWasm() must be awaited first!");
23591 const nativeResponseValue = wasm.TS_ChannelReady_set_short_channel_id_alias(this_ptr, val);
23592 // debug statements here
23594 // 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);
23596 export function ChannelReady_new(channel_id_arg: number, next_per_commitment_point_arg: number, short_channel_id_alias_arg: bigint): bigint {
23597 if(!isWasmInitialized) {
23598 throw new Error("initializeWasm() must be awaited first!");
23600 const nativeResponseValue = wasm.TS_ChannelReady_new(channel_id_arg, next_per_commitment_point_arg, short_channel_id_alias_arg);
23601 return nativeResponseValue;
23603 // uint64_t ChannelReady_clone_ptr(LDKChannelReady *NONNULL_PTR arg);
23605 export function ChannelReady_clone_ptr(arg: bigint): bigint {
23606 if(!isWasmInitialized) {
23607 throw new Error("initializeWasm() must be awaited first!");
23609 const nativeResponseValue = wasm.TS_ChannelReady_clone_ptr(arg);
23610 return nativeResponseValue;
23612 // struct LDKChannelReady ChannelReady_clone(const struct LDKChannelReady *NONNULL_PTR orig);
23614 export function ChannelReady_clone(orig: bigint): bigint {
23615 if(!isWasmInitialized) {
23616 throw new Error("initializeWasm() must be awaited first!");
23618 const nativeResponseValue = wasm.TS_ChannelReady_clone(orig);
23619 return nativeResponseValue;
23621 // bool ChannelReady_eq(const struct LDKChannelReady *NONNULL_PTR a, const struct LDKChannelReady *NONNULL_PTR b);
23623 export function ChannelReady_eq(a: bigint, b: bigint): boolean {
23624 if(!isWasmInitialized) {
23625 throw new Error("initializeWasm() must be awaited first!");
23627 const nativeResponseValue = wasm.TS_ChannelReady_eq(a, b);
23628 return nativeResponseValue;
23630 // void Shutdown_free(struct LDKShutdown this_obj);
23632 export function Shutdown_free(this_obj: bigint): void {
23633 if(!isWasmInitialized) {
23634 throw new Error("initializeWasm() must be awaited first!");
23636 const nativeResponseValue = wasm.TS_Shutdown_free(this_obj);
23637 // debug statements here
23639 // const uint8_t (*Shutdown_get_channel_id(const struct LDKShutdown *NONNULL_PTR this_ptr))[32];
23641 export function Shutdown_get_channel_id(this_ptr: bigint): number {
23642 if(!isWasmInitialized) {
23643 throw new Error("initializeWasm() must be awaited first!");
23645 const nativeResponseValue = wasm.TS_Shutdown_get_channel_id(this_ptr);
23646 return nativeResponseValue;
23648 // void Shutdown_set_channel_id(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23650 export function Shutdown_set_channel_id(this_ptr: bigint, val: number): void {
23651 if(!isWasmInitialized) {
23652 throw new Error("initializeWasm() must be awaited first!");
23654 const nativeResponseValue = wasm.TS_Shutdown_set_channel_id(this_ptr, val);
23655 // debug statements here
23657 // struct LDKu8slice Shutdown_get_scriptpubkey(const struct LDKShutdown *NONNULL_PTR this_ptr);
23659 export function Shutdown_get_scriptpubkey(this_ptr: bigint): number {
23660 if(!isWasmInitialized) {
23661 throw new Error("initializeWasm() must be awaited first!");
23663 const nativeResponseValue = wasm.TS_Shutdown_get_scriptpubkey(this_ptr);
23664 return nativeResponseValue;
23666 // void Shutdown_set_scriptpubkey(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
23668 export function Shutdown_set_scriptpubkey(this_ptr: bigint, val: number): void {
23669 if(!isWasmInitialized) {
23670 throw new Error("initializeWasm() must be awaited first!");
23672 const nativeResponseValue = wasm.TS_Shutdown_set_scriptpubkey(this_ptr, val);
23673 // debug statements here
23675 // MUST_USE_RES struct LDKShutdown Shutdown_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z scriptpubkey_arg);
23677 export function Shutdown_new(channel_id_arg: number, scriptpubkey_arg: number): bigint {
23678 if(!isWasmInitialized) {
23679 throw new Error("initializeWasm() must be awaited first!");
23681 const nativeResponseValue = wasm.TS_Shutdown_new(channel_id_arg, scriptpubkey_arg);
23682 return nativeResponseValue;
23684 // uint64_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg);
23686 export function Shutdown_clone_ptr(arg: bigint): bigint {
23687 if(!isWasmInitialized) {
23688 throw new Error("initializeWasm() must be awaited first!");
23690 const nativeResponseValue = wasm.TS_Shutdown_clone_ptr(arg);
23691 return nativeResponseValue;
23693 // struct LDKShutdown Shutdown_clone(const struct LDKShutdown *NONNULL_PTR orig);
23695 export function Shutdown_clone(orig: bigint): bigint {
23696 if(!isWasmInitialized) {
23697 throw new Error("initializeWasm() must be awaited first!");
23699 const nativeResponseValue = wasm.TS_Shutdown_clone(orig);
23700 return nativeResponseValue;
23702 // bool Shutdown_eq(const struct LDKShutdown *NONNULL_PTR a, const struct LDKShutdown *NONNULL_PTR b);
23704 export function Shutdown_eq(a: bigint, b: bigint): boolean {
23705 if(!isWasmInitialized) {
23706 throw new Error("initializeWasm() must be awaited first!");
23708 const nativeResponseValue = wasm.TS_Shutdown_eq(a, b);
23709 return nativeResponseValue;
23711 // void ClosingSignedFeeRange_free(struct LDKClosingSignedFeeRange this_obj);
23713 export function ClosingSignedFeeRange_free(this_obj: bigint): void {
23714 if(!isWasmInitialized) {
23715 throw new Error("initializeWasm() must be awaited first!");
23717 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_free(this_obj);
23718 // debug statements here
23720 // uint64_t ClosingSignedFeeRange_get_min_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
23722 export function ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr: bigint): bigint {
23723 if(!isWasmInitialized) {
23724 throw new Error("initializeWasm() must be awaited first!");
23726 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr);
23727 return nativeResponseValue;
23729 // void ClosingSignedFeeRange_set_min_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
23731 export function ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr: bigint, val: bigint): void {
23732 if(!isWasmInitialized) {
23733 throw new Error("initializeWasm() must be awaited first!");
23735 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr, val);
23736 // debug statements here
23738 // uint64_t ClosingSignedFeeRange_get_max_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
23740 export function ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr: bigint): bigint {
23741 if(!isWasmInitialized) {
23742 throw new Error("initializeWasm() must be awaited first!");
23744 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr);
23745 return nativeResponseValue;
23747 // void ClosingSignedFeeRange_set_max_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
23749 export function ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr: bigint, val: bigint): void {
23750 if(!isWasmInitialized) {
23751 throw new Error("initializeWasm() must be awaited first!");
23753 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr, val);
23754 // debug statements here
23756 // MUST_USE_RES struct LDKClosingSignedFeeRange ClosingSignedFeeRange_new(uint64_t min_fee_satoshis_arg, uint64_t max_fee_satoshis_arg);
23758 export function ClosingSignedFeeRange_new(min_fee_satoshis_arg: bigint, max_fee_satoshis_arg: bigint): bigint {
23759 if(!isWasmInitialized) {
23760 throw new Error("initializeWasm() must be awaited first!");
23762 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
23763 return nativeResponseValue;
23765 // uint64_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg);
23767 export function ClosingSignedFeeRange_clone_ptr(arg: bigint): bigint {
23768 if(!isWasmInitialized) {
23769 throw new Error("initializeWasm() must be awaited first!");
23771 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone_ptr(arg);
23772 return nativeResponseValue;
23774 // struct LDKClosingSignedFeeRange ClosingSignedFeeRange_clone(const struct LDKClosingSignedFeeRange *NONNULL_PTR orig);
23776 export function ClosingSignedFeeRange_clone(orig: bigint): bigint {
23777 if(!isWasmInitialized) {
23778 throw new Error("initializeWasm() must be awaited first!");
23780 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone(orig);
23781 return nativeResponseValue;
23783 // bool ClosingSignedFeeRange_eq(const struct LDKClosingSignedFeeRange *NONNULL_PTR a, const struct LDKClosingSignedFeeRange *NONNULL_PTR b);
23785 export function ClosingSignedFeeRange_eq(a: bigint, b: bigint): boolean {
23786 if(!isWasmInitialized) {
23787 throw new Error("initializeWasm() must be awaited first!");
23789 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_eq(a, b);
23790 return nativeResponseValue;
23792 // void ClosingSigned_free(struct LDKClosingSigned this_obj);
23794 export function ClosingSigned_free(this_obj: bigint): void {
23795 if(!isWasmInitialized) {
23796 throw new Error("initializeWasm() must be awaited first!");
23798 const nativeResponseValue = wasm.TS_ClosingSigned_free(this_obj);
23799 // debug statements here
23801 // const uint8_t (*ClosingSigned_get_channel_id(const struct LDKClosingSigned *NONNULL_PTR this_ptr))[32];
23803 export function ClosingSigned_get_channel_id(this_ptr: bigint): number {
23804 if(!isWasmInitialized) {
23805 throw new Error("initializeWasm() must be awaited first!");
23807 const nativeResponseValue = wasm.TS_ClosingSigned_get_channel_id(this_ptr);
23808 return nativeResponseValue;
23810 // void ClosingSigned_set_channel_id(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23812 export function ClosingSigned_set_channel_id(this_ptr: bigint, val: number): void {
23813 if(!isWasmInitialized) {
23814 throw new Error("initializeWasm() must be awaited first!");
23816 const nativeResponseValue = wasm.TS_ClosingSigned_set_channel_id(this_ptr, val);
23817 // debug statements here
23819 // uint64_t ClosingSigned_get_fee_satoshis(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
23821 export function ClosingSigned_get_fee_satoshis(this_ptr: bigint): bigint {
23822 if(!isWasmInitialized) {
23823 throw new Error("initializeWasm() must be awaited first!");
23825 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_satoshis(this_ptr);
23826 return nativeResponseValue;
23828 // void ClosingSigned_set_fee_satoshis(struct LDKClosingSigned *NONNULL_PTR this_ptr, uint64_t val);
23830 export function ClosingSigned_set_fee_satoshis(this_ptr: bigint, val: bigint): void {
23831 if(!isWasmInitialized) {
23832 throw new Error("initializeWasm() must be awaited first!");
23834 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_satoshis(this_ptr, val);
23835 // debug statements here
23837 // struct LDKSignature ClosingSigned_get_signature(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
23839 export function ClosingSigned_get_signature(this_ptr: bigint): number {
23840 if(!isWasmInitialized) {
23841 throw new Error("initializeWasm() must be awaited first!");
23843 const nativeResponseValue = wasm.TS_ClosingSigned_get_signature(this_ptr);
23844 return nativeResponseValue;
23846 // void ClosingSigned_set_signature(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
23848 export function ClosingSigned_set_signature(this_ptr: bigint, val: number): void {
23849 if(!isWasmInitialized) {
23850 throw new Error("initializeWasm() must be awaited first!");
23852 const nativeResponseValue = wasm.TS_ClosingSigned_set_signature(this_ptr, val);
23853 // debug statements here
23855 // struct LDKClosingSignedFeeRange ClosingSigned_get_fee_range(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
23857 export function ClosingSigned_get_fee_range(this_ptr: bigint): bigint {
23858 if(!isWasmInitialized) {
23859 throw new Error("initializeWasm() must be awaited first!");
23861 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_range(this_ptr);
23862 return nativeResponseValue;
23864 // void ClosingSigned_set_fee_range(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKClosingSignedFeeRange val);
23866 export function ClosingSigned_set_fee_range(this_ptr: bigint, val: bigint): void {
23867 if(!isWasmInitialized) {
23868 throw new Error("initializeWasm() must be awaited first!");
23870 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_range(this_ptr, val);
23871 // debug statements here
23873 // 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);
23875 export function ClosingSigned_new(channel_id_arg: number, fee_satoshis_arg: bigint, signature_arg: number, fee_range_arg: bigint): bigint {
23876 if(!isWasmInitialized) {
23877 throw new Error("initializeWasm() must be awaited first!");
23879 const nativeResponseValue = wasm.TS_ClosingSigned_new(channel_id_arg, fee_satoshis_arg, signature_arg, fee_range_arg);
23880 return nativeResponseValue;
23882 // uint64_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg);
23884 export function ClosingSigned_clone_ptr(arg: bigint): bigint {
23885 if(!isWasmInitialized) {
23886 throw new Error("initializeWasm() must be awaited first!");
23888 const nativeResponseValue = wasm.TS_ClosingSigned_clone_ptr(arg);
23889 return nativeResponseValue;
23891 // struct LDKClosingSigned ClosingSigned_clone(const struct LDKClosingSigned *NONNULL_PTR orig);
23893 export function ClosingSigned_clone(orig: bigint): bigint {
23894 if(!isWasmInitialized) {
23895 throw new Error("initializeWasm() must be awaited first!");
23897 const nativeResponseValue = wasm.TS_ClosingSigned_clone(orig);
23898 return nativeResponseValue;
23900 // bool ClosingSigned_eq(const struct LDKClosingSigned *NONNULL_PTR a, const struct LDKClosingSigned *NONNULL_PTR b);
23902 export function ClosingSigned_eq(a: bigint, b: bigint): boolean {
23903 if(!isWasmInitialized) {
23904 throw new Error("initializeWasm() must be awaited first!");
23906 const nativeResponseValue = wasm.TS_ClosingSigned_eq(a, b);
23907 return nativeResponseValue;
23909 // void UpdateAddHTLC_free(struct LDKUpdateAddHTLC this_obj);
23911 export function UpdateAddHTLC_free(this_obj: bigint): void {
23912 if(!isWasmInitialized) {
23913 throw new Error("initializeWasm() must be awaited first!");
23915 const nativeResponseValue = wasm.TS_UpdateAddHTLC_free(this_obj);
23916 // debug statements here
23918 // const uint8_t (*UpdateAddHTLC_get_channel_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
23920 export function UpdateAddHTLC_get_channel_id(this_ptr: bigint): number {
23921 if(!isWasmInitialized) {
23922 throw new Error("initializeWasm() must be awaited first!");
23924 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_channel_id(this_ptr);
23925 return nativeResponseValue;
23927 // void UpdateAddHTLC_set_channel_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23929 export function UpdateAddHTLC_set_channel_id(this_ptr: bigint, val: number): void {
23930 if(!isWasmInitialized) {
23931 throw new Error("initializeWasm() must be awaited first!");
23933 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_channel_id(this_ptr, val);
23934 // debug statements here
23936 // uint64_t UpdateAddHTLC_get_htlc_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
23938 export function UpdateAddHTLC_get_htlc_id(this_ptr: bigint): bigint {
23939 if(!isWasmInitialized) {
23940 throw new Error("initializeWasm() must be awaited first!");
23942 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_htlc_id(this_ptr);
23943 return nativeResponseValue;
23945 // void UpdateAddHTLC_set_htlc_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
23947 export function UpdateAddHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
23948 if(!isWasmInitialized) {
23949 throw new Error("initializeWasm() must be awaited first!");
23951 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_htlc_id(this_ptr, val);
23952 // debug statements here
23954 // uint64_t UpdateAddHTLC_get_amount_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
23956 export function UpdateAddHTLC_get_amount_msat(this_ptr: bigint): bigint {
23957 if(!isWasmInitialized) {
23958 throw new Error("initializeWasm() must be awaited first!");
23960 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_amount_msat(this_ptr);
23961 return nativeResponseValue;
23963 // void UpdateAddHTLC_set_amount_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
23965 export function UpdateAddHTLC_set_amount_msat(this_ptr: bigint, val: bigint): void {
23966 if(!isWasmInitialized) {
23967 throw new Error("initializeWasm() must be awaited first!");
23969 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_amount_msat(this_ptr, val);
23970 // debug statements here
23972 // const uint8_t (*UpdateAddHTLC_get_payment_hash(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
23974 export function UpdateAddHTLC_get_payment_hash(this_ptr: bigint): number {
23975 if(!isWasmInitialized) {
23976 throw new Error("initializeWasm() must be awaited first!");
23978 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_payment_hash(this_ptr);
23979 return nativeResponseValue;
23981 // void UpdateAddHTLC_set_payment_hash(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23983 export function UpdateAddHTLC_set_payment_hash(this_ptr: bigint, val: number): void {
23984 if(!isWasmInitialized) {
23985 throw new Error("initializeWasm() must be awaited first!");
23987 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_payment_hash(this_ptr, val);
23988 // debug statements here
23990 // uint32_t UpdateAddHTLC_get_cltv_expiry(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
23992 export function UpdateAddHTLC_get_cltv_expiry(this_ptr: bigint): number {
23993 if(!isWasmInitialized) {
23994 throw new Error("initializeWasm() must be awaited first!");
23996 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_cltv_expiry(this_ptr);
23997 return nativeResponseValue;
23999 // void UpdateAddHTLC_set_cltv_expiry(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint32_t val);
24001 export function UpdateAddHTLC_set_cltv_expiry(this_ptr: bigint, val: number): void {
24002 if(!isWasmInitialized) {
24003 throw new Error("initializeWasm() must be awaited first!");
24005 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_cltv_expiry(this_ptr, val);
24006 // debug statements here
24008 // uint64_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg);
24010 export function UpdateAddHTLC_clone_ptr(arg: bigint): bigint {
24011 if(!isWasmInitialized) {
24012 throw new Error("initializeWasm() must be awaited first!");
24014 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone_ptr(arg);
24015 return nativeResponseValue;
24017 // struct LDKUpdateAddHTLC UpdateAddHTLC_clone(const struct LDKUpdateAddHTLC *NONNULL_PTR orig);
24019 export function UpdateAddHTLC_clone(orig: bigint): bigint {
24020 if(!isWasmInitialized) {
24021 throw new Error("initializeWasm() must be awaited first!");
24023 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone(orig);
24024 return nativeResponseValue;
24026 // bool UpdateAddHTLC_eq(const struct LDKUpdateAddHTLC *NONNULL_PTR a, const struct LDKUpdateAddHTLC *NONNULL_PTR b);
24028 export function UpdateAddHTLC_eq(a: bigint, b: bigint): boolean {
24029 if(!isWasmInitialized) {
24030 throw new Error("initializeWasm() must be awaited first!");
24032 const nativeResponseValue = wasm.TS_UpdateAddHTLC_eq(a, b);
24033 return nativeResponseValue;
24035 // void OnionMessage_free(struct LDKOnionMessage this_obj);
24037 export function OnionMessage_free(this_obj: bigint): void {
24038 if(!isWasmInitialized) {
24039 throw new Error("initializeWasm() must be awaited first!");
24041 const nativeResponseValue = wasm.TS_OnionMessage_free(this_obj);
24042 // debug statements here
24044 // struct LDKPublicKey OnionMessage_get_blinding_point(const struct LDKOnionMessage *NONNULL_PTR this_ptr);
24046 export function OnionMessage_get_blinding_point(this_ptr: bigint): number {
24047 if(!isWasmInitialized) {
24048 throw new Error("initializeWasm() must be awaited first!");
24050 const nativeResponseValue = wasm.TS_OnionMessage_get_blinding_point(this_ptr);
24051 return nativeResponseValue;
24053 // void OnionMessage_set_blinding_point(struct LDKOnionMessage *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24055 export function OnionMessage_set_blinding_point(this_ptr: bigint, val: number): void {
24056 if(!isWasmInitialized) {
24057 throw new Error("initializeWasm() must be awaited first!");
24059 const nativeResponseValue = wasm.TS_OnionMessage_set_blinding_point(this_ptr, val);
24060 // debug statements here
24062 // uint64_t OnionMessage_clone_ptr(LDKOnionMessage *NONNULL_PTR arg);
24064 export function OnionMessage_clone_ptr(arg: bigint): bigint {
24065 if(!isWasmInitialized) {
24066 throw new Error("initializeWasm() must be awaited first!");
24068 const nativeResponseValue = wasm.TS_OnionMessage_clone_ptr(arg);
24069 return nativeResponseValue;
24071 // struct LDKOnionMessage OnionMessage_clone(const struct LDKOnionMessage *NONNULL_PTR orig);
24073 export function OnionMessage_clone(orig: bigint): bigint {
24074 if(!isWasmInitialized) {
24075 throw new Error("initializeWasm() must be awaited first!");
24077 const nativeResponseValue = wasm.TS_OnionMessage_clone(orig);
24078 return nativeResponseValue;
24080 // bool OnionMessage_eq(const struct LDKOnionMessage *NONNULL_PTR a, const struct LDKOnionMessage *NONNULL_PTR b);
24082 export function OnionMessage_eq(a: bigint, b: bigint): boolean {
24083 if(!isWasmInitialized) {
24084 throw new Error("initializeWasm() must be awaited first!");
24086 const nativeResponseValue = wasm.TS_OnionMessage_eq(a, b);
24087 return nativeResponseValue;
24089 // void UpdateFulfillHTLC_free(struct LDKUpdateFulfillHTLC this_obj);
24091 export function UpdateFulfillHTLC_free(this_obj: bigint): void {
24092 if(!isWasmInitialized) {
24093 throw new Error("initializeWasm() must be awaited first!");
24095 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_free(this_obj);
24096 // debug statements here
24098 // const uint8_t (*UpdateFulfillHTLC_get_channel_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
24100 export function UpdateFulfillHTLC_get_channel_id(this_ptr: bigint): number {
24101 if(!isWasmInitialized) {
24102 throw new Error("initializeWasm() must be awaited first!");
24104 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_channel_id(this_ptr);
24105 return nativeResponseValue;
24107 // void UpdateFulfillHTLC_set_channel_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24109 export function UpdateFulfillHTLC_set_channel_id(this_ptr: bigint, val: number): void {
24110 if(!isWasmInitialized) {
24111 throw new Error("initializeWasm() must be awaited first!");
24113 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_channel_id(this_ptr, val);
24114 // debug statements here
24116 // uint64_t UpdateFulfillHTLC_get_htlc_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr);
24118 export function UpdateFulfillHTLC_get_htlc_id(this_ptr: bigint): bigint {
24119 if(!isWasmInitialized) {
24120 throw new Error("initializeWasm() must be awaited first!");
24122 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_htlc_id(this_ptr);
24123 return nativeResponseValue;
24125 // void UpdateFulfillHTLC_set_htlc_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, uint64_t val);
24127 export function UpdateFulfillHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
24128 if(!isWasmInitialized) {
24129 throw new Error("initializeWasm() must be awaited first!");
24131 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_htlc_id(this_ptr, val);
24132 // debug statements here
24134 // const uint8_t (*UpdateFulfillHTLC_get_payment_preimage(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
24136 export function UpdateFulfillHTLC_get_payment_preimage(this_ptr: bigint): number {
24137 if(!isWasmInitialized) {
24138 throw new Error("initializeWasm() must be awaited first!");
24140 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_payment_preimage(this_ptr);
24141 return nativeResponseValue;
24143 // void UpdateFulfillHTLC_set_payment_preimage(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24145 export function UpdateFulfillHTLC_set_payment_preimage(this_ptr: bigint, val: number): void {
24146 if(!isWasmInitialized) {
24147 throw new Error("initializeWasm() must be awaited first!");
24149 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_payment_preimage(this_ptr, val);
24150 // debug statements here
24152 // MUST_USE_RES struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t htlc_id_arg, struct LDKThirtyTwoBytes payment_preimage_arg);
24154 export function UpdateFulfillHTLC_new(channel_id_arg: number, htlc_id_arg: bigint, payment_preimage_arg: number): bigint {
24155 if(!isWasmInitialized) {
24156 throw new Error("initializeWasm() must be awaited first!");
24158 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_new(channel_id_arg, htlc_id_arg, payment_preimage_arg);
24159 return nativeResponseValue;
24161 // uint64_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg);
24163 export function UpdateFulfillHTLC_clone_ptr(arg: bigint): bigint {
24164 if(!isWasmInitialized) {
24165 throw new Error("initializeWasm() must be awaited first!");
24167 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone_ptr(arg);
24168 return nativeResponseValue;
24170 // struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_clone(const struct LDKUpdateFulfillHTLC *NONNULL_PTR orig);
24172 export function UpdateFulfillHTLC_clone(orig: bigint): bigint {
24173 if(!isWasmInitialized) {
24174 throw new Error("initializeWasm() must be awaited first!");
24176 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone(orig);
24177 return nativeResponseValue;
24179 // bool UpdateFulfillHTLC_eq(const struct LDKUpdateFulfillHTLC *NONNULL_PTR a, const struct LDKUpdateFulfillHTLC *NONNULL_PTR b);
24181 export function UpdateFulfillHTLC_eq(a: bigint, b: bigint): boolean {
24182 if(!isWasmInitialized) {
24183 throw new Error("initializeWasm() must be awaited first!");
24185 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_eq(a, b);
24186 return nativeResponseValue;
24188 // void UpdateFailHTLC_free(struct LDKUpdateFailHTLC this_obj);
24190 export function UpdateFailHTLC_free(this_obj: bigint): void {
24191 if(!isWasmInitialized) {
24192 throw new Error("initializeWasm() must be awaited first!");
24194 const nativeResponseValue = wasm.TS_UpdateFailHTLC_free(this_obj);
24195 // debug statements here
24197 // const uint8_t (*UpdateFailHTLC_get_channel_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr))[32];
24199 export function UpdateFailHTLC_get_channel_id(this_ptr: bigint): number {
24200 if(!isWasmInitialized) {
24201 throw new Error("initializeWasm() must be awaited first!");
24203 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_channel_id(this_ptr);
24204 return nativeResponseValue;
24206 // void UpdateFailHTLC_set_channel_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24208 export function UpdateFailHTLC_set_channel_id(this_ptr: bigint, val: number): void {
24209 if(!isWasmInitialized) {
24210 throw new Error("initializeWasm() must be awaited first!");
24212 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_channel_id(this_ptr, val);
24213 // debug statements here
24215 // uint64_t UpdateFailHTLC_get_htlc_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr);
24217 export function UpdateFailHTLC_get_htlc_id(this_ptr: bigint): bigint {
24218 if(!isWasmInitialized) {
24219 throw new Error("initializeWasm() must be awaited first!");
24221 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_htlc_id(this_ptr);
24222 return nativeResponseValue;
24224 // void UpdateFailHTLC_set_htlc_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, uint64_t val);
24226 export function UpdateFailHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
24227 if(!isWasmInitialized) {
24228 throw new Error("initializeWasm() must be awaited first!");
24230 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_htlc_id(this_ptr, val);
24231 // debug statements here
24233 // uint64_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg);
24235 export function UpdateFailHTLC_clone_ptr(arg: bigint): bigint {
24236 if(!isWasmInitialized) {
24237 throw new Error("initializeWasm() must be awaited first!");
24239 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone_ptr(arg);
24240 return nativeResponseValue;
24242 // struct LDKUpdateFailHTLC UpdateFailHTLC_clone(const struct LDKUpdateFailHTLC *NONNULL_PTR orig);
24244 export function UpdateFailHTLC_clone(orig: bigint): bigint {
24245 if(!isWasmInitialized) {
24246 throw new Error("initializeWasm() must be awaited first!");
24248 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone(orig);
24249 return nativeResponseValue;
24251 // bool UpdateFailHTLC_eq(const struct LDKUpdateFailHTLC *NONNULL_PTR a, const struct LDKUpdateFailHTLC *NONNULL_PTR b);
24253 export function UpdateFailHTLC_eq(a: bigint, b: bigint): boolean {
24254 if(!isWasmInitialized) {
24255 throw new Error("initializeWasm() must be awaited first!");
24257 const nativeResponseValue = wasm.TS_UpdateFailHTLC_eq(a, b);
24258 return nativeResponseValue;
24260 // void UpdateFailMalformedHTLC_free(struct LDKUpdateFailMalformedHTLC this_obj);
24262 export function UpdateFailMalformedHTLC_free(this_obj: bigint): void {
24263 if(!isWasmInitialized) {
24264 throw new Error("initializeWasm() must be awaited first!");
24266 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_free(this_obj);
24267 // debug statements here
24269 // const uint8_t (*UpdateFailMalformedHTLC_get_channel_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr))[32];
24271 export function UpdateFailMalformedHTLC_get_channel_id(this_ptr: bigint): number {
24272 if(!isWasmInitialized) {
24273 throw new Error("initializeWasm() must be awaited first!");
24275 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_channel_id(this_ptr);
24276 return nativeResponseValue;
24278 // void UpdateFailMalformedHTLC_set_channel_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24280 export function UpdateFailMalformedHTLC_set_channel_id(this_ptr: bigint, val: number): void {
24281 if(!isWasmInitialized) {
24282 throw new Error("initializeWasm() must be awaited first!");
24284 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_channel_id(this_ptr, val);
24285 // debug statements here
24287 // uint64_t UpdateFailMalformedHTLC_get_htlc_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
24289 export function UpdateFailMalformedHTLC_get_htlc_id(this_ptr: bigint): bigint {
24290 if(!isWasmInitialized) {
24291 throw new Error("initializeWasm() must be awaited first!");
24293 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_htlc_id(this_ptr);
24294 return nativeResponseValue;
24296 // void UpdateFailMalformedHTLC_set_htlc_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint64_t val);
24298 export function UpdateFailMalformedHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
24299 if(!isWasmInitialized) {
24300 throw new Error("initializeWasm() must be awaited first!");
24302 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_htlc_id(this_ptr, val);
24303 // debug statements here
24305 // uint16_t UpdateFailMalformedHTLC_get_failure_code(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
24307 export function UpdateFailMalformedHTLC_get_failure_code(this_ptr: bigint): number {
24308 if(!isWasmInitialized) {
24309 throw new Error("initializeWasm() must be awaited first!");
24311 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_failure_code(this_ptr);
24312 return nativeResponseValue;
24314 // void UpdateFailMalformedHTLC_set_failure_code(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint16_t val);
24316 export function UpdateFailMalformedHTLC_set_failure_code(this_ptr: bigint, val: number): void {
24317 if(!isWasmInitialized) {
24318 throw new Error("initializeWasm() must be awaited first!");
24320 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_failure_code(this_ptr, val);
24321 // debug statements here
24323 // uint64_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg);
24325 export function UpdateFailMalformedHTLC_clone_ptr(arg: bigint): bigint {
24326 if(!isWasmInitialized) {
24327 throw new Error("initializeWasm() must be awaited first!");
24329 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone_ptr(arg);
24330 return nativeResponseValue;
24332 // struct LDKUpdateFailMalformedHTLC UpdateFailMalformedHTLC_clone(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR orig);
24334 export function UpdateFailMalformedHTLC_clone(orig: bigint): bigint {
24335 if(!isWasmInitialized) {
24336 throw new Error("initializeWasm() must be awaited first!");
24338 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone(orig);
24339 return nativeResponseValue;
24341 // bool UpdateFailMalformedHTLC_eq(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR a, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR b);
24343 export function UpdateFailMalformedHTLC_eq(a: bigint, b: bigint): boolean {
24344 if(!isWasmInitialized) {
24345 throw new Error("initializeWasm() must be awaited first!");
24347 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_eq(a, b);
24348 return nativeResponseValue;
24350 // void CommitmentSigned_free(struct LDKCommitmentSigned this_obj);
24352 export function CommitmentSigned_free(this_obj: bigint): void {
24353 if(!isWasmInitialized) {
24354 throw new Error("initializeWasm() must be awaited first!");
24356 const nativeResponseValue = wasm.TS_CommitmentSigned_free(this_obj);
24357 // debug statements here
24359 // const uint8_t (*CommitmentSigned_get_channel_id(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr))[32];
24361 export function CommitmentSigned_get_channel_id(this_ptr: bigint): number {
24362 if(!isWasmInitialized) {
24363 throw new Error("initializeWasm() must be awaited first!");
24365 const nativeResponseValue = wasm.TS_CommitmentSigned_get_channel_id(this_ptr);
24366 return nativeResponseValue;
24368 // void CommitmentSigned_set_channel_id(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24370 export function CommitmentSigned_set_channel_id(this_ptr: bigint, val: number): void {
24371 if(!isWasmInitialized) {
24372 throw new Error("initializeWasm() must be awaited first!");
24374 const nativeResponseValue = wasm.TS_CommitmentSigned_set_channel_id(this_ptr, val);
24375 // debug statements here
24377 // struct LDKSignature CommitmentSigned_get_signature(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
24379 export function CommitmentSigned_get_signature(this_ptr: bigint): number {
24380 if(!isWasmInitialized) {
24381 throw new Error("initializeWasm() must be awaited first!");
24383 const nativeResponseValue = wasm.TS_CommitmentSigned_get_signature(this_ptr);
24384 return nativeResponseValue;
24386 // void CommitmentSigned_set_signature(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
24388 export function CommitmentSigned_set_signature(this_ptr: bigint, val: number): void {
24389 if(!isWasmInitialized) {
24390 throw new Error("initializeWasm() must be awaited first!");
24392 const nativeResponseValue = wasm.TS_CommitmentSigned_set_signature(this_ptr, val);
24393 // debug statements here
24395 // struct LDKCVec_SignatureZ CommitmentSigned_get_htlc_signatures(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
24397 export function CommitmentSigned_get_htlc_signatures(this_ptr: bigint): number {
24398 if(!isWasmInitialized) {
24399 throw new Error("initializeWasm() must be awaited first!");
24401 const nativeResponseValue = wasm.TS_CommitmentSigned_get_htlc_signatures(this_ptr);
24402 return nativeResponseValue;
24404 // void CommitmentSigned_set_htlc_signatures(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
24406 export function CommitmentSigned_set_htlc_signatures(this_ptr: bigint, val: number): void {
24407 if(!isWasmInitialized) {
24408 throw new Error("initializeWasm() must be awaited first!");
24410 const nativeResponseValue = wasm.TS_CommitmentSigned_set_htlc_signatures(this_ptr, val);
24411 // debug statements here
24413 // MUST_USE_RES struct LDKCommitmentSigned CommitmentSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg, struct LDKCVec_SignatureZ htlc_signatures_arg);
24415 export function CommitmentSigned_new(channel_id_arg: number, signature_arg: number, htlc_signatures_arg: number): bigint {
24416 if(!isWasmInitialized) {
24417 throw new Error("initializeWasm() must be awaited first!");
24419 const nativeResponseValue = wasm.TS_CommitmentSigned_new(channel_id_arg, signature_arg, htlc_signatures_arg);
24420 return nativeResponseValue;
24422 // uint64_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg);
24424 export function CommitmentSigned_clone_ptr(arg: bigint): bigint {
24425 if(!isWasmInitialized) {
24426 throw new Error("initializeWasm() must be awaited first!");
24428 const nativeResponseValue = wasm.TS_CommitmentSigned_clone_ptr(arg);
24429 return nativeResponseValue;
24431 // struct LDKCommitmentSigned CommitmentSigned_clone(const struct LDKCommitmentSigned *NONNULL_PTR orig);
24433 export function CommitmentSigned_clone(orig: bigint): bigint {
24434 if(!isWasmInitialized) {
24435 throw new Error("initializeWasm() must be awaited first!");
24437 const nativeResponseValue = wasm.TS_CommitmentSigned_clone(orig);
24438 return nativeResponseValue;
24440 // bool CommitmentSigned_eq(const struct LDKCommitmentSigned *NONNULL_PTR a, const struct LDKCommitmentSigned *NONNULL_PTR b);
24442 export function CommitmentSigned_eq(a: bigint, b: bigint): boolean {
24443 if(!isWasmInitialized) {
24444 throw new Error("initializeWasm() must be awaited first!");
24446 const nativeResponseValue = wasm.TS_CommitmentSigned_eq(a, b);
24447 return nativeResponseValue;
24449 // void RevokeAndACK_free(struct LDKRevokeAndACK this_obj);
24451 export function RevokeAndACK_free(this_obj: bigint): void {
24452 if(!isWasmInitialized) {
24453 throw new Error("initializeWasm() must be awaited first!");
24455 const nativeResponseValue = wasm.TS_RevokeAndACK_free(this_obj);
24456 // debug statements here
24458 // const uint8_t (*RevokeAndACK_get_channel_id(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
24460 export function RevokeAndACK_get_channel_id(this_ptr: bigint): number {
24461 if(!isWasmInitialized) {
24462 throw new Error("initializeWasm() must be awaited first!");
24464 const nativeResponseValue = wasm.TS_RevokeAndACK_get_channel_id(this_ptr);
24465 return nativeResponseValue;
24467 // void RevokeAndACK_set_channel_id(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24469 export function RevokeAndACK_set_channel_id(this_ptr: bigint, val: number): void {
24470 if(!isWasmInitialized) {
24471 throw new Error("initializeWasm() must be awaited first!");
24473 const nativeResponseValue = wasm.TS_RevokeAndACK_set_channel_id(this_ptr, val);
24474 // debug statements here
24476 // const uint8_t (*RevokeAndACK_get_per_commitment_secret(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
24478 export function RevokeAndACK_get_per_commitment_secret(this_ptr: bigint): number {
24479 if(!isWasmInitialized) {
24480 throw new Error("initializeWasm() must be awaited first!");
24482 const nativeResponseValue = wasm.TS_RevokeAndACK_get_per_commitment_secret(this_ptr);
24483 return nativeResponseValue;
24485 // void RevokeAndACK_set_per_commitment_secret(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24487 export function RevokeAndACK_set_per_commitment_secret(this_ptr: bigint, val: number): void {
24488 if(!isWasmInitialized) {
24489 throw new Error("initializeWasm() must be awaited first!");
24491 const nativeResponseValue = wasm.TS_RevokeAndACK_set_per_commitment_secret(this_ptr, val);
24492 // debug statements here
24494 // struct LDKPublicKey RevokeAndACK_get_next_per_commitment_point(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr);
24496 export function RevokeAndACK_get_next_per_commitment_point(this_ptr: bigint): number {
24497 if(!isWasmInitialized) {
24498 throw new Error("initializeWasm() must be awaited first!");
24500 const nativeResponseValue = wasm.TS_RevokeAndACK_get_next_per_commitment_point(this_ptr);
24501 return nativeResponseValue;
24503 // void RevokeAndACK_set_next_per_commitment_point(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24505 export function RevokeAndACK_set_next_per_commitment_point(this_ptr: bigint, val: number): void {
24506 if(!isWasmInitialized) {
24507 throw new Error("initializeWasm() must be awaited first!");
24509 const nativeResponseValue = wasm.TS_RevokeAndACK_set_next_per_commitment_point(this_ptr, val);
24510 // debug statements here
24512 // 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);
24514 export function RevokeAndACK_new(channel_id_arg: number, per_commitment_secret_arg: number, next_per_commitment_point_arg: number): bigint {
24515 if(!isWasmInitialized) {
24516 throw new Error("initializeWasm() must be awaited first!");
24518 const nativeResponseValue = wasm.TS_RevokeAndACK_new(channel_id_arg, per_commitment_secret_arg, next_per_commitment_point_arg);
24519 return nativeResponseValue;
24521 // uint64_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg);
24523 export function RevokeAndACK_clone_ptr(arg: bigint): bigint {
24524 if(!isWasmInitialized) {
24525 throw new Error("initializeWasm() must be awaited first!");
24527 const nativeResponseValue = wasm.TS_RevokeAndACK_clone_ptr(arg);
24528 return nativeResponseValue;
24530 // struct LDKRevokeAndACK RevokeAndACK_clone(const struct LDKRevokeAndACK *NONNULL_PTR orig);
24532 export function RevokeAndACK_clone(orig: bigint): bigint {
24533 if(!isWasmInitialized) {
24534 throw new Error("initializeWasm() must be awaited first!");
24536 const nativeResponseValue = wasm.TS_RevokeAndACK_clone(orig);
24537 return nativeResponseValue;
24539 // bool RevokeAndACK_eq(const struct LDKRevokeAndACK *NONNULL_PTR a, const struct LDKRevokeAndACK *NONNULL_PTR b);
24541 export function RevokeAndACK_eq(a: bigint, b: bigint): boolean {
24542 if(!isWasmInitialized) {
24543 throw new Error("initializeWasm() must be awaited first!");
24545 const nativeResponseValue = wasm.TS_RevokeAndACK_eq(a, b);
24546 return nativeResponseValue;
24548 // void UpdateFee_free(struct LDKUpdateFee this_obj);
24550 export function UpdateFee_free(this_obj: bigint): void {
24551 if(!isWasmInitialized) {
24552 throw new Error("initializeWasm() must be awaited first!");
24554 const nativeResponseValue = wasm.TS_UpdateFee_free(this_obj);
24555 // debug statements here
24557 // const uint8_t (*UpdateFee_get_channel_id(const struct LDKUpdateFee *NONNULL_PTR this_ptr))[32];
24559 export function UpdateFee_get_channel_id(this_ptr: bigint): number {
24560 if(!isWasmInitialized) {
24561 throw new Error("initializeWasm() must be awaited first!");
24563 const nativeResponseValue = wasm.TS_UpdateFee_get_channel_id(this_ptr);
24564 return nativeResponseValue;
24566 // void UpdateFee_set_channel_id(struct LDKUpdateFee *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24568 export function UpdateFee_set_channel_id(this_ptr: bigint, val: number): void {
24569 if(!isWasmInitialized) {
24570 throw new Error("initializeWasm() must be awaited first!");
24572 const nativeResponseValue = wasm.TS_UpdateFee_set_channel_id(this_ptr, val);
24573 // debug statements here
24575 // uint32_t UpdateFee_get_feerate_per_kw(const struct LDKUpdateFee *NONNULL_PTR this_ptr);
24577 export function UpdateFee_get_feerate_per_kw(this_ptr: bigint): number {
24578 if(!isWasmInitialized) {
24579 throw new Error("initializeWasm() must be awaited first!");
24581 const nativeResponseValue = wasm.TS_UpdateFee_get_feerate_per_kw(this_ptr);
24582 return nativeResponseValue;
24584 // void UpdateFee_set_feerate_per_kw(struct LDKUpdateFee *NONNULL_PTR this_ptr, uint32_t val);
24586 export function UpdateFee_set_feerate_per_kw(this_ptr: bigint, val: number): void {
24587 if(!isWasmInitialized) {
24588 throw new Error("initializeWasm() must be awaited first!");
24590 const nativeResponseValue = wasm.TS_UpdateFee_set_feerate_per_kw(this_ptr, val);
24591 // debug statements here
24593 // MUST_USE_RES struct LDKUpdateFee UpdateFee_new(struct LDKThirtyTwoBytes channel_id_arg, uint32_t feerate_per_kw_arg);
24595 export function UpdateFee_new(channel_id_arg: number, feerate_per_kw_arg: number): bigint {
24596 if(!isWasmInitialized) {
24597 throw new Error("initializeWasm() must be awaited first!");
24599 const nativeResponseValue = wasm.TS_UpdateFee_new(channel_id_arg, feerate_per_kw_arg);
24600 return nativeResponseValue;
24602 // uint64_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg);
24604 export function UpdateFee_clone_ptr(arg: bigint): bigint {
24605 if(!isWasmInitialized) {
24606 throw new Error("initializeWasm() must be awaited first!");
24608 const nativeResponseValue = wasm.TS_UpdateFee_clone_ptr(arg);
24609 return nativeResponseValue;
24611 // struct LDKUpdateFee UpdateFee_clone(const struct LDKUpdateFee *NONNULL_PTR orig);
24613 export function UpdateFee_clone(orig: bigint): bigint {
24614 if(!isWasmInitialized) {
24615 throw new Error("initializeWasm() must be awaited first!");
24617 const nativeResponseValue = wasm.TS_UpdateFee_clone(orig);
24618 return nativeResponseValue;
24620 // bool UpdateFee_eq(const struct LDKUpdateFee *NONNULL_PTR a, const struct LDKUpdateFee *NONNULL_PTR b);
24622 export function UpdateFee_eq(a: bigint, b: bigint): boolean {
24623 if(!isWasmInitialized) {
24624 throw new Error("initializeWasm() must be awaited first!");
24626 const nativeResponseValue = wasm.TS_UpdateFee_eq(a, b);
24627 return nativeResponseValue;
24629 // void DataLossProtect_free(struct LDKDataLossProtect this_obj);
24631 export function DataLossProtect_free(this_obj: bigint): void {
24632 if(!isWasmInitialized) {
24633 throw new Error("initializeWasm() must be awaited first!");
24635 const nativeResponseValue = wasm.TS_DataLossProtect_free(this_obj);
24636 // debug statements here
24638 // const uint8_t (*DataLossProtect_get_your_last_per_commitment_secret(const struct LDKDataLossProtect *NONNULL_PTR this_ptr))[32];
24640 export function DataLossProtect_get_your_last_per_commitment_secret(this_ptr: bigint): number {
24641 if(!isWasmInitialized) {
24642 throw new Error("initializeWasm() must be awaited first!");
24644 const nativeResponseValue = wasm.TS_DataLossProtect_get_your_last_per_commitment_secret(this_ptr);
24645 return nativeResponseValue;
24647 // void DataLossProtect_set_your_last_per_commitment_secret(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24649 export function DataLossProtect_set_your_last_per_commitment_secret(this_ptr: bigint, val: number): void {
24650 if(!isWasmInitialized) {
24651 throw new Error("initializeWasm() must be awaited first!");
24653 const nativeResponseValue = wasm.TS_DataLossProtect_set_your_last_per_commitment_secret(this_ptr, val);
24654 // debug statements here
24656 // struct LDKPublicKey DataLossProtect_get_my_current_per_commitment_point(const struct LDKDataLossProtect *NONNULL_PTR this_ptr);
24658 export function DataLossProtect_get_my_current_per_commitment_point(this_ptr: bigint): number {
24659 if(!isWasmInitialized) {
24660 throw new Error("initializeWasm() must be awaited first!");
24662 const nativeResponseValue = wasm.TS_DataLossProtect_get_my_current_per_commitment_point(this_ptr);
24663 return nativeResponseValue;
24665 // void DataLossProtect_set_my_current_per_commitment_point(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24667 export function DataLossProtect_set_my_current_per_commitment_point(this_ptr: bigint, val: number): void {
24668 if(!isWasmInitialized) {
24669 throw new Error("initializeWasm() must be awaited first!");
24671 const nativeResponseValue = wasm.TS_DataLossProtect_set_my_current_per_commitment_point(this_ptr, val);
24672 // debug statements here
24674 // MUST_USE_RES struct LDKDataLossProtect DataLossProtect_new(struct LDKThirtyTwoBytes your_last_per_commitment_secret_arg, struct LDKPublicKey my_current_per_commitment_point_arg);
24676 export function DataLossProtect_new(your_last_per_commitment_secret_arg: number, my_current_per_commitment_point_arg: number): bigint {
24677 if(!isWasmInitialized) {
24678 throw new Error("initializeWasm() must be awaited first!");
24680 const nativeResponseValue = wasm.TS_DataLossProtect_new(your_last_per_commitment_secret_arg, my_current_per_commitment_point_arg);
24681 return nativeResponseValue;
24683 // uint64_t DataLossProtect_clone_ptr(LDKDataLossProtect *NONNULL_PTR arg);
24685 export function DataLossProtect_clone_ptr(arg: bigint): bigint {
24686 if(!isWasmInitialized) {
24687 throw new Error("initializeWasm() must be awaited first!");
24689 const nativeResponseValue = wasm.TS_DataLossProtect_clone_ptr(arg);
24690 return nativeResponseValue;
24692 // struct LDKDataLossProtect DataLossProtect_clone(const struct LDKDataLossProtect *NONNULL_PTR orig);
24694 export function DataLossProtect_clone(orig: bigint): bigint {
24695 if(!isWasmInitialized) {
24696 throw new Error("initializeWasm() must be awaited first!");
24698 const nativeResponseValue = wasm.TS_DataLossProtect_clone(orig);
24699 return nativeResponseValue;
24701 // bool DataLossProtect_eq(const struct LDKDataLossProtect *NONNULL_PTR a, const struct LDKDataLossProtect *NONNULL_PTR b);
24703 export function DataLossProtect_eq(a: bigint, b: bigint): boolean {
24704 if(!isWasmInitialized) {
24705 throw new Error("initializeWasm() must be awaited first!");
24707 const nativeResponseValue = wasm.TS_DataLossProtect_eq(a, b);
24708 return nativeResponseValue;
24710 // void ChannelReestablish_free(struct LDKChannelReestablish this_obj);
24712 export function ChannelReestablish_free(this_obj: bigint): void {
24713 if(!isWasmInitialized) {
24714 throw new Error("initializeWasm() must be awaited first!");
24716 const nativeResponseValue = wasm.TS_ChannelReestablish_free(this_obj);
24717 // debug statements here
24719 // const uint8_t (*ChannelReestablish_get_channel_id(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
24721 export function ChannelReestablish_get_channel_id(this_ptr: bigint): number {
24722 if(!isWasmInitialized) {
24723 throw new Error("initializeWasm() must be awaited first!");
24725 const nativeResponseValue = wasm.TS_ChannelReestablish_get_channel_id(this_ptr);
24726 return nativeResponseValue;
24728 // void ChannelReestablish_set_channel_id(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24730 export function ChannelReestablish_set_channel_id(this_ptr: bigint, val: number): void {
24731 if(!isWasmInitialized) {
24732 throw new Error("initializeWasm() must be awaited first!");
24734 const nativeResponseValue = wasm.TS_ChannelReestablish_set_channel_id(this_ptr, val);
24735 // debug statements here
24737 // uint64_t ChannelReestablish_get_next_local_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
24739 export function ChannelReestablish_get_next_local_commitment_number(this_ptr: bigint): bigint {
24740 if(!isWasmInitialized) {
24741 throw new Error("initializeWasm() must be awaited first!");
24743 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_local_commitment_number(this_ptr);
24744 return nativeResponseValue;
24746 // void ChannelReestablish_set_next_local_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
24748 export function ChannelReestablish_set_next_local_commitment_number(this_ptr: bigint, val: bigint): void {
24749 if(!isWasmInitialized) {
24750 throw new Error("initializeWasm() must be awaited first!");
24752 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_local_commitment_number(this_ptr, val);
24753 // debug statements here
24755 // uint64_t ChannelReestablish_get_next_remote_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
24757 export function ChannelReestablish_get_next_remote_commitment_number(this_ptr: bigint): bigint {
24758 if(!isWasmInitialized) {
24759 throw new Error("initializeWasm() must be awaited first!");
24761 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_remote_commitment_number(this_ptr);
24762 return nativeResponseValue;
24764 // void ChannelReestablish_set_next_remote_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
24766 export function ChannelReestablish_set_next_remote_commitment_number(this_ptr: bigint, val: bigint): void {
24767 if(!isWasmInitialized) {
24768 throw new Error("initializeWasm() must be awaited first!");
24770 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_remote_commitment_number(this_ptr, val);
24771 // debug statements here
24773 // uint64_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg);
24775 export function ChannelReestablish_clone_ptr(arg: bigint): bigint {
24776 if(!isWasmInitialized) {
24777 throw new Error("initializeWasm() must be awaited first!");
24779 const nativeResponseValue = wasm.TS_ChannelReestablish_clone_ptr(arg);
24780 return nativeResponseValue;
24782 // struct LDKChannelReestablish ChannelReestablish_clone(const struct LDKChannelReestablish *NONNULL_PTR orig);
24784 export function ChannelReestablish_clone(orig: bigint): bigint {
24785 if(!isWasmInitialized) {
24786 throw new Error("initializeWasm() must be awaited first!");
24788 const nativeResponseValue = wasm.TS_ChannelReestablish_clone(orig);
24789 return nativeResponseValue;
24791 // bool ChannelReestablish_eq(const struct LDKChannelReestablish *NONNULL_PTR a, const struct LDKChannelReestablish *NONNULL_PTR b);
24793 export function ChannelReestablish_eq(a: bigint, b: bigint): boolean {
24794 if(!isWasmInitialized) {
24795 throw new Error("initializeWasm() must be awaited first!");
24797 const nativeResponseValue = wasm.TS_ChannelReestablish_eq(a, b);
24798 return nativeResponseValue;
24800 // void AnnouncementSignatures_free(struct LDKAnnouncementSignatures this_obj);
24802 export function AnnouncementSignatures_free(this_obj: bigint): void {
24803 if(!isWasmInitialized) {
24804 throw new Error("initializeWasm() must be awaited first!");
24806 const nativeResponseValue = wasm.TS_AnnouncementSignatures_free(this_obj);
24807 // debug statements here
24809 // const uint8_t (*AnnouncementSignatures_get_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr))[32];
24811 export function AnnouncementSignatures_get_channel_id(this_ptr: bigint): number {
24812 if(!isWasmInitialized) {
24813 throw new Error("initializeWasm() must be awaited first!");
24815 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_channel_id(this_ptr);
24816 return nativeResponseValue;
24818 // void AnnouncementSignatures_set_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24820 export function AnnouncementSignatures_set_channel_id(this_ptr: bigint, val: number): void {
24821 if(!isWasmInitialized) {
24822 throw new Error("initializeWasm() must be awaited first!");
24824 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_channel_id(this_ptr, val);
24825 // debug statements here
24827 // uint64_t AnnouncementSignatures_get_short_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
24829 export function AnnouncementSignatures_get_short_channel_id(this_ptr: bigint): bigint {
24830 if(!isWasmInitialized) {
24831 throw new Error("initializeWasm() must be awaited first!");
24833 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_short_channel_id(this_ptr);
24834 return nativeResponseValue;
24836 // void AnnouncementSignatures_set_short_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, uint64_t val);
24838 export function AnnouncementSignatures_set_short_channel_id(this_ptr: bigint, val: bigint): void {
24839 if(!isWasmInitialized) {
24840 throw new Error("initializeWasm() must be awaited first!");
24842 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_short_channel_id(this_ptr, val);
24843 // debug statements here
24845 // struct LDKSignature AnnouncementSignatures_get_node_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
24847 export function AnnouncementSignatures_get_node_signature(this_ptr: bigint): number {
24848 if(!isWasmInitialized) {
24849 throw new Error("initializeWasm() must be awaited first!");
24851 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_node_signature(this_ptr);
24852 return nativeResponseValue;
24854 // void AnnouncementSignatures_set_node_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
24856 export function AnnouncementSignatures_set_node_signature(this_ptr: bigint, val: number): void {
24857 if(!isWasmInitialized) {
24858 throw new Error("initializeWasm() must be awaited first!");
24860 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_node_signature(this_ptr, val);
24861 // debug statements here
24863 // struct LDKSignature AnnouncementSignatures_get_bitcoin_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
24865 export function AnnouncementSignatures_get_bitcoin_signature(this_ptr: bigint): number {
24866 if(!isWasmInitialized) {
24867 throw new Error("initializeWasm() must be awaited first!");
24869 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_bitcoin_signature(this_ptr);
24870 return nativeResponseValue;
24872 // void AnnouncementSignatures_set_bitcoin_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
24874 export function AnnouncementSignatures_set_bitcoin_signature(this_ptr: bigint, val: number): void {
24875 if(!isWasmInitialized) {
24876 throw new Error("initializeWasm() must be awaited first!");
24878 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_bitcoin_signature(this_ptr, val);
24879 // debug statements here
24881 // 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);
24883 export function AnnouncementSignatures_new(channel_id_arg: number, short_channel_id_arg: bigint, node_signature_arg: number, bitcoin_signature_arg: number): bigint {
24884 if(!isWasmInitialized) {
24885 throw new Error("initializeWasm() must be awaited first!");
24887 const nativeResponseValue = wasm.TS_AnnouncementSignatures_new(channel_id_arg, short_channel_id_arg, node_signature_arg, bitcoin_signature_arg);
24888 return nativeResponseValue;
24890 // uint64_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg);
24892 export function AnnouncementSignatures_clone_ptr(arg: bigint): bigint {
24893 if(!isWasmInitialized) {
24894 throw new Error("initializeWasm() must be awaited first!");
24896 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone_ptr(arg);
24897 return nativeResponseValue;
24899 // struct LDKAnnouncementSignatures AnnouncementSignatures_clone(const struct LDKAnnouncementSignatures *NONNULL_PTR orig);
24901 export function AnnouncementSignatures_clone(orig: bigint): bigint {
24902 if(!isWasmInitialized) {
24903 throw new Error("initializeWasm() must be awaited first!");
24905 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone(orig);
24906 return nativeResponseValue;
24908 // bool AnnouncementSignatures_eq(const struct LDKAnnouncementSignatures *NONNULL_PTR a, const struct LDKAnnouncementSignatures *NONNULL_PTR b);
24910 export function AnnouncementSignatures_eq(a: bigint, b: bigint): boolean {
24911 if(!isWasmInitialized) {
24912 throw new Error("initializeWasm() must be awaited first!");
24914 const nativeResponseValue = wasm.TS_AnnouncementSignatures_eq(a, b);
24915 return nativeResponseValue;
24917 // void NetAddress_free(struct LDKNetAddress this_ptr);
24919 export function NetAddress_free(this_ptr: bigint): void {
24920 if(!isWasmInitialized) {
24921 throw new Error("initializeWasm() must be awaited first!");
24923 const nativeResponseValue = wasm.TS_NetAddress_free(this_ptr);
24924 // debug statements here
24926 // uint64_t NetAddress_clone_ptr(LDKNetAddress *NONNULL_PTR arg);
24928 export function NetAddress_clone_ptr(arg: bigint): bigint {
24929 if(!isWasmInitialized) {
24930 throw new Error("initializeWasm() must be awaited first!");
24932 const nativeResponseValue = wasm.TS_NetAddress_clone_ptr(arg);
24933 return nativeResponseValue;
24935 // struct LDKNetAddress NetAddress_clone(const struct LDKNetAddress *NONNULL_PTR orig);
24937 export function NetAddress_clone(orig: bigint): bigint {
24938 if(!isWasmInitialized) {
24939 throw new Error("initializeWasm() must be awaited first!");
24941 const nativeResponseValue = wasm.TS_NetAddress_clone(orig);
24942 return nativeResponseValue;
24944 // struct LDKNetAddress NetAddress_ipv4(struct LDKFourBytes addr, uint16_t port);
24946 export function NetAddress_ipv4(addr: number, port: number): bigint {
24947 if(!isWasmInitialized) {
24948 throw new Error("initializeWasm() must be awaited first!");
24950 const nativeResponseValue = wasm.TS_NetAddress_ipv4(addr, port);
24951 return nativeResponseValue;
24953 // struct LDKNetAddress NetAddress_ipv6(struct LDKSixteenBytes addr, uint16_t port);
24955 export function NetAddress_ipv6(addr: number, port: number): bigint {
24956 if(!isWasmInitialized) {
24957 throw new Error("initializeWasm() must be awaited first!");
24959 const nativeResponseValue = wasm.TS_NetAddress_ipv6(addr, port);
24960 return nativeResponseValue;
24962 // struct LDKNetAddress NetAddress_onion_v2(struct LDKTwelveBytes a);
24964 export function NetAddress_onion_v2(a: number): bigint {
24965 if(!isWasmInitialized) {
24966 throw new Error("initializeWasm() must be awaited first!");
24968 const nativeResponseValue = wasm.TS_NetAddress_onion_v2(a);
24969 return nativeResponseValue;
24971 // struct LDKNetAddress NetAddress_onion_v3(struct LDKThirtyTwoBytes ed25519_pubkey, uint16_t checksum, uint8_t version, uint16_t port);
24973 export function NetAddress_onion_v3(ed25519_pubkey: number, checksum: number, version: number, port: number): bigint {
24974 if(!isWasmInitialized) {
24975 throw new Error("initializeWasm() must be awaited first!");
24977 const nativeResponseValue = wasm.TS_NetAddress_onion_v3(ed25519_pubkey, checksum, version, port);
24978 return nativeResponseValue;
24980 // struct LDKNetAddress NetAddress_hostname(struct LDKHostname hostname, uint16_t port);
24982 export function NetAddress_hostname(hostname: bigint, port: number): bigint {
24983 if(!isWasmInitialized) {
24984 throw new Error("initializeWasm() must be awaited first!");
24986 const nativeResponseValue = wasm.TS_NetAddress_hostname(hostname, port);
24987 return nativeResponseValue;
24989 // bool NetAddress_eq(const struct LDKNetAddress *NONNULL_PTR a, const struct LDKNetAddress *NONNULL_PTR b);
24991 export function NetAddress_eq(a: bigint, b: bigint): boolean {
24992 if(!isWasmInitialized) {
24993 throw new Error("initializeWasm() must be awaited first!");
24995 const nativeResponseValue = wasm.TS_NetAddress_eq(a, b);
24996 return nativeResponseValue;
24998 // struct LDKCVec_u8Z NetAddress_write(const struct LDKNetAddress *NONNULL_PTR obj);
25000 export function NetAddress_write(obj: bigint): number {
25001 if(!isWasmInitialized) {
25002 throw new Error("initializeWasm() must be awaited first!");
25004 const nativeResponseValue = wasm.TS_NetAddress_write(obj);
25005 return nativeResponseValue;
25007 // struct LDKCResult_NetAddressDecodeErrorZ NetAddress_read(struct LDKu8slice ser);
25009 export function NetAddress_read(ser: number): bigint {
25010 if(!isWasmInitialized) {
25011 throw new Error("initializeWasm() must be awaited first!");
25013 const nativeResponseValue = wasm.TS_NetAddress_read(ser);
25014 return nativeResponseValue;
25016 // void UnsignedNodeAnnouncement_free(struct LDKUnsignedNodeAnnouncement this_obj);
25018 export function UnsignedNodeAnnouncement_free(this_obj: bigint): void {
25019 if(!isWasmInitialized) {
25020 throw new Error("initializeWasm() must be awaited first!");
25022 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_free(this_obj);
25023 // debug statements here
25025 // struct LDKNodeFeatures UnsignedNodeAnnouncement_get_features(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
25027 export function UnsignedNodeAnnouncement_get_features(this_ptr: bigint): bigint {
25028 if(!isWasmInitialized) {
25029 throw new Error("initializeWasm() must be awaited first!");
25031 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_features(this_ptr);
25032 return nativeResponseValue;
25034 // void UnsignedNodeAnnouncement_set_features(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
25036 export function UnsignedNodeAnnouncement_set_features(this_ptr: bigint, val: bigint): void {
25037 if(!isWasmInitialized) {
25038 throw new Error("initializeWasm() must be awaited first!");
25040 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_features(this_ptr, val);
25041 // debug statements here
25043 // uint32_t UnsignedNodeAnnouncement_get_timestamp(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
25045 export function UnsignedNodeAnnouncement_get_timestamp(this_ptr: bigint): number {
25046 if(!isWasmInitialized) {
25047 throw new Error("initializeWasm() must be awaited first!");
25049 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_timestamp(this_ptr);
25050 return nativeResponseValue;
25052 // void UnsignedNodeAnnouncement_set_timestamp(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, uint32_t val);
25054 export function UnsignedNodeAnnouncement_set_timestamp(this_ptr: bigint, val: number): void {
25055 if(!isWasmInitialized) {
25056 throw new Error("initializeWasm() must be awaited first!");
25058 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_timestamp(this_ptr, val);
25059 // debug statements here
25061 // struct LDKPublicKey UnsignedNodeAnnouncement_get_node_id(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
25063 export function UnsignedNodeAnnouncement_get_node_id(this_ptr: bigint): number {
25064 if(!isWasmInitialized) {
25065 throw new Error("initializeWasm() must be awaited first!");
25067 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_node_id(this_ptr);
25068 return nativeResponseValue;
25070 // void UnsignedNodeAnnouncement_set_node_id(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25072 export function UnsignedNodeAnnouncement_set_node_id(this_ptr: bigint, val: number): void {
25073 if(!isWasmInitialized) {
25074 throw new Error("initializeWasm() must be awaited first!");
25076 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_node_id(this_ptr, val);
25077 // debug statements here
25079 // const uint8_t (*UnsignedNodeAnnouncement_get_rgb(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[3];
25081 export function UnsignedNodeAnnouncement_get_rgb(this_ptr: bigint): number {
25082 if(!isWasmInitialized) {
25083 throw new Error("initializeWasm() must be awaited first!");
25085 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_rgb(this_ptr);
25086 return nativeResponseValue;
25088 // void UnsignedNodeAnnouncement_set_rgb(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
25090 export function UnsignedNodeAnnouncement_set_rgb(this_ptr: bigint, val: number): void {
25091 if(!isWasmInitialized) {
25092 throw new Error("initializeWasm() must be awaited first!");
25094 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_rgb(this_ptr, val);
25095 // debug statements here
25097 // const uint8_t (*UnsignedNodeAnnouncement_get_alias(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[32];
25099 export function UnsignedNodeAnnouncement_get_alias(this_ptr: bigint): number {
25100 if(!isWasmInitialized) {
25101 throw new Error("initializeWasm() must be awaited first!");
25103 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_alias(this_ptr);
25104 return nativeResponseValue;
25106 // void UnsignedNodeAnnouncement_set_alias(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25108 export function UnsignedNodeAnnouncement_set_alias(this_ptr: bigint, val: number): void {
25109 if(!isWasmInitialized) {
25110 throw new Error("initializeWasm() must be awaited first!");
25112 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_alias(this_ptr, val);
25113 // debug statements here
25115 // struct LDKCVec_NetAddressZ UnsignedNodeAnnouncement_get_addresses(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
25117 export function UnsignedNodeAnnouncement_get_addresses(this_ptr: bigint): number {
25118 if(!isWasmInitialized) {
25119 throw new Error("initializeWasm() must be awaited first!");
25121 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_addresses(this_ptr);
25122 return nativeResponseValue;
25124 // void UnsignedNodeAnnouncement_set_addresses(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
25126 export function UnsignedNodeAnnouncement_set_addresses(this_ptr: bigint, val: number): void {
25127 if(!isWasmInitialized) {
25128 throw new Error("initializeWasm() must be awaited first!");
25130 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_addresses(this_ptr, val);
25131 // debug statements here
25133 // uint64_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg);
25135 export function UnsignedNodeAnnouncement_clone_ptr(arg: bigint): bigint {
25136 if(!isWasmInitialized) {
25137 throw new Error("initializeWasm() must be awaited first!");
25139 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone_ptr(arg);
25140 return nativeResponseValue;
25142 // struct LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_clone(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR orig);
25144 export function UnsignedNodeAnnouncement_clone(orig: bigint): bigint {
25145 if(!isWasmInitialized) {
25146 throw new Error("initializeWasm() must be awaited first!");
25148 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone(orig);
25149 return nativeResponseValue;
25151 // bool UnsignedNodeAnnouncement_eq(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR a, const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR b);
25153 export function UnsignedNodeAnnouncement_eq(a: bigint, b: bigint): boolean {
25154 if(!isWasmInitialized) {
25155 throw new Error("initializeWasm() must be awaited first!");
25157 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_eq(a, b);
25158 return nativeResponseValue;
25160 // void NodeAnnouncement_free(struct LDKNodeAnnouncement this_obj);
25162 export function NodeAnnouncement_free(this_obj: bigint): void {
25163 if(!isWasmInitialized) {
25164 throw new Error("initializeWasm() must be awaited first!");
25166 const nativeResponseValue = wasm.TS_NodeAnnouncement_free(this_obj);
25167 // debug statements here
25169 // struct LDKSignature NodeAnnouncement_get_signature(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
25171 export function NodeAnnouncement_get_signature(this_ptr: bigint): number {
25172 if(!isWasmInitialized) {
25173 throw new Error("initializeWasm() must be awaited first!");
25175 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_signature(this_ptr);
25176 return nativeResponseValue;
25178 // void NodeAnnouncement_set_signature(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
25180 export function NodeAnnouncement_set_signature(this_ptr: bigint, val: number): void {
25181 if(!isWasmInitialized) {
25182 throw new Error("initializeWasm() must be awaited first!");
25184 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_signature(this_ptr, val);
25185 // debug statements here
25187 // struct LDKUnsignedNodeAnnouncement NodeAnnouncement_get_contents(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
25189 export function NodeAnnouncement_get_contents(this_ptr: bigint): bigint {
25190 if(!isWasmInitialized) {
25191 throw new Error("initializeWasm() must be awaited first!");
25193 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_contents(this_ptr);
25194 return nativeResponseValue;
25196 // void NodeAnnouncement_set_contents(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedNodeAnnouncement val);
25198 export function NodeAnnouncement_set_contents(this_ptr: bigint, val: bigint): void {
25199 if(!isWasmInitialized) {
25200 throw new Error("initializeWasm() must be awaited first!");
25202 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_contents(this_ptr, val);
25203 // debug statements here
25205 // MUST_USE_RES struct LDKNodeAnnouncement NodeAnnouncement_new(struct LDKSignature signature_arg, struct LDKUnsignedNodeAnnouncement contents_arg);
25207 export function NodeAnnouncement_new(signature_arg: number, contents_arg: bigint): bigint {
25208 if(!isWasmInitialized) {
25209 throw new Error("initializeWasm() must be awaited first!");
25211 const nativeResponseValue = wasm.TS_NodeAnnouncement_new(signature_arg, contents_arg);
25212 return nativeResponseValue;
25214 // uint64_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg);
25216 export function NodeAnnouncement_clone_ptr(arg: bigint): bigint {
25217 if(!isWasmInitialized) {
25218 throw new Error("initializeWasm() must be awaited first!");
25220 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone_ptr(arg);
25221 return nativeResponseValue;
25223 // struct LDKNodeAnnouncement NodeAnnouncement_clone(const struct LDKNodeAnnouncement *NONNULL_PTR orig);
25225 export function NodeAnnouncement_clone(orig: bigint): bigint {
25226 if(!isWasmInitialized) {
25227 throw new Error("initializeWasm() must be awaited first!");
25229 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone(orig);
25230 return nativeResponseValue;
25232 // bool NodeAnnouncement_eq(const struct LDKNodeAnnouncement *NONNULL_PTR a, const struct LDKNodeAnnouncement *NONNULL_PTR b);
25234 export function NodeAnnouncement_eq(a: bigint, b: bigint): boolean {
25235 if(!isWasmInitialized) {
25236 throw new Error("initializeWasm() must be awaited first!");
25238 const nativeResponseValue = wasm.TS_NodeAnnouncement_eq(a, b);
25239 return nativeResponseValue;
25241 // void UnsignedChannelAnnouncement_free(struct LDKUnsignedChannelAnnouncement this_obj);
25243 export function UnsignedChannelAnnouncement_free(this_obj: bigint): void {
25244 if(!isWasmInitialized) {
25245 throw new Error("initializeWasm() must be awaited first!");
25247 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_free(this_obj);
25248 // debug statements here
25250 // struct LDKChannelFeatures UnsignedChannelAnnouncement_get_features(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
25252 export function UnsignedChannelAnnouncement_get_features(this_ptr: bigint): bigint {
25253 if(!isWasmInitialized) {
25254 throw new Error("initializeWasm() must be awaited first!");
25256 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_features(this_ptr);
25257 return nativeResponseValue;
25259 // void UnsignedChannelAnnouncement_set_features(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
25261 export function UnsignedChannelAnnouncement_set_features(this_ptr: bigint, val: bigint): void {
25262 if(!isWasmInitialized) {
25263 throw new Error("initializeWasm() must be awaited first!");
25265 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_features(this_ptr, val);
25266 // debug statements here
25268 // const uint8_t (*UnsignedChannelAnnouncement_get_chain_hash(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr))[32];
25270 export function UnsignedChannelAnnouncement_get_chain_hash(this_ptr: bigint): number {
25271 if(!isWasmInitialized) {
25272 throw new Error("initializeWasm() must be awaited first!");
25274 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_chain_hash(this_ptr);
25275 return nativeResponseValue;
25277 // void UnsignedChannelAnnouncement_set_chain_hash(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25279 export function UnsignedChannelAnnouncement_set_chain_hash(this_ptr: bigint, val: number): void {
25280 if(!isWasmInitialized) {
25281 throw new Error("initializeWasm() must be awaited first!");
25283 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_chain_hash(this_ptr, val);
25284 // debug statements here
25286 // uint64_t UnsignedChannelAnnouncement_get_short_channel_id(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
25288 export function UnsignedChannelAnnouncement_get_short_channel_id(this_ptr: bigint): bigint {
25289 if(!isWasmInitialized) {
25290 throw new Error("initializeWasm() must be awaited first!");
25292 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_short_channel_id(this_ptr);
25293 return nativeResponseValue;
25295 // void UnsignedChannelAnnouncement_set_short_channel_id(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, uint64_t val);
25297 export function UnsignedChannelAnnouncement_set_short_channel_id(this_ptr: bigint, val: bigint): void {
25298 if(!isWasmInitialized) {
25299 throw new Error("initializeWasm() must be awaited first!");
25301 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_short_channel_id(this_ptr, val);
25302 // debug statements here
25304 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
25306 export function UnsignedChannelAnnouncement_get_node_id_1(this_ptr: bigint): number {
25307 if(!isWasmInitialized) {
25308 throw new Error("initializeWasm() must be awaited first!");
25310 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_1(this_ptr);
25311 return nativeResponseValue;
25313 // void UnsignedChannelAnnouncement_set_node_id_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25315 export function UnsignedChannelAnnouncement_set_node_id_1(this_ptr: bigint, val: number): void {
25316 if(!isWasmInitialized) {
25317 throw new Error("initializeWasm() must be awaited first!");
25319 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_1(this_ptr, val);
25320 // debug statements here
25322 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
25324 export function UnsignedChannelAnnouncement_get_node_id_2(this_ptr: bigint): number {
25325 if(!isWasmInitialized) {
25326 throw new Error("initializeWasm() must be awaited first!");
25328 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_2(this_ptr);
25329 return nativeResponseValue;
25331 // void UnsignedChannelAnnouncement_set_node_id_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25333 export function UnsignedChannelAnnouncement_set_node_id_2(this_ptr: bigint, val: number): void {
25334 if(!isWasmInitialized) {
25335 throw new Error("initializeWasm() must be awaited first!");
25337 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_2(this_ptr, val);
25338 // debug statements here
25340 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
25342 export function UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr: bigint): number {
25343 if(!isWasmInitialized) {
25344 throw new Error("initializeWasm() must be awaited first!");
25346 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr);
25347 return nativeResponseValue;
25349 // void UnsignedChannelAnnouncement_set_bitcoin_key_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25351 export function UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr: bigint, val: number): void {
25352 if(!isWasmInitialized) {
25353 throw new Error("initializeWasm() must be awaited first!");
25355 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr, val);
25356 // debug statements here
25358 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
25360 export function UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr: bigint): number {
25361 if(!isWasmInitialized) {
25362 throw new Error("initializeWasm() must be awaited first!");
25364 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr);
25365 return nativeResponseValue;
25367 // void UnsignedChannelAnnouncement_set_bitcoin_key_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25369 export function UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr: bigint, val: number): void {
25370 if(!isWasmInitialized) {
25371 throw new Error("initializeWasm() must be awaited first!");
25373 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr, val);
25374 // debug statements here
25376 // uint64_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg);
25378 export function UnsignedChannelAnnouncement_clone_ptr(arg: bigint): bigint {
25379 if(!isWasmInitialized) {
25380 throw new Error("initializeWasm() must be awaited first!");
25382 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone_ptr(arg);
25383 return nativeResponseValue;
25385 // struct LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_clone(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR orig);
25387 export function UnsignedChannelAnnouncement_clone(orig: bigint): bigint {
25388 if(!isWasmInitialized) {
25389 throw new Error("initializeWasm() must be awaited first!");
25391 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone(orig);
25392 return nativeResponseValue;
25394 // bool UnsignedChannelAnnouncement_eq(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR a, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR b);
25396 export function UnsignedChannelAnnouncement_eq(a: bigint, b: bigint): boolean {
25397 if(!isWasmInitialized) {
25398 throw new Error("initializeWasm() must be awaited first!");
25400 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_eq(a, b);
25401 return nativeResponseValue;
25403 // void ChannelAnnouncement_free(struct LDKChannelAnnouncement this_obj);
25405 export function ChannelAnnouncement_free(this_obj: bigint): void {
25406 if(!isWasmInitialized) {
25407 throw new Error("initializeWasm() must be awaited first!");
25409 const nativeResponseValue = wasm.TS_ChannelAnnouncement_free(this_obj);
25410 // debug statements here
25412 // struct LDKSignature ChannelAnnouncement_get_node_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
25414 export function ChannelAnnouncement_get_node_signature_1(this_ptr: bigint): number {
25415 if(!isWasmInitialized) {
25416 throw new Error("initializeWasm() must be awaited first!");
25418 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_1(this_ptr);
25419 return nativeResponseValue;
25421 // void ChannelAnnouncement_set_node_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
25423 export function ChannelAnnouncement_set_node_signature_1(this_ptr: bigint, val: number): void {
25424 if(!isWasmInitialized) {
25425 throw new Error("initializeWasm() must be awaited first!");
25427 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_1(this_ptr, val);
25428 // debug statements here
25430 // struct LDKSignature ChannelAnnouncement_get_node_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
25432 export function ChannelAnnouncement_get_node_signature_2(this_ptr: bigint): number {
25433 if(!isWasmInitialized) {
25434 throw new Error("initializeWasm() must be awaited first!");
25436 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_2(this_ptr);
25437 return nativeResponseValue;
25439 // void ChannelAnnouncement_set_node_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
25441 export function ChannelAnnouncement_set_node_signature_2(this_ptr: bigint, val: number): void {
25442 if(!isWasmInitialized) {
25443 throw new Error("initializeWasm() must be awaited first!");
25445 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_2(this_ptr, val);
25446 // debug statements here
25448 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
25450 export function ChannelAnnouncement_get_bitcoin_signature_1(this_ptr: bigint): number {
25451 if(!isWasmInitialized) {
25452 throw new Error("initializeWasm() must be awaited first!");
25454 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_1(this_ptr);
25455 return nativeResponseValue;
25457 // void ChannelAnnouncement_set_bitcoin_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
25459 export function ChannelAnnouncement_set_bitcoin_signature_1(this_ptr: bigint, val: number): void {
25460 if(!isWasmInitialized) {
25461 throw new Error("initializeWasm() must be awaited first!");
25463 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_1(this_ptr, val);
25464 // debug statements here
25466 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
25468 export function ChannelAnnouncement_get_bitcoin_signature_2(this_ptr: bigint): number {
25469 if(!isWasmInitialized) {
25470 throw new Error("initializeWasm() must be awaited first!");
25472 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_2(this_ptr);
25473 return nativeResponseValue;
25475 // void ChannelAnnouncement_set_bitcoin_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
25477 export function ChannelAnnouncement_set_bitcoin_signature_2(this_ptr: bigint, val: number): void {
25478 if(!isWasmInitialized) {
25479 throw new Error("initializeWasm() must be awaited first!");
25481 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_2(this_ptr, val);
25482 // debug statements here
25484 // struct LDKUnsignedChannelAnnouncement ChannelAnnouncement_get_contents(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
25486 export function ChannelAnnouncement_get_contents(this_ptr: bigint): bigint {
25487 if(!isWasmInitialized) {
25488 throw new Error("initializeWasm() must be awaited first!");
25490 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_contents(this_ptr);
25491 return nativeResponseValue;
25493 // void ChannelAnnouncement_set_contents(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedChannelAnnouncement val);
25495 export function ChannelAnnouncement_set_contents(this_ptr: bigint, val: bigint): void {
25496 if(!isWasmInitialized) {
25497 throw new Error("initializeWasm() must be awaited first!");
25499 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_contents(this_ptr, val);
25500 // debug statements here
25502 // 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);
25504 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 {
25505 if(!isWasmInitialized) {
25506 throw new Error("initializeWasm() must be awaited first!");
25508 const nativeResponseValue = wasm.TS_ChannelAnnouncement_new(node_signature_1_arg, node_signature_2_arg, bitcoin_signature_1_arg, bitcoin_signature_2_arg, contents_arg);
25509 return nativeResponseValue;
25511 // uint64_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg);
25513 export function ChannelAnnouncement_clone_ptr(arg: bigint): bigint {
25514 if(!isWasmInitialized) {
25515 throw new Error("initializeWasm() must be awaited first!");
25517 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone_ptr(arg);
25518 return nativeResponseValue;
25520 // struct LDKChannelAnnouncement ChannelAnnouncement_clone(const struct LDKChannelAnnouncement *NONNULL_PTR orig);
25522 export function ChannelAnnouncement_clone(orig: bigint): bigint {
25523 if(!isWasmInitialized) {
25524 throw new Error("initializeWasm() must be awaited first!");
25526 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone(orig);
25527 return nativeResponseValue;
25529 // bool ChannelAnnouncement_eq(const struct LDKChannelAnnouncement *NONNULL_PTR a, const struct LDKChannelAnnouncement *NONNULL_PTR b);
25531 export function ChannelAnnouncement_eq(a: bigint, b: bigint): boolean {
25532 if(!isWasmInitialized) {
25533 throw new Error("initializeWasm() must be awaited first!");
25535 const nativeResponseValue = wasm.TS_ChannelAnnouncement_eq(a, b);
25536 return nativeResponseValue;
25538 // void UnsignedChannelUpdate_free(struct LDKUnsignedChannelUpdate this_obj);
25540 export function UnsignedChannelUpdate_free(this_obj: bigint): void {
25541 if(!isWasmInitialized) {
25542 throw new Error("initializeWasm() must be awaited first!");
25544 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_free(this_obj);
25545 // debug statements here
25547 // const uint8_t (*UnsignedChannelUpdate_get_chain_hash(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr))[32];
25549 export function UnsignedChannelUpdate_get_chain_hash(this_ptr: bigint): number {
25550 if(!isWasmInitialized) {
25551 throw new Error("initializeWasm() must be awaited first!");
25553 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_chain_hash(this_ptr);
25554 return nativeResponseValue;
25556 // void UnsignedChannelUpdate_set_chain_hash(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25558 export function UnsignedChannelUpdate_set_chain_hash(this_ptr: bigint, val: number): void {
25559 if(!isWasmInitialized) {
25560 throw new Error("initializeWasm() must be awaited first!");
25562 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_chain_hash(this_ptr, val);
25563 // debug statements here
25565 // uint64_t UnsignedChannelUpdate_get_short_channel_id(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
25567 export function UnsignedChannelUpdate_get_short_channel_id(this_ptr: bigint): bigint {
25568 if(!isWasmInitialized) {
25569 throw new Error("initializeWasm() must be awaited first!");
25571 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_short_channel_id(this_ptr);
25572 return nativeResponseValue;
25574 // void UnsignedChannelUpdate_set_short_channel_id(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
25576 export function UnsignedChannelUpdate_set_short_channel_id(this_ptr: bigint, val: bigint): void {
25577 if(!isWasmInitialized) {
25578 throw new Error("initializeWasm() must be awaited first!");
25580 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_short_channel_id(this_ptr, val);
25581 // debug statements here
25583 // uint32_t UnsignedChannelUpdate_get_timestamp(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
25585 export function UnsignedChannelUpdate_get_timestamp(this_ptr: bigint): number {
25586 if(!isWasmInitialized) {
25587 throw new Error("initializeWasm() must be awaited first!");
25589 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_timestamp(this_ptr);
25590 return nativeResponseValue;
25592 // void UnsignedChannelUpdate_set_timestamp(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
25594 export function UnsignedChannelUpdate_set_timestamp(this_ptr: bigint, val: number): void {
25595 if(!isWasmInitialized) {
25596 throw new Error("initializeWasm() must be awaited first!");
25598 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_timestamp(this_ptr, val);
25599 // debug statements here
25601 // uint8_t UnsignedChannelUpdate_get_flags(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
25603 export function UnsignedChannelUpdate_get_flags(this_ptr: bigint): number {
25604 if(!isWasmInitialized) {
25605 throw new Error("initializeWasm() must be awaited first!");
25607 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_flags(this_ptr);
25608 return nativeResponseValue;
25610 // void UnsignedChannelUpdate_set_flags(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint8_t val);
25612 export function UnsignedChannelUpdate_set_flags(this_ptr: bigint, val: number): void {
25613 if(!isWasmInitialized) {
25614 throw new Error("initializeWasm() must be awaited first!");
25616 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_flags(this_ptr, val);
25617 // debug statements here
25619 // uint16_t UnsignedChannelUpdate_get_cltv_expiry_delta(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
25621 export function UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr: bigint): number {
25622 if(!isWasmInitialized) {
25623 throw new Error("initializeWasm() must be awaited first!");
25625 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr);
25626 return nativeResponseValue;
25628 // void UnsignedChannelUpdate_set_cltv_expiry_delta(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint16_t val);
25630 export function UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
25631 if(!isWasmInitialized) {
25632 throw new Error("initializeWasm() must be awaited first!");
25634 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr, val);
25635 // debug statements here
25637 // uint64_t UnsignedChannelUpdate_get_htlc_minimum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
25639 export function UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr: bigint): bigint {
25640 if(!isWasmInitialized) {
25641 throw new Error("initializeWasm() must be awaited first!");
25643 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr);
25644 return nativeResponseValue;
25646 // void UnsignedChannelUpdate_set_htlc_minimum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
25648 export function UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
25649 if(!isWasmInitialized) {
25650 throw new Error("initializeWasm() must be awaited first!");
25652 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr, val);
25653 // debug statements here
25655 // uint64_t UnsignedChannelUpdate_get_htlc_maximum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
25657 export function UnsignedChannelUpdate_get_htlc_maximum_msat(this_ptr: bigint): bigint {
25658 if(!isWasmInitialized) {
25659 throw new Error("initializeWasm() must be awaited first!");
25661 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_maximum_msat(this_ptr);
25662 return nativeResponseValue;
25664 // void UnsignedChannelUpdate_set_htlc_maximum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
25666 export function UnsignedChannelUpdate_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
25667 if(!isWasmInitialized) {
25668 throw new Error("initializeWasm() must be awaited first!");
25670 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_maximum_msat(this_ptr, val);
25671 // debug statements here
25673 // uint32_t UnsignedChannelUpdate_get_fee_base_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
25675 export function UnsignedChannelUpdate_get_fee_base_msat(this_ptr: bigint): number {
25676 if(!isWasmInitialized) {
25677 throw new Error("initializeWasm() must be awaited first!");
25679 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_base_msat(this_ptr);
25680 return nativeResponseValue;
25682 // void UnsignedChannelUpdate_set_fee_base_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
25684 export function UnsignedChannelUpdate_set_fee_base_msat(this_ptr: bigint, val: number): void {
25685 if(!isWasmInitialized) {
25686 throw new Error("initializeWasm() must be awaited first!");
25688 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_base_msat(this_ptr, val);
25689 // debug statements here
25691 // uint32_t UnsignedChannelUpdate_get_fee_proportional_millionths(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
25693 export function UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr: bigint): number {
25694 if(!isWasmInitialized) {
25695 throw new Error("initializeWasm() must be awaited first!");
25697 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr);
25698 return nativeResponseValue;
25700 // void UnsignedChannelUpdate_set_fee_proportional_millionths(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
25702 export function UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
25703 if(!isWasmInitialized) {
25704 throw new Error("initializeWasm() must be awaited first!");
25706 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr, val);
25707 // debug statements here
25709 // struct LDKCVec_u8Z UnsignedChannelUpdate_get_excess_data(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
25711 export function UnsignedChannelUpdate_get_excess_data(this_ptr: bigint): number {
25712 if(!isWasmInitialized) {
25713 throw new Error("initializeWasm() must be awaited first!");
25715 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_excess_data(this_ptr);
25716 return nativeResponseValue;
25718 // void UnsignedChannelUpdate_set_excess_data(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
25720 export function UnsignedChannelUpdate_set_excess_data(this_ptr: bigint, val: number): void {
25721 if(!isWasmInitialized) {
25722 throw new Error("initializeWasm() must be awaited first!");
25724 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_excess_data(this_ptr, val);
25725 // debug statements here
25727 // 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);
25729 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 {
25730 if(!isWasmInitialized) {
25731 throw new Error("initializeWasm() must be awaited first!");
25733 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);
25734 return nativeResponseValue;
25736 // uint64_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg);
25738 export function UnsignedChannelUpdate_clone_ptr(arg: bigint): bigint {
25739 if(!isWasmInitialized) {
25740 throw new Error("initializeWasm() must be awaited first!");
25742 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone_ptr(arg);
25743 return nativeResponseValue;
25745 // struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_clone(const struct LDKUnsignedChannelUpdate *NONNULL_PTR orig);
25747 export function UnsignedChannelUpdate_clone(orig: bigint): bigint {
25748 if(!isWasmInitialized) {
25749 throw new Error("initializeWasm() must be awaited first!");
25751 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone(orig);
25752 return nativeResponseValue;
25754 // bool UnsignedChannelUpdate_eq(const struct LDKUnsignedChannelUpdate *NONNULL_PTR a, const struct LDKUnsignedChannelUpdate *NONNULL_PTR b);
25756 export function UnsignedChannelUpdate_eq(a: bigint, b: bigint): boolean {
25757 if(!isWasmInitialized) {
25758 throw new Error("initializeWasm() must be awaited first!");
25760 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_eq(a, b);
25761 return nativeResponseValue;
25763 // void ChannelUpdate_free(struct LDKChannelUpdate this_obj);
25765 export function ChannelUpdate_free(this_obj: bigint): void {
25766 if(!isWasmInitialized) {
25767 throw new Error("initializeWasm() must be awaited first!");
25769 const nativeResponseValue = wasm.TS_ChannelUpdate_free(this_obj);
25770 // debug statements here
25772 // struct LDKSignature ChannelUpdate_get_signature(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
25774 export function ChannelUpdate_get_signature(this_ptr: bigint): number {
25775 if(!isWasmInitialized) {
25776 throw new Error("initializeWasm() must be awaited first!");
25778 const nativeResponseValue = wasm.TS_ChannelUpdate_get_signature(this_ptr);
25779 return nativeResponseValue;
25781 // void ChannelUpdate_set_signature(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKSignature val);
25783 export function ChannelUpdate_set_signature(this_ptr: bigint, val: number): void {
25784 if(!isWasmInitialized) {
25785 throw new Error("initializeWasm() must be awaited first!");
25787 const nativeResponseValue = wasm.TS_ChannelUpdate_set_signature(this_ptr, val);
25788 // debug statements here
25790 // struct LDKUnsignedChannelUpdate ChannelUpdate_get_contents(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
25792 export function ChannelUpdate_get_contents(this_ptr: bigint): bigint {
25793 if(!isWasmInitialized) {
25794 throw new Error("initializeWasm() must be awaited first!");
25796 const nativeResponseValue = wasm.TS_ChannelUpdate_get_contents(this_ptr);
25797 return nativeResponseValue;
25799 // void ChannelUpdate_set_contents(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKUnsignedChannelUpdate val);
25801 export function ChannelUpdate_set_contents(this_ptr: bigint, val: bigint): void {
25802 if(!isWasmInitialized) {
25803 throw new Error("initializeWasm() must be awaited first!");
25805 const nativeResponseValue = wasm.TS_ChannelUpdate_set_contents(this_ptr, val);
25806 // debug statements here
25808 // MUST_USE_RES struct LDKChannelUpdate ChannelUpdate_new(struct LDKSignature signature_arg, struct LDKUnsignedChannelUpdate contents_arg);
25810 export function ChannelUpdate_new(signature_arg: number, contents_arg: bigint): bigint {
25811 if(!isWasmInitialized) {
25812 throw new Error("initializeWasm() must be awaited first!");
25814 const nativeResponseValue = wasm.TS_ChannelUpdate_new(signature_arg, contents_arg);
25815 return nativeResponseValue;
25817 // uint64_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg);
25819 export function ChannelUpdate_clone_ptr(arg: bigint): bigint {
25820 if(!isWasmInitialized) {
25821 throw new Error("initializeWasm() must be awaited first!");
25823 const nativeResponseValue = wasm.TS_ChannelUpdate_clone_ptr(arg);
25824 return nativeResponseValue;
25826 // struct LDKChannelUpdate ChannelUpdate_clone(const struct LDKChannelUpdate *NONNULL_PTR orig);
25828 export function ChannelUpdate_clone(orig: bigint): bigint {
25829 if(!isWasmInitialized) {
25830 throw new Error("initializeWasm() must be awaited first!");
25832 const nativeResponseValue = wasm.TS_ChannelUpdate_clone(orig);
25833 return nativeResponseValue;
25835 // bool ChannelUpdate_eq(const struct LDKChannelUpdate *NONNULL_PTR a, const struct LDKChannelUpdate *NONNULL_PTR b);
25837 export function ChannelUpdate_eq(a: bigint, b: bigint): boolean {
25838 if(!isWasmInitialized) {
25839 throw new Error("initializeWasm() must be awaited first!");
25841 const nativeResponseValue = wasm.TS_ChannelUpdate_eq(a, b);
25842 return nativeResponseValue;
25844 // void QueryChannelRange_free(struct LDKQueryChannelRange this_obj);
25846 export function QueryChannelRange_free(this_obj: bigint): void {
25847 if(!isWasmInitialized) {
25848 throw new Error("initializeWasm() must be awaited first!");
25850 const nativeResponseValue = wasm.TS_QueryChannelRange_free(this_obj);
25851 // debug statements here
25853 // const uint8_t (*QueryChannelRange_get_chain_hash(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr))[32];
25855 export function QueryChannelRange_get_chain_hash(this_ptr: bigint): number {
25856 if(!isWasmInitialized) {
25857 throw new Error("initializeWasm() must be awaited first!");
25859 const nativeResponseValue = wasm.TS_QueryChannelRange_get_chain_hash(this_ptr);
25860 return nativeResponseValue;
25862 // void QueryChannelRange_set_chain_hash(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25864 export function QueryChannelRange_set_chain_hash(this_ptr: bigint, val: number): void {
25865 if(!isWasmInitialized) {
25866 throw new Error("initializeWasm() must be awaited first!");
25868 const nativeResponseValue = wasm.TS_QueryChannelRange_set_chain_hash(this_ptr, val);
25869 // debug statements here
25871 // uint32_t QueryChannelRange_get_first_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
25873 export function QueryChannelRange_get_first_blocknum(this_ptr: bigint): number {
25874 if(!isWasmInitialized) {
25875 throw new Error("initializeWasm() must be awaited first!");
25877 const nativeResponseValue = wasm.TS_QueryChannelRange_get_first_blocknum(this_ptr);
25878 return nativeResponseValue;
25880 // void QueryChannelRange_set_first_blocknum(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
25882 export function QueryChannelRange_set_first_blocknum(this_ptr: bigint, val: number): void {
25883 if(!isWasmInitialized) {
25884 throw new Error("initializeWasm() must be awaited first!");
25886 const nativeResponseValue = wasm.TS_QueryChannelRange_set_first_blocknum(this_ptr, val);
25887 // debug statements here
25889 // uint32_t QueryChannelRange_get_number_of_blocks(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
25891 export function QueryChannelRange_get_number_of_blocks(this_ptr: bigint): number {
25892 if(!isWasmInitialized) {
25893 throw new Error("initializeWasm() must be awaited first!");
25895 const nativeResponseValue = wasm.TS_QueryChannelRange_get_number_of_blocks(this_ptr);
25896 return nativeResponseValue;
25898 // void QueryChannelRange_set_number_of_blocks(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
25900 export function QueryChannelRange_set_number_of_blocks(this_ptr: bigint, val: number): void {
25901 if(!isWasmInitialized) {
25902 throw new Error("initializeWasm() must be awaited first!");
25904 const nativeResponseValue = wasm.TS_QueryChannelRange_set_number_of_blocks(this_ptr, val);
25905 // debug statements here
25907 // MUST_USE_RES struct LDKQueryChannelRange QueryChannelRange_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_blocknum_arg, uint32_t number_of_blocks_arg);
25909 export function QueryChannelRange_new(chain_hash_arg: number, first_blocknum_arg: number, number_of_blocks_arg: number): bigint {
25910 if(!isWasmInitialized) {
25911 throw new Error("initializeWasm() must be awaited first!");
25913 const nativeResponseValue = wasm.TS_QueryChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg);
25914 return nativeResponseValue;
25916 // uint64_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg);
25918 export function QueryChannelRange_clone_ptr(arg: bigint): bigint {
25919 if(!isWasmInitialized) {
25920 throw new Error("initializeWasm() must be awaited first!");
25922 const nativeResponseValue = wasm.TS_QueryChannelRange_clone_ptr(arg);
25923 return nativeResponseValue;
25925 // struct LDKQueryChannelRange QueryChannelRange_clone(const struct LDKQueryChannelRange *NONNULL_PTR orig);
25927 export function QueryChannelRange_clone(orig: bigint): bigint {
25928 if(!isWasmInitialized) {
25929 throw new Error("initializeWasm() must be awaited first!");
25931 const nativeResponseValue = wasm.TS_QueryChannelRange_clone(orig);
25932 return nativeResponseValue;
25934 // bool QueryChannelRange_eq(const struct LDKQueryChannelRange *NONNULL_PTR a, const struct LDKQueryChannelRange *NONNULL_PTR b);
25936 export function QueryChannelRange_eq(a: bigint, b: bigint): boolean {
25937 if(!isWasmInitialized) {
25938 throw new Error("initializeWasm() must be awaited first!");
25940 const nativeResponseValue = wasm.TS_QueryChannelRange_eq(a, b);
25941 return nativeResponseValue;
25943 // void ReplyChannelRange_free(struct LDKReplyChannelRange this_obj);
25945 export function ReplyChannelRange_free(this_obj: bigint): void {
25946 if(!isWasmInitialized) {
25947 throw new Error("initializeWasm() must be awaited first!");
25949 const nativeResponseValue = wasm.TS_ReplyChannelRange_free(this_obj);
25950 // debug statements here
25952 // const uint8_t (*ReplyChannelRange_get_chain_hash(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr))[32];
25954 export function ReplyChannelRange_get_chain_hash(this_ptr: bigint): number {
25955 if(!isWasmInitialized) {
25956 throw new Error("initializeWasm() must be awaited first!");
25958 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_chain_hash(this_ptr);
25959 return nativeResponseValue;
25961 // void ReplyChannelRange_set_chain_hash(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25963 export function ReplyChannelRange_set_chain_hash(this_ptr: bigint, val: number): void {
25964 if(!isWasmInitialized) {
25965 throw new Error("initializeWasm() must be awaited first!");
25967 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_chain_hash(this_ptr, val);
25968 // debug statements here
25970 // uint32_t ReplyChannelRange_get_first_blocknum(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
25972 export function ReplyChannelRange_get_first_blocknum(this_ptr: bigint): number {
25973 if(!isWasmInitialized) {
25974 throw new Error("initializeWasm() must be awaited first!");
25976 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_first_blocknum(this_ptr);
25977 return nativeResponseValue;
25979 // void ReplyChannelRange_set_first_blocknum(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
25981 export function ReplyChannelRange_set_first_blocknum(this_ptr: bigint, val: number): void {
25982 if(!isWasmInitialized) {
25983 throw new Error("initializeWasm() must be awaited first!");
25985 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_first_blocknum(this_ptr, val);
25986 // debug statements here
25988 // uint32_t ReplyChannelRange_get_number_of_blocks(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
25990 export function ReplyChannelRange_get_number_of_blocks(this_ptr: bigint): number {
25991 if(!isWasmInitialized) {
25992 throw new Error("initializeWasm() must be awaited first!");
25994 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_number_of_blocks(this_ptr);
25995 return nativeResponseValue;
25997 // void ReplyChannelRange_set_number_of_blocks(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
25999 export function ReplyChannelRange_set_number_of_blocks(this_ptr: bigint, val: number): void {
26000 if(!isWasmInitialized) {
26001 throw new Error("initializeWasm() must be awaited first!");
26003 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_number_of_blocks(this_ptr, val);
26004 // debug statements here
26006 // bool ReplyChannelRange_get_sync_complete(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
26008 export function ReplyChannelRange_get_sync_complete(this_ptr: bigint): boolean {
26009 if(!isWasmInitialized) {
26010 throw new Error("initializeWasm() must be awaited first!");
26012 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_sync_complete(this_ptr);
26013 return nativeResponseValue;
26015 // void ReplyChannelRange_set_sync_complete(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, bool val);
26017 export function ReplyChannelRange_set_sync_complete(this_ptr: bigint, val: boolean): void {
26018 if(!isWasmInitialized) {
26019 throw new Error("initializeWasm() must be awaited first!");
26021 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_sync_complete(this_ptr, val);
26022 // debug statements here
26024 // struct LDKCVec_u64Z ReplyChannelRange_get_short_channel_ids(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
26026 export function ReplyChannelRange_get_short_channel_ids(this_ptr: bigint): number {
26027 if(!isWasmInitialized) {
26028 throw new Error("initializeWasm() must be awaited first!");
26030 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_short_channel_ids(this_ptr);
26031 return nativeResponseValue;
26033 // void ReplyChannelRange_set_short_channel_ids(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
26035 export function ReplyChannelRange_set_short_channel_ids(this_ptr: bigint, val: number): void {
26036 if(!isWasmInitialized) {
26037 throw new Error("initializeWasm() must be awaited first!");
26039 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_short_channel_ids(this_ptr, val);
26040 // debug statements here
26042 // 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);
26044 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 {
26045 if(!isWasmInitialized) {
26046 throw new Error("initializeWasm() must be awaited first!");
26048 const nativeResponseValue = wasm.TS_ReplyChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg);
26049 return nativeResponseValue;
26051 // uint64_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg);
26053 export function ReplyChannelRange_clone_ptr(arg: bigint): bigint {
26054 if(!isWasmInitialized) {
26055 throw new Error("initializeWasm() must be awaited first!");
26057 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone_ptr(arg);
26058 return nativeResponseValue;
26060 // struct LDKReplyChannelRange ReplyChannelRange_clone(const struct LDKReplyChannelRange *NONNULL_PTR orig);
26062 export function ReplyChannelRange_clone(orig: bigint): bigint {
26063 if(!isWasmInitialized) {
26064 throw new Error("initializeWasm() must be awaited first!");
26066 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone(orig);
26067 return nativeResponseValue;
26069 // bool ReplyChannelRange_eq(const struct LDKReplyChannelRange *NONNULL_PTR a, const struct LDKReplyChannelRange *NONNULL_PTR b);
26071 export function ReplyChannelRange_eq(a: bigint, b: bigint): boolean {
26072 if(!isWasmInitialized) {
26073 throw new Error("initializeWasm() must be awaited first!");
26075 const nativeResponseValue = wasm.TS_ReplyChannelRange_eq(a, b);
26076 return nativeResponseValue;
26078 // void QueryShortChannelIds_free(struct LDKQueryShortChannelIds this_obj);
26080 export function QueryShortChannelIds_free(this_obj: bigint): void {
26081 if(!isWasmInitialized) {
26082 throw new Error("initializeWasm() must be awaited first!");
26084 const nativeResponseValue = wasm.TS_QueryShortChannelIds_free(this_obj);
26085 // debug statements here
26087 // const uint8_t (*QueryShortChannelIds_get_chain_hash(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr))[32];
26089 export function QueryShortChannelIds_get_chain_hash(this_ptr: bigint): number {
26090 if(!isWasmInitialized) {
26091 throw new Error("initializeWasm() must be awaited first!");
26093 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_chain_hash(this_ptr);
26094 return nativeResponseValue;
26096 // void QueryShortChannelIds_set_chain_hash(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26098 export function QueryShortChannelIds_set_chain_hash(this_ptr: bigint, val: number): void {
26099 if(!isWasmInitialized) {
26100 throw new Error("initializeWasm() must be awaited first!");
26102 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_chain_hash(this_ptr, val);
26103 // debug statements here
26105 // struct LDKCVec_u64Z QueryShortChannelIds_get_short_channel_ids(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr);
26107 export function QueryShortChannelIds_get_short_channel_ids(this_ptr: bigint): number {
26108 if(!isWasmInitialized) {
26109 throw new Error("initializeWasm() must be awaited first!");
26111 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_short_channel_ids(this_ptr);
26112 return nativeResponseValue;
26114 // void QueryShortChannelIds_set_short_channel_ids(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
26116 export function QueryShortChannelIds_set_short_channel_ids(this_ptr: bigint, val: number): void {
26117 if(!isWasmInitialized) {
26118 throw new Error("initializeWasm() must be awaited first!");
26120 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_short_channel_ids(this_ptr, val);
26121 // debug statements here
26123 // MUST_USE_RES struct LDKQueryShortChannelIds QueryShortChannelIds_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKCVec_u64Z short_channel_ids_arg);
26125 export function QueryShortChannelIds_new(chain_hash_arg: number, short_channel_ids_arg: number): bigint {
26126 if(!isWasmInitialized) {
26127 throw new Error("initializeWasm() must be awaited first!");
26129 const nativeResponseValue = wasm.TS_QueryShortChannelIds_new(chain_hash_arg, short_channel_ids_arg);
26130 return nativeResponseValue;
26132 // uint64_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg);
26134 export function QueryShortChannelIds_clone_ptr(arg: bigint): bigint {
26135 if(!isWasmInitialized) {
26136 throw new Error("initializeWasm() must be awaited first!");
26138 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone_ptr(arg);
26139 return nativeResponseValue;
26141 // struct LDKQueryShortChannelIds QueryShortChannelIds_clone(const struct LDKQueryShortChannelIds *NONNULL_PTR orig);
26143 export function QueryShortChannelIds_clone(orig: bigint): bigint {
26144 if(!isWasmInitialized) {
26145 throw new Error("initializeWasm() must be awaited first!");
26147 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone(orig);
26148 return nativeResponseValue;
26150 // bool QueryShortChannelIds_eq(const struct LDKQueryShortChannelIds *NONNULL_PTR a, const struct LDKQueryShortChannelIds *NONNULL_PTR b);
26152 export function QueryShortChannelIds_eq(a: bigint, b: bigint): boolean {
26153 if(!isWasmInitialized) {
26154 throw new Error("initializeWasm() must be awaited first!");
26156 const nativeResponseValue = wasm.TS_QueryShortChannelIds_eq(a, b);
26157 return nativeResponseValue;
26159 // void ReplyShortChannelIdsEnd_free(struct LDKReplyShortChannelIdsEnd this_obj);
26161 export function ReplyShortChannelIdsEnd_free(this_obj: bigint): void {
26162 if(!isWasmInitialized) {
26163 throw new Error("initializeWasm() must be awaited first!");
26165 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_free(this_obj);
26166 // debug statements here
26168 // const uint8_t (*ReplyShortChannelIdsEnd_get_chain_hash(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr))[32];
26170 export function ReplyShortChannelIdsEnd_get_chain_hash(this_ptr: bigint): number {
26171 if(!isWasmInitialized) {
26172 throw new Error("initializeWasm() must be awaited first!");
26174 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_chain_hash(this_ptr);
26175 return nativeResponseValue;
26177 // void ReplyShortChannelIdsEnd_set_chain_hash(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26179 export function ReplyShortChannelIdsEnd_set_chain_hash(this_ptr: bigint, val: number): void {
26180 if(!isWasmInitialized) {
26181 throw new Error("initializeWasm() must be awaited first!");
26183 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_chain_hash(this_ptr, val);
26184 // debug statements here
26186 // bool ReplyShortChannelIdsEnd_get_full_information(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr);
26188 export function ReplyShortChannelIdsEnd_get_full_information(this_ptr: bigint): boolean {
26189 if(!isWasmInitialized) {
26190 throw new Error("initializeWasm() must be awaited first!");
26192 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_full_information(this_ptr);
26193 return nativeResponseValue;
26195 // void ReplyShortChannelIdsEnd_set_full_information(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, bool val);
26197 export function ReplyShortChannelIdsEnd_set_full_information(this_ptr: bigint, val: boolean): void {
26198 if(!isWasmInitialized) {
26199 throw new Error("initializeWasm() must be awaited first!");
26201 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_full_information(this_ptr, val);
26202 // debug statements here
26204 // MUST_USE_RES struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_new(struct LDKThirtyTwoBytes chain_hash_arg, bool full_information_arg);
26206 export function ReplyShortChannelIdsEnd_new(chain_hash_arg: number, full_information_arg: boolean): bigint {
26207 if(!isWasmInitialized) {
26208 throw new Error("initializeWasm() must be awaited first!");
26210 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_new(chain_hash_arg, full_information_arg);
26211 return nativeResponseValue;
26213 // uint64_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg);
26215 export function ReplyShortChannelIdsEnd_clone_ptr(arg: bigint): bigint {
26216 if(!isWasmInitialized) {
26217 throw new Error("initializeWasm() must be awaited first!");
26219 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone_ptr(arg);
26220 return nativeResponseValue;
26222 // struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_clone(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR orig);
26224 export function ReplyShortChannelIdsEnd_clone(orig: bigint): bigint {
26225 if(!isWasmInitialized) {
26226 throw new Error("initializeWasm() must be awaited first!");
26228 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone(orig);
26229 return nativeResponseValue;
26231 // bool ReplyShortChannelIdsEnd_eq(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR a, const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR b);
26233 export function ReplyShortChannelIdsEnd_eq(a: bigint, b: bigint): boolean {
26234 if(!isWasmInitialized) {
26235 throw new Error("initializeWasm() must be awaited first!");
26237 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_eq(a, b);
26238 return nativeResponseValue;
26240 // void GossipTimestampFilter_free(struct LDKGossipTimestampFilter this_obj);
26242 export function GossipTimestampFilter_free(this_obj: bigint): void {
26243 if(!isWasmInitialized) {
26244 throw new Error("initializeWasm() must be awaited first!");
26246 const nativeResponseValue = wasm.TS_GossipTimestampFilter_free(this_obj);
26247 // debug statements here
26249 // const uint8_t (*GossipTimestampFilter_get_chain_hash(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr))[32];
26251 export function GossipTimestampFilter_get_chain_hash(this_ptr: bigint): number {
26252 if(!isWasmInitialized) {
26253 throw new Error("initializeWasm() must be awaited first!");
26255 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_chain_hash(this_ptr);
26256 return nativeResponseValue;
26258 // void GossipTimestampFilter_set_chain_hash(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26260 export function GossipTimestampFilter_set_chain_hash(this_ptr: bigint, val: number): void {
26261 if(!isWasmInitialized) {
26262 throw new Error("initializeWasm() must be awaited first!");
26264 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_chain_hash(this_ptr, val);
26265 // debug statements here
26267 // uint32_t GossipTimestampFilter_get_first_timestamp(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
26269 export function GossipTimestampFilter_get_first_timestamp(this_ptr: bigint): number {
26270 if(!isWasmInitialized) {
26271 throw new Error("initializeWasm() must be awaited first!");
26273 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_first_timestamp(this_ptr);
26274 return nativeResponseValue;
26276 // void GossipTimestampFilter_set_first_timestamp(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
26278 export function GossipTimestampFilter_set_first_timestamp(this_ptr: bigint, val: number): void {
26279 if(!isWasmInitialized) {
26280 throw new Error("initializeWasm() must be awaited first!");
26282 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_first_timestamp(this_ptr, val);
26283 // debug statements here
26285 // uint32_t GossipTimestampFilter_get_timestamp_range(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
26287 export function GossipTimestampFilter_get_timestamp_range(this_ptr: bigint): number {
26288 if(!isWasmInitialized) {
26289 throw new Error("initializeWasm() must be awaited first!");
26291 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_timestamp_range(this_ptr);
26292 return nativeResponseValue;
26294 // void GossipTimestampFilter_set_timestamp_range(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
26296 export function GossipTimestampFilter_set_timestamp_range(this_ptr: bigint, val: number): void {
26297 if(!isWasmInitialized) {
26298 throw new Error("initializeWasm() must be awaited first!");
26300 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_timestamp_range(this_ptr, val);
26301 // debug statements here
26303 // MUST_USE_RES struct LDKGossipTimestampFilter GossipTimestampFilter_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_timestamp_arg, uint32_t timestamp_range_arg);
26305 export function GossipTimestampFilter_new(chain_hash_arg: number, first_timestamp_arg: number, timestamp_range_arg: number): bigint {
26306 if(!isWasmInitialized) {
26307 throw new Error("initializeWasm() must be awaited first!");
26309 const nativeResponseValue = wasm.TS_GossipTimestampFilter_new(chain_hash_arg, first_timestamp_arg, timestamp_range_arg);
26310 return nativeResponseValue;
26312 // uint64_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg);
26314 export function GossipTimestampFilter_clone_ptr(arg: bigint): bigint {
26315 if(!isWasmInitialized) {
26316 throw new Error("initializeWasm() must be awaited first!");
26318 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone_ptr(arg);
26319 return nativeResponseValue;
26321 // struct LDKGossipTimestampFilter GossipTimestampFilter_clone(const struct LDKGossipTimestampFilter *NONNULL_PTR orig);
26323 export function GossipTimestampFilter_clone(orig: bigint): bigint {
26324 if(!isWasmInitialized) {
26325 throw new Error("initializeWasm() must be awaited first!");
26327 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone(orig);
26328 return nativeResponseValue;
26330 // bool GossipTimestampFilter_eq(const struct LDKGossipTimestampFilter *NONNULL_PTR a, const struct LDKGossipTimestampFilter *NONNULL_PTR b);
26332 export function GossipTimestampFilter_eq(a: bigint, b: bigint): boolean {
26333 if(!isWasmInitialized) {
26334 throw new Error("initializeWasm() must be awaited first!");
26336 const nativeResponseValue = wasm.TS_GossipTimestampFilter_eq(a, b);
26337 return nativeResponseValue;
26339 // void ErrorAction_free(struct LDKErrorAction this_ptr);
26341 export function ErrorAction_free(this_ptr: bigint): void {
26342 if(!isWasmInitialized) {
26343 throw new Error("initializeWasm() must be awaited first!");
26345 const nativeResponseValue = wasm.TS_ErrorAction_free(this_ptr);
26346 // debug statements here
26348 // uint64_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg);
26350 export function ErrorAction_clone_ptr(arg: bigint): bigint {
26351 if(!isWasmInitialized) {
26352 throw new Error("initializeWasm() must be awaited first!");
26354 const nativeResponseValue = wasm.TS_ErrorAction_clone_ptr(arg);
26355 return nativeResponseValue;
26357 // struct LDKErrorAction ErrorAction_clone(const struct LDKErrorAction *NONNULL_PTR orig);
26359 export function ErrorAction_clone(orig: bigint): bigint {
26360 if(!isWasmInitialized) {
26361 throw new Error("initializeWasm() must be awaited first!");
26363 const nativeResponseValue = wasm.TS_ErrorAction_clone(orig);
26364 return nativeResponseValue;
26366 // struct LDKErrorAction ErrorAction_disconnect_peer(struct LDKErrorMessage msg);
26368 export function ErrorAction_disconnect_peer(msg: bigint): bigint {
26369 if(!isWasmInitialized) {
26370 throw new Error("initializeWasm() must be awaited first!");
26372 const nativeResponseValue = wasm.TS_ErrorAction_disconnect_peer(msg);
26373 return nativeResponseValue;
26375 // struct LDKErrorAction ErrorAction_ignore_error(void);
26377 export function ErrorAction_ignore_error(): bigint {
26378 if(!isWasmInitialized) {
26379 throw new Error("initializeWasm() must be awaited first!");
26381 const nativeResponseValue = wasm.TS_ErrorAction_ignore_error();
26382 return nativeResponseValue;
26384 // struct LDKErrorAction ErrorAction_ignore_and_log(enum LDKLevel a);
26386 export function ErrorAction_ignore_and_log(a: Level): bigint {
26387 if(!isWasmInitialized) {
26388 throw new Error("initializeWasm() must be awaited first!");
26390 const nativeResponseValue = wasm.TS_ErrorAction_ignore_and_log(a);
26391 return nativeResponseValue;
26393 // struct LDKErrorAction ErrorAction_ignore_duplicate_gossip(void);
26395 export function ErrorAction_ignore_duplicate_gossip(): bigint {
26396 if(!isWasmInitialized) {
26397 throw new Error("initializeWasm() must be awaited first!");
26399 const nativeResponseValue = wasm.TS_ErrorAction_ignore_duplicate_gossip();
26400 return nativeResponseValue;
26402 // struct LDKErrorAction ErrorAction_send_error_message(struct LDKErrorMessage msg);
26404 export function ErrorAction_send_error_message(msg: bigint): bigint {
26405 if(!isWasmInitialized) {
26406 throw new Error("initializeWasm() must be awaited first!");
26408 const nativeResponseValue = wasm.TS_ErrorAction_send_error_message(msg);
26409 return nativeResponseValue;
26411 // struct LDKErrorAction ErrorAction_send_warning_message(struct LDKWarningMessage msg, enum LDKLevel log_level);
26413 export function ErrorAction_send_warning_message(msg: bigint, log_level: Level): bigint {
26414 if(!isWasmInitialized) {
26415 throw new Error("initializeWasm() must be awaited first!");
26417 const nativeResponseValue = wasm.TS_ErrorAction_send_warning_message(msg, log_level);
26418 return nativeResponseValue;
26420 // void LightningError_free(struct LDKLightningError this_obj);
26422 export function LightningError_free(this_obj: bigint): void {
26423 if(!isWasmInitialized) {
26424 throw new Error("initializeWasm() must be awaited first!");
26426 const nativeResponseValue = wasm.TS_LightningError_free(this_obj);
26427 // debug statements here
26429 // struct LDKStr LightningError_get_err(const struct LDKLightningError *NONNULL_PTR this_ptr);
26431 export function LightningError_get_err(this_ptr: bigint): number {
26432 if(!isWasmInitialized) {
26433 throw new Error("initializeWasm() must be awaited first!");
26435 const nativeResponseValue = wasm.TS_LightningError_get_err(this_ptr);
26436 return nativeResponseValue;
26438 // void LightningError_set_err(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKStr val);
26440 export function LightningError_set_err(this_ptr: bigint, val: number): void {
26441 if(!isWasmInitialized) {
26442 throw new Error("initializeWasm() must be awaited first!");
26444 const nativeResponseValue = wasm.TS_LightningError_set_err(this_ptr, val);
26445 // debug statements here
26447 // struct LDKErrorAction LightningError_get_action(const struct LDKLightningError *NONNULL_PTR this_ptr);
26449 export function LightningError_get_action(this_ptr: bigint): bigint {
26450 if(!isWasmInitialized) {
26451 throw new Error("initializeWasm() must be awaited first!");
26453 const nativeResponseValue = wasm.TS_LightningError_get_action(this_ptr);
26454 return nativeResponseValue;
26456 // void LightningError_set_action(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKErrorAction val);
26458 export function LightningError_set_action(this_ptr: bigint, val: bigint): void {
26459 if(!isWasmInitialized) {
26460 throw new Error("initializeWasm() must be awaited first!");
26462 const nativeResponseValue = wasm.TS_LightningError_set_action(this_ptr, val);
26463 // debug statements here
26465 // MUST_USE_RES struct LDKLightningError LightningError_new(struct LDKStr err_arg, struct LDKErrorAction action_arg);
26467 export function LightningError_new(err_arg: number, action_arg: bigint): bigint {
26468 if(!isWasmInitialized) {
26469 throw new Error("initializeWasm() must be awaited first!");
26471 const nativeResponseValue = wasm.TS_LightningError_new(err_arg, action_arg);
26472 return nativeResponseValue;
26474 // uint64_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg);
26476 export function LightningError_clone_ptr(arg: bigint): bigint {
26477 if(!isWasmInitialized) {
26478 throw new Error("initializeWasm() must be awaited first!");
26480 const nativeResponseValue = wasm.TS_LightningError_clone_ptr(arg);
26481 return nativeResponseValue;
26483 // struct LDKLightningError LightningError_clone(const struct LDKLightningError *NONNULL_PTR orig);
26485 export function LightningError_clone(orig: bigint): bigint {
26486 if(!isWasmInitialized) {
26487 throw new Error("initializeWasm() must be awaited first!");
26489 const nativeResponseValue = wasm.TS_LightningError_clone(orig);
26490 return nativeResponseValue;
26492 // void CommitmentUpdate_free(struct LDKCommitmentUpdate this_obj);
26494 export function CommitmentUpdate_free(this_obj: bigint): void {
26495 if(!isWasmInitialized) {
26496 throw new Error("initializeWasm() must be awaited first!");
26498 const nativeResponseValue = wasm.TS_CommitmentUpdate_free(this_obj);
26499 // debug statements here
26501 // struct LDKCVec_UpdateAddHTLCZ CommitmentUpdate_get_update_add_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
26503 export function CommitmentUpdate_get_update_add_htlcs(this_ptr: bigint): number {
26504 if(!isWasmInitialized) {
26505 throw new Error("initializeWasm() must be awaited first!");
26507 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_add_htlcs(this_ptr);
26508 return nativeResponseValue;
26510 // void CommitmentUpdate_set_update_add_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateAddHTLCZ val);
26512 export function CommitmentUpdate_set_update_add_htlcs(this_ptr: bigint, val: number): void {
26513 if(!isWasmInitialized) {
26514 throw new Error("initializeWasm() must be awaited first!");
26516 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_add_htlcs(this_ptr, val);
26517 // debug statements here
26519 // struct LDKCVec_UpdateFulfillHTLCZ CommitmentUpdate_get_update_fulfill_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
26521 export function CommitmentUpdate_get_update_fulfill_htlcs(this_ptr: bigint): number {
26522 if(!isWasmInitialized) {
26523 throw new Error("initializeWasm() must be awaited first!");
26525 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fulfill_htlcs(this_ptr);
26526 return nativeResponseValue;
26528 // void CommitmentUpdate_set_update_fulfill_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFulfillHTLCZ val);
26530 export function CommitmentUpdate_set_update_fulfill_htlcs(this_ptr: bigint, val: number): void {
26531 if(!isWasmInitialized) {
26532 throw new Error("initializeWasm() must be awaited first!");
26534 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fulfill_htlcs(this_ptr, val);
26535 // debug statements here
26537 // struct LDKCVec_UpdateFailHTLCZ CommitmentUpdate_get_update_fail_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
26539 export function CommitmentUpdate_get_update_fail_htlcs(this_ptr: bigint): number {
26540 if(!isWasmInitialized) {
26541 throw new Error("initializeWasm() must be awaited first!");
26543 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_htlcs(this_ptr);
26544 return nativeResponseValue;
26546 // void CommitmentUpdate_set_update_fail_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailHTLCZ val);
26548 export function CommitmentUpdate_set_update_fail_htlcs(this_ptr: bigint, val: number): void {
26549 if(!isWasmInitialized) {
26550 throw new Error("initializeWasm() must be awaited first!");
26552 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_htlcs(this_ptr, val);
26553 // debug statements here
26555 // struct LDKCVec_UpdateFailMalformedHTLCZ CommitmentUpdate_get_update_fail_malformed_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
26557 export function CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr: bigint): number {
26558 if(!isWasmInitialized) {
26559 throw new Error("initializeWasm() must be awaited first!");
26561 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr);
26562 return nativeResponseValue;
26564 // void CommitmentUpdate_set_update_fail_malformed_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailMalformedHTLCZ val);
26566 export function CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr: bigint, val: number): void {
26567 if(!isWasmInitialized) {
26568 throw new Error("initializeWasm() must be awaited first!");
26570 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr, val);
26571 // debug statements here
26573 // struct LDKUpdateFee CommitmentUpdate_get_update_fee(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
26575 export function CommitmentUpdate_get_update_fee(this_ptr: bigint): bigint {
26576 if(!isWasmInitialized) {
26577 throw new Error("initializeWasm() must be awaited first!");
26579 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fee(this_ptr);
26580 return nativeResponseValue;
26582 // void CommitmentUpdate_set_update_fee(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKUpdateFee val);
26584 export function CommitmentUpdate_set_update_fee(this_ptr: bigint, val: bigint): void {
26585 if(!isWasmInitialized) {
26586 throw new Error("initializeWasm() must be awaited first!");
26588 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fee(this_ptr, val);
26589 // debug statements here
26591 // struct LDKCommitmentSigned CommitmentUpdate_get_commitment_signed(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
26593 export function CommitmentUpdate_get_commitment_signed(this_ptr: bigint): bigint {
26594 if(!isWasmInitialized) {
26595 throw new Error("initializeWasm() must be awaited first!");
26597 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_commitment_signed(this_ptr);
26598 return nativeResponseValue;
26600 // void CommitmentUpdate_set_commitment_signed(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCommitmentSigned val);
26602 export function CommitmentUpdate_set_commitment_signed(this_ptr: bigint, val: bigint): void {
26603 if(!isWasmInitialized) {
26604 throw new Error("initializeWasm() must be awaited first!");
26606 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_commitment_signed(this_ptr, val);
26607 // debug statements here
26609 // 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);
26611 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 {
26612 if(!isWasmInitialized) {
26613 throw new Error("initializeWasm() must be awaited first!");
26615 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);
26616 return nativeResponseValue;
26618 // uint64_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg);
26620 export function CommitmentUpdate_clone_ptr(arg: bigint): bigint {
26621 if(!isWasmInitialized) {
26622 throw new Error("initializeWasm() must be awaited first!");
26624 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone_ptr(arg);
26625 return nativeResponseValue;
26627 // struct LDKCommitmentUpdate CommitmentUpdate_clone(const struct LDKCommitmentUpdate *NONNULL_PTR orig);
26629 export function CommitmentUpdate_clone(orig: bigint): bigint {
26630 if(!isWasmInitialized) {
26631 throw new Error("initializeWasm() must be awaited first!");
26633 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone(orig);
26634 return nativeResponseValue;
26636 // bool CommitmentUpdate_eq(const struct LDKCommitmentUpdate *NONNULL_PTR a, const struct LDKCommitmentUpdate *NONNULL_PTR b);
26638 export function CommitmentUpdate_eq(a: bigint, b: bigint): boolean {
26639 if(!isWasmInitialized) {
26640 throw new Error("initializeWasm() must be awaited first!");
26642 const nativeResponseValue = wasm.TS_CommitmentUpdate_eq(a, b);
26643 return nativeResponseValue;
26645 // void ChannelMessageHandler_free(struct LDKChannelMessageHandler this_ptr);
26647 export function ChannelMessageHandler_free(this_ptr: bigint): void {
26648 if(!isWasmInitialized) {
26649 throw new Error("initializeWasm() must be awaited first!");
26651 const nativeResponseValue = wasm.TS_ChannelMessageHandler_free(this_ptr);
26652 // debug statements here
26654 // void RoutingMessageHandler_free(struct LDKRoutingMessageHandler this_ptr);
26656 export function RoutingMessageHandler_free(this_ptr: bigint): void {
26657 if(!isWasmInitialized) {
26658 throw new Error("initializeWasm() must be awaited first!");
26660 const nativeResponseValue = wasm.TS_RoutingMessageHandler_free(this_ptr);
26661 // debug statements here
26663 // void OnionMessageHandler_free(struct LDKOnionMessageHandler this_ptr);
26665 export function OnionMessageHandler_free(this_ptr: bigint): void {
26666 if(!isWasmInitialized) {
26667 throw new Error("initializeWasm() must be awaited first!");
26669 const nativeResponseValue = wasm.TS_OnionMessageHandler_free(this_ptr);
26670 // debug statements here
26672 // struct LDKCVec_u8Z AcceptChannel_write(const struct LDKAcceptChannel *NONNULL_PTR obj);
26674 export function AcceptChannel_write(obj: bigint): number {
26675 if(!isWasmInitialized) {
26676 throw new Error("initializeWasm() must be awaited first!");
26678 const nativeResponseValue = wasm.TS_AcceptChannel_write(obj);
26679 return nativeResponseValue;
26681 // struct LDKCResult_AcceptChannelDecodeErrorZ AcceptChannel_read(struct LDKu8slice ser);
26683 export function AcceptChannel_read(ser: number): bigint {
26684 if(!isWasmInitialized) {
26685 throw new Error("initializeWasm() must be awaited first!");
26687 const nativeResponseValue = wasm.TS_AcceptChannel_read(ser);
26688 return nativeResponseValue;
26690 // struct LDKCVec_u8Z AnnouncementSignatures_write(const struct LDKAnnouncementSignatures *NONNULL_PTR obj);
26692 export function AnnouncementSignatures_write(obj: bigint): number {
26693 if(!isWasmInitialized) {
26694 throw new Error("initializeWasm() must be awaited first!");
26696 const nativeResponseValue = wasm.TS_AnnouncementSignatures_write(obj);
26697 return nativeResponseValue;
26699 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ AnnouncementSignatures_read(struct LDKu8slice ser);
26701 export function AnnouncementSignatures_read(ser: number): bigint {
26702 if(!isWasmInitialized) {
26703 throw new Error("initializeWasm() must be awaited first!");
26705 const nativeResponseValue = wasm.TS_AnnouncementSignatures_read(ser);
26706 return nativeResponseValue;
26708 // struct LDKCVec_u8Z ChannelReestablish_write(const struct LDKChannelReestablish *NONNULL_PTR obj);
26710 export function ChannelReestablish_write(obj: bigint): number {
26711 if(!isWasmInitialized) {
26712 throw new Error("initializeWasm() must be awaited first!");
26714 const nativeResponseValue = wasm.TS_ChannelReestablish_write(obj);
26715 return nativeResponseValue;
26717 // struct LDKCResult_ChannelReestablishDecodeErrorZ ChannelReestablish_read(struct LDKu8slice ser);
26719 export function ChannelReestablish_read(ser: number): bigint {
26720 if(!isWasmInitialized) {
26721 throw new Error("initializeWasm() must be awaited first!");
26723 const nativeResponseValue = wasm.TS_ChannelReestablish_read(ser);
26724 return nativeResponseValue;
26726 // struct LDKCVec_u8Z ClosingSigned_write(const struct LDKClosingSigned *NONNULL_PTR obj);
26728 export function ClosingSigned_write(obj: bigint): number {
26729 if(!isWasmInitialized) {
26730 throw new Error("initializeWasm() must be awaited first!");
26732 const nativeResponseValue = wasm.TS_ClosingSigned_write(obj);
26733 return nativeResponseValue;
26735 // struct LDKCResult_ClosingSignedDecodeErrorZ ClosingSigned_read(struct LDKu8slice ser);
26737 export function ClosingSigned_read(ser: number): bigint {
26738 if(!isWasmInitialized) {
26739 throw new Error("initializeWasm() must be awaited first!");
26741 const nativeResponseValue = wasm.TS_ClosingSigned_read(ser);
26742 return nativeResponseValue;
26744 // struct LDKCVec_u8Z ClosingSignedFeeRange_write(const struct LDKClosingSignedFeeRange *NONNULL_PTR obj);
26746 export function ClosingSignedFeeRange_write(obj: bigint): number {
26747 if(!isWasmInitialized) {
26748 throw new Error("initializeWasm() must be awaited first!");
26750 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_write(obj);
26751 return nativeResponseValue;
26753 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ ClosingSignedFeeRange_read(struct LDKu8slice ser);
26755 export function ClosingSignedFeeRange_read(ser: number): bigint {
26756 if(!isWasmInitialized) {
26757 throw new Error("initializeWasm() must be awaited first!");
26759 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_read(ser);
26760 return nativeResponseValue;
26762 // struct LDKCVec_u8Z CommitmentSigned_write(const struct LDKCommitmentSigned *NONNULL_PTR obj);
26764 export function CommitmentSigned_write(obj: bigint): number {
26765 if(!isWasmInitialized) {
26766 throw new Error("initializeWasm() must be awaited first!");
26768 const nativeResponseValue = wasm.TS_CommitmentSigned_write(obj);
26769 return nativeResponseValue;
26771 // struct LDKCResult_CommitmentSignedDecodeErrorZ CommitmentSigned_read(struct LDKu8slice ser);
26773 export function CommitmentSigned_read(ser: number): bigint {
26774 if(!isWasmInitialized) {
26775 throw new Error("initializeWasm() must be awaited first!");
26777 const nativeResponseValue = wasm.TS_CommitmentSigned_read(ser);
26778 return nativeResponseValue;
26780 // struct LDKCVec_u8Z FundingCreated_write(const struct LDKFundingCreated *NONNULL_PTR obj);
26782 export function FundingCreated_write(obj: bigint): number {
26783 if(!isWasmInitialized) {
26784 throw new Error("initializeWasm() must be awaited first!");
26786 const nativeResponseValue = wasm.TS_FundingCreated_write(obj);
26787 return nativeResponseValue;
26789 // struct LDKCResult_FundingCreatedDecodeErrorZ FundingCreated_read(struct LDKu8slice ser);
26791 export function FundingCreated_read(ser: number): bigint {
26792 if(!isWasmInitialized) {
26793 throw new Error("initializeWasm() must be awaited first!");
26795 const nativeResponseValue = wasm.TS_FundingCreated_read(ser);
26796 return nativeResponseValue;
26798 // struct LDKCVec_u8Z FundingSigned_write(const struct LDKFundingSigned *NONNULL_PTR obj);
26800 export function FundingSigned_write(obj: bigint): number {
26801 if(!isWasmInitialized) {
26802 throw new Error("initializeWasm() must be awaited first!");
26804 const nativeResponseValue = wasm.TS_FundingSigned_write(obj);
26805 return nativeResponseValue;
26807 // struct LDKCResult_FundingSignedDecodeErrorZ FundingSigned_read(struct LDKu8slice ser);
26809 export function FundingSigned_read(ser: number): bigint {
26810 if(!isWasmInitialized) {
26811 throw new Error("initializeWasm() must be awaited first!");
26813 const nativeResponseValue = wasm.TS_FundingSigned_read(ser);
26814 return nativeResponseValue;
26816 // struct LDKCVec_u8Z ChannelReady_write(const struct LDKChannelReady *NONNULL_PTR obj);
26818 export function ChannelReady_write(obj: bigint): number {
26819 if(!isWasmInitialized) {
26820 throw new Error("initializeWasm() must be awaited first!");
26822 const nativeResponseValue = wasm.TS_ChannelReady_write(obj);
26823 return nativeResponseValue;
26825 // struct LDKCResult_ChannelReadyDecodeErrorZ ChannelReady_read(struct LDKu8slice ser);
26827 export function ChannelReady_read(ser: number): bigint {
26828 if(!isWasmInitialized) {
26829 throw new Error("initializeWasm() must be awaited first!");
26831 const nativeResponseValue = wasm.TS_ChannelReady_read(ser);
26832 return nativeResponseValue;
26834 // struct LDKCVec_u8Z Init_write(const struct LDKInit *NONNULL_PTR obj);
26836 export function Init_write(obj: bigint): number {
26837 if(!isWasmInitialized) {
26838 throw new Error("initializeWasm() must be awaited first!");
26840 const nativeResponseValue = wasm.TS_Init_write(obj);
26841 return nativeResponseValue;
26843 // struct LDKCResult_InitDecodeErrorZ Init_read(struct LDKu8slice ser);
26845 export function Init_read(ser: number): bigint {
26846 if(!isWasmInitialized) {
26847 throw new Error("initializeWasm() must be awaited first!");
26849 const nativeResponseValue = wasm.TS_Init_read(ser);
26850 return nativeResponseValue;
26852 // struct LDKCVec_u8Z OpenChannel_write(const struct LDKOpenChannel *NONNULL_PTR obj);
26854 export function OpenChannel_write(obj: bigint): number {
26855 if(!isWasmInitialized) {
26856 throw new Error("initializeWasm() must be awaited first!");
26858 const nativeResponseValue = wasm.TS_OpenChannel_write(obj);
26859 return nativeResponseValue;
26861 // struct LDKCResult_OpenChannelDecodeErrorZ OpenChannel_read(struct LDKu8slice ser);
26863 export function OpenChannel_read(ser: number): bigint {
26864 if(!isWasmInitialized) {
26865 throw new Error("initializeWasm() must be awaited first!");
26867 const nativeResponseValue = wasm.TS_OpenChannel_read(ser);
26868 return nativeResponseValue;
26870 // struct LDKCVec_u8Z RevokeAndACK_write(const struct LDKRevokeAndACK *NONNULL_PTR obj);
26872 export function RevokeAndACK_write(obj: bigint): number {
26873 if(!isWasmInitialized) {
26874 throw new Error("initializeWasm() must be awaited first!");
26876 const nativeResponseValue = wasm.TS_RevokeAndACK_write(obj);
26877 return nativeResponseValue;
26879 // struct LDKCResult_RevokeAndACKDecodeErrorZ RevokeAndACK_read(struct LDKu8slice ser);
26881 export function RevokeAndACK_read(ser: number): bigint {
26882 if(!isWasmInitialized) {
26883 throw new Error("initializeWasm() must be awaited first!");
26885 const nativeResponseValue = wasm.TS_RevokeAndACK_read(ser);
26886 return nativeResponseValue;
26888 // struct LDKCVec_u8Z Shutdown_write(const struct LDKShutdown *NONNULL_PTR obj);
26890 export function Shutdown_write(obj: bigint): number {
26891 if(!isWasmInitialized) {
26892 throw new Error("initializeWasm() must be awaited first!");
26894 const nativeResponseValue = wasm.TS_Shutdown_write(obj);
26895 return nativeResponseValue;
26897 // struct LDKCResult_ShutdownDecodeErrorZ Shutdown_read(struct LDKu8slice ser);
26899 export function Shutdown_read(ser: number): bigint {
26900 if(!isWasmInitialized) {
26901 throw new Error("initializeWasm() must be awaited first!");
26903 const nativeResponseValue = wasm.TS_Shutdown_read(ser);
26904 return nativeResponseValue;
26906 // struct LDKCVec_u8Z UpdateFailHTLC_write(const struct LDKUpdateFailHTLC *NONNULL_PTR obj);
26908 export function UpdateFailHTLC_write(obj: bigint): number {
26909 if(!isWasmInitialized) {
26910 throw new Error("initializeWasm() must be awaited first!");
26912 const nativeResponseValue = wasm.TS_UpdateFailHTLC_write(obj);
26913 return nativeResponseValue;
26915 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ UpdateFailHTLC_read(struct LDKu8slice ser);
26917 export function UpdateFailHTLC_read(ser: number): bigint {
26918 if(!isWasmInitialized) {
26919 throw new Error("initializeWasm() must be awaited first!");
26921 const nativeResponseValue = wasm.TS_UpdateFailHTLC_read(ser);
26922 return nativeResponseValue;
26924 // struct LDKCVec_u8Z UpdateFailMalformedHTLC_write(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR obj);
26926 export function UpdateFailMalformedHTLC_write(obj: bigint): number {
26927 if(!isWasmInitialized) {
26928 throw new Error("initializeWasm() must be awaited first!");
26930 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_write(obj);
26931 return nativeResponseValue;
26933 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ UpdateFailMalformedHTLC_read(struct LDKu8slice ser);
26935 export function UpdateFailMalformedHTLC_read(ser: number): bigint {
26936 if(!isWasmInitialized) {
26937 throw new Error("initializeWasm() must be awaited first!");
26939 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_read(ser);
26940 return nativeResponseValue;
26942 // struct LDKCVec_u8Z UpdateFee_write(const struct LDKUpdateFee *NONNULL_PTR obj);
26944 export function UpdateFee_write(obj: bigint): number {
26945 if(!isWasmInitialized) {
26946 throw new Error("initializeWasm() must be awaited first!");
26948 const nativeResponseValue = wasm.TS_UpdateFee_write(obj);
26949 return nativeResponseValue;
26951 // struct LDKCResult_UpdateFeeDecodeErrorZ UpdateFee_read(struct LDKu8slice ser);
26953 export function UpdateFee_read(ser: number): bigint {
26954 if(!isWasmInitialized) {
26955 throw new Error("initializeWasm() must be awaited first!");
26957 const nativeResponseValue = wasm.TS_UpdateFee_read(ser);
26958 return nativeResponseValue;
26960 // struct LDKCVec_u8Z UpdateFulfillHTLC_write(const struct LDKUpdateFulfillHTLC *NONNULL_PTR obj);
26962 export function UpdateFulfillHTLC_write(obj: bigint): number {
26963 if(!isWasmInitialized) {
26964 throw new Error("initializeWasm() must be awaited first!");
26966 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_write(obj);
26967 return nativeResponseValue;
26969 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ UpdateFulfillHTLC_read(struct LDKu8slice ser);
26971 export function UpdateFulfillHTLC_read(ser: number): bigint {
26972 if(!isWasmInitialized) {
26973 throw new Error("initializeWasm() must be awaited first!");
26975 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_read(ser);
26976 return nativeResponseValue;
26978 // struct LDKCVec_u8Z UpdateAddHTLC_write(const struct LDKUpdateAddHTLC *NONNULL_PTR obj);
26980 export function UpdateAddHTLC_write(obj: bigint): number {
26981 if(!isWasmInitialized) {
26982 throw new Error("initializeWasm() must be awaited first!");
26984 const nativeResponseValue = wasm.TS_UpdateAddHTLC_write(obj);
26985 return nativeResponseValue;
26987 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ UpdateAddHTLC_read(struct LDKu8slice ser);
26989 export function UpdateAddHTLC_read(ser: number): bigint {
26990 if(!isWasmInitialized) {
26991 throw new Error("initializeWasm() must be awaited first!");
26993 const nativeResponseValue = wasm.TS_UpdateAddHTLC_read(ser);
26994 return nativeResponseValue;
26996 // struct LDKCResult_OnionMessageDecodeErrorZ OnionMessage_read(struct LDKu8slice ser);
26998 export function OnionMessage_read(ser: number): bigint {
26999 if(!isWasmInitialized) {
27000 throw new Error("initializeWasm() must be awaited first!");
27002 const nativeResponseValue = wasm.TS_OnionMessage_read(ser);
27003 return nativeResponseValue;
27005 // struct LDKCVec_u8Z OnionMessage_write(const struct LDKOnionMessage *NONNULL_PTR obj);
27007 export function OnionMessage_write(obj: bigint): number {
27008 if(!isWasmInitialized) {
27009 throw new Error("initializeWasm() must be awaited first!");
27011 const nativeResponseValue = wasm.TS_OnionMessage_write(obj);
27012 return nativeResponseValue;
27014 // struct LDKCVec_u8Z Ping_write(const struct LDKPing *NONNULL_PTR obj);
27016 export function Ping_write(obj: bigint): number {
27017 if(!isWasmInitialized) {
27018 throw new Error("initializeWasm() must be awaited first!");
27020 const nativeResponseValue = wasm.TS_Ping_write(obj);
27021 return nativeResponseValue;
27023 // struct LDKCResult_PingDecodeErrorZ Ping_read(struct LDKu8slice ser);
27025 export function Ping_read(ser: number): bigint {
27026 if(!isWasmInitialized) {
27027 throw new Error("initializeWasm() must be awaited first!");
27029 const nativeResponseValue = wasm.TS_Ping_read(ser);
27030 return nativeResponseValue;
27032 // struct LDKCVec_u8Z Pong_write(const struct LDKPong *NONNULL_PTR obj);
27034 export function Pong_write(obj: bigint): number {
27035 if(!isWasmInitialized) {
27036 throw new Error("initializeWasm() must be awaited first!");
27038 const nativeResponseValue = wasm.TS_Pong_write(obj);
27039 return nativeResponseValue;
27041 // struct LDKCResult_PongDecodeErrorZ Pong_read(struct LDKu8slice ser);
27043 export function Pong_read(ser: number): bigint {
27044 if(!isWasmInitialized) {
27045 throw new Error("initializeWasm() must be awaited first!");
27047 const nativeResponseValue = wasm.TS_Pong_read(ser);
27048 return nativeResponseValue;
27050 // struct LDKCVec_u8Z UnsignedChannelAnnouncement_write(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR obj);
27052 export function UnsignedChannelAnnouncement_write(obj: bigint): number {
27053 if(!isWasmInitialized) {
27054 throw new Error("initializeWasm() must be awaited first!");
27056 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_write(obj);
27057 return nativeResponseValue;
27059 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ UnsignedChannelAnnouncement_read(struct LDKu8slice ser);
27061 export function UnsignedChannelAnnouncement_read(ser: number): bigint {
27062 if(!isWasmInitialized) {
27063 throw new Error("initializeWasm() must be awaited first!");
27065 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_read(ser);
27066 return nativeResponseValue;
27068 // struct LDKCVec_u8Z ChannelAnnouncement_write(const struct LDKChannelAnnouncement *NONNULL_PTR obj);
27070 export function ChannelAnnouncement_write(obj: bigint): number {
27071 if(!isWasmInitialized) {
27072 throw new Error("initializeWasm() must be awaited first!");
27074 const nativeResponseValue = wasm.TS_ChannelAnnouncement_write(obj);
27075 return nativeResponseValue;
27077 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ ChannelAnnouncement_read(struct LDKu8slice ser);
27079 export function ChannelAnnouncement_read(ser: number): bigint {
27080 if(!isWasmInitialized) {
27081 throw new Error("initializeWasm() must be awaited first!");
27083 const nativeResponseValue = wasm.TS_ChannelAnnouncement_read(ser);
27084 return nativeResponseValue;
27086 // struct LDKCVec_u8Z UnsignedChannelUpdate_write(const struct LDKUnsignedChannelUpdate *NONNULL_PTR obj);
27088 export function UnsignedChannelUpdate_write(obj: bigint): number {
27089 if(!isWasmInitialized) {
27090 throw new Error("initializeWasm() must be awaited first!");
27092 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_write(obj);
27093 return nativeResponseValue;
27095 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ UnsignedChannelUpdate_read(struct LDKu8slice ser);
27097 export function UnsignedChannelUpdate_read(ser: number): bigint {
27098 if(!isWasmInitialized) {
27099 throw new Error("initializeWasm() must be awaited first!");
27101 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_read(ser);
27102 return nativeResponseValue;
27104 // struct LDKCVec_u8Z ChannelUpdate_write(const struct LDKChannelUpdate *NONNULL_PTR obj);
27106 export function ChannelUpdate_write(obj: bigint): number {
27107 if(!isWasmInitialized) {
27108 throw new Error("initializeWasm() must be awaited first!");
27110 const nativeResponseValue = wasm.TS_ChannelUpdate_write(obj);
27111 return nativeResponseValue;
27113 // struct LDKCResult_ChannelUpdateDecodeErrorZ ChannelUpdate_read(struct LDKu8slice ser);
27115 export function ChannelUpdate_read(ser: number): bigint {
27116 if(!isWasmInitialized) {
27117 throw new Error("initializeWasm() must be awaited first!");
27119 const nativeResponseValue = wasm.TS_ChannelUpdate_read(ser);
27120 return nativeResponseValue;
27122 // struct LDKCVec_u8Z ErrorMessage_write(const struct LDKErrorMessage *NONNULL_PTR obj);
27124 export function ErrorMessage_write(obj: bigint): number {
27125 if(!isWasmInitialized) {
27126 throw new Error("initializeWasm() must be awaited first!");
27128 const nativeResponseValue = wasm.TS_ErrorMessage_write(obj);
27129 return nativeResponseValue;
27131 // struct LDKCResult_ErrorMessageDecodeErrorZ ErrorMessage_read(struct LDKu8slice ser);
27133 export function ErrorMessage_read(ser: number): bigint {
27134 if(!isWasmInitialized) {
27135 throw new Error("initializeWasm() must be awaited first!");
27137 const nativeResponseValue = wasm.TS_ErrorMessage_read(ser);
27138 return nativeResponseValue;
27140 // struct LDKCVec_u8Z WarningMessage_write(const struct LDKWarningMessage *NONNULL_PTR obj);
27142 export function WarningMessage_write(obj: bigint): number {
27143 if(!isWasmInitialized) {
27144 throw new Error("initializeWasm() must be awaited first!");
27146 const nativeResponseValue = wasm.TS_WarningMessage_write(obj);
27147 return nativeResponseValue;
27149 // struct LDKCResult_WarningMessageDecodeErrorZ WarningMessage_read(struct LDKu8slice ser);
27151 export function WarningMessage_read(ser: number): bigint {
27152 if(!isWasmInitialized) {
27153 throw new Error("initializeWasm() must be awaited first!");
27155 const nativeResponseValue = wasm.TS_WarningMessage_read(ser);
27156 return nativeResponseValue;
27158 // struct LDKCVec_u8Z UnsignedNodeAnnouncement_write(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR obj);
27160 export function UnsignedNodeAnnouncement_write(obj: bigint): number {
27161 if(!isWasmInitialized) {
27162 throw new Error("initializeWasm() must be awaited first!");
27164 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_write(obj);
27165 return nativeResponseValue;
27167 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ UnsignedNodeAnnouncement_read(struct LDKu8slice ser);
27169 export function UnsignedNodeAnnouncement_read(ser: number): bigint {
27170 if(!isWasmInitialized) {
27171 throw new Error("initializeWasm() must be awaited first!");
27173 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_read(ser);
27174 return nativeResponseValue;
27176 // struct LDKCVec_u8Z NodeAnnouncement_write(const struct LDKNodeAnnouncement *NONNULL_PTR obj);
27178 export function NodeAnnouncement_write(obj: bigint): number {
27179 if(!isWasmInitialized) {
27180 throw new Error("initializeWasm() must be awaited first!");
27182 const nativeResponseValue = wasm.TS_NodeAnnouncement_write(obj);
27183 return nativeResponseValue;
27185 // struct LDKCResult_NodeAnnouncementDecodeErrorZ NodeAnnouncement_read(struct LDKu8slice ser);
27187 export function NodeAnnouncement_read(ser: number): bigint {
27188 if(!isWasmInitialized) {
27189 throw new Error("initializeWasm() must be awaited first!");
27191 const nativeResponseValue = wasm.TS_NodeAnnouncement_read(ser);
27192 return nativeResponseValue;
27194 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ QueryShortChannelIds_read(struct LDKu8slice ser);
27196 export function QueryShortChannelIds_read(ser: number): bigint {
27197 if(!isWasmInitialized) {
27198 throw new Error("initializeWasm() must be awaited first!");
27200 const nativeResponseValue = wasm.TS_QueryShortChannelIds_read(ser);
27201 return nativeResponseValue;
27203 // struct LDKCVec_u8Z QueryShortChannelIds_write(const struct LDKQueryShortChannelIds *NONNULL_PTR obj);
27205 export function QueryShortChannelIds_write(obj: bigint): number {
27206 if(!isWasmInitialized) {
27207 throw new Error("initializeWasm() must be awaited first!");
27209 const nativeResponseValue = wasm.TS_QueryShortChannelIds_write(obj);
27210 return nativeResponseValue;
27212 // struct LDKCVec_u8Z ReplyShortChannelIdsEnd_write(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR obj);
27214 export function ReplyShortChannelIdsEnd_write(obj: bigint): number {
27215 if(!isWasmInitialized) {
27216 throw new Error("initializeWasm() must be awaited first!");
27218 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_write(obj);
27219 return nativeResponseValue;
27221 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ ReplyShortChannelIdsEnd_read(struct LDKu8slice ser);
27223 export function ReplyShortChannelIdsEnd_read(ser: number): bigint {
27224 if(!isWasmInitialized) {
27225 throw new Error("initializeWasm() must be awaited first!");
27227 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_read(ser);
27228 return nativeResponseValue;
27230 // MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
27232 export function QueryChannelRange_end_blocknum(this_arg: bigint): number {
27233 if(!isWasmInitialized) {
27234 throw new Error("initializeWasm() must be awaited first!");
27236 const nativeResponseValue = wasm.TS_QueryChannelRange_end_blocknum(this_arg);
27237 return nativeResponseValue;
27239 // struct LDKCVec_u8Z QueryChannelRange_write(const struct LDKQueryChannelRange *NONNULL_PTR obj);
27241 export function QueryChannelRange_write(obj: bigint): number {
27242 if(!isWasmInitialized) {
27243 throw new Error("initializeWasm() must be awaited first!");
27245 const nativeResponseValue = wasm.TS_QueryChannelRange_write(obj);
27246 return nativeResponseValue;
27248 // struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
27250 export function QueryChannelRange_read(ser: number): bigint {
27251 if(!isWasmInitialized) {
27252 throw new Error("initializeWasm() must be awaited first!");
27254 const nativeResponseValue = wasm.TS_QueryChannelRange_read(ser);
27255 return nativeResponseValue;
27257 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ ReplyChannelRange_read(struct LDKu8slice ser);
27259 export function ReplyChannelRange_read(ser: number): bigint {
27260 if(!isWasmInitialized) {
27261 throw new Error("initializeWasm() must be awaited first!");
27263 const nativeResponseValue = wasm.TS_ReplyChannelRange_read(ser);
27264 return nativeResponseValue;
27266 // struct LDKCVec_u8Z ReplyChannelRange_write(const struct LDKReplyChannelRange *NONNULL_PTR obj);
27268 export function ReplyChannelRange_write(obj: bigint): number {
27269 if(!isWasmInitialized) {
27270 throw new Error("initializeWasm() must be awaited first!");
27272 const nativeResponseValue = wasm.TS_ReplyChannelRange_write(obj);
27273 return nativeResponseValue;
27275 // struct LDKCVec_u8Z GossipTimestampFilter_write(const struct LDKGossipTimestampFilter *NONNULL_PTR obj);
27277 export function GossipTimestampFilter_write(obj: bigint): number {
27278 if(!isWasmInitialized) {
27279 throw new Error("initializeWasm() must be awaited first!");
27281 const nativeResponseValue = wasm.TS_GossipTimestampFilter_write(obj);
27282 return nativeResponseValue;
27284 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ GossipTimestampFilter_read(struct LDKu8slice ser);
27286 export function GossipTimestampFilter_read(ser: number): bigint {
27287 if(!isWasmInitialized) {
27288 throw new Error("initializeWasm() must be awaited first!");
27290 const nativeResponseValue = wasm.TS_GossipTimestampFilter_read(ser);
27291 return nativeResponseValue;
27293 // void CustomMessageHandler_free(struct LDKCustomMessageHandler this_ptr);
27295 export function CustomMessageHandler_free(this_ptr: bigint): void {
27296 if(!isWasmInitialized) {
27297 throw new Error("initializeWasm() must be awaited first!");
27299 const nativeResponseValue = wasm.TS_CustomMessageHandler_free(this_ptr);
27300 // debug statements here
27302 // void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_obj);
27304 export function IgnoringMessageHandler_free(this_obj: bigint): void {
27305 if(!isWasmInitialized) {
27306 throw new Error("initializeWasm() must be awaited first!");
27308 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_free(this_obj);
27309 // debug statements here
27311 // MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void);
27313 export function IgnoringMessageHandler_new(): bigint {
27314 if(!isWasmInitialized) {
27315 throw new Error("initializeWasm() must be awaited first!");
27317 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_new();
27318 return nativeResponseValue;
27320 // struct LDKMessageSendEventsProvider IgnoringMessageHandler_as_MessageSendEventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
27322 export function IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg: bigint): bigint {
27323 if(!isWasmInitialized) {
27324 throw new Error("initializeWasm() must be awaited first!");
27326 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg);
27327 return nativeResponseValue;
27329 // struct LDKRoutingMessageHandler IgnoringMessageHandler_as_RoutingMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
27331 export function IgnoringMessageHandler_as_RoutingMessageHandler(this_arg: bigint): bigint {
27332 if(!isWasmInitialized) {
27333 throw new Error("initializeWasm() must be awaited first!");
27335 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_RoutingMessageHandler(this_arg);
27336 return nativeResponseValue;
27338 // struct LDKOnionMessageProvider IgnoringMessageHandler_as_OnionMessageProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
27340 export function IgnoringMessageHandler_as_OnionMessageProvider(this_arg: bigint): bigint {
27341 if(!isWasmInitialized) {
27342 throw new Error("initializeWasm() must be awaited first!");
27344 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_OnionMessageProvider(this_arg);
27345 return nativeResponseValue;
27347 // struct LDKOnionMessageHandler IgnoringMessageHandler_as_OnionMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
27349 export function IgnoringMessageHandler_as_OnionMessageHandler(this_arg: bigint): bigint {
27350 if(!isWasmInitialized) {
27351 throw new Error("initializeWasm() must be awaited first!");
27353 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_OnionMessageHandler(this_arg);
27354 return nativeResponseValue;
27356 // struct LDKCustomOnionMessageHandler IgnoringMessageHandler_as_CustomOnionMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
27358 export function IgnoringMessageHandler_as_CustomOnionMessageHandler(this_arg: bigint): bigint {
27359 if(!isWasmInitialized) {
27360 throw new Error("initializeWasm() must be awaited first!");
27362 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomOnionMessageHandler(this_arg);
27363 return nativeResponseValue;
27365 // struct LDKCustomMessageReader IgnoringMessageHandler_as_CustomMessageReader(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
27367 export function IgnoringMessageHandler_as_CustomMessageReader(this_arg: bigint): bigint {
27368 if(!isWasmInitialized) {
27369 throw new Error("initializeWasm() must be awaited first!");
27371 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageReader(this_arg);
27372 return nativeResponseValue;
27374 // struct LDKCustomMessageHandler IgnoringMessageHandler_as_CustomMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
27376 export function IgnoringMessageHandler_as_CustomMessageHandler(this_arg: bigint): bigint {
27377 if(!isWasmInitialized) {
27378 throw new Error("initializeWasm() must be awaited first!");
27380 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageHandler(this_arg);
27381 return nativeResponseValue;
27383 // void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_obj);
27385 export function ErroringMessageHandler_free(this_obj: bigint): void {
27386 if(!isWasmInitialized) {
27387 throw new Error("initializeWasm() must be awaited first!");
27389 const nativeResponseValue = wasm.TS_ErroringMessageHandler_free(this_obj);
27390 // debug statements here
27392 // MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void);
27394 export function ErroringMessageHandler_new(): bigint {
27395 if(!isWasmInitialized) {
27396 throw new Error("initializeWasm() must be awaited first!");
27398 const nativeResponseValue = wasm.TS_ErroringMessageHandler_new();
27399 return nativeResponseValue;
27401 // struct LDKMessageSendEventsProvider ErroringMessageHandler_as_MessageSendEventsProvider(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
27403 export function ErroringMessageHandler_as_MessageSendEventsProvider(this_arg: bigint): bigint {
27404 if(!isWasmInitialized) {
27405 throw new Error("initializeWasm() must be awaited first!");
27407 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_MessageSendEventsProvider(this_arg);
27408 return nativeResponseValue;
27410 // struct LDKChannelMessageHandler ErroringMessageHandler_as_ChannelMessageHandler(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
27412 export function ErroringMessageHandler_as_ChannelMessageHandler(this_arg: bigint): bigint {
27413 if(!isWasmInitialized) {
27414 throw new Error("initializeWasm() must be awaited first!");
27416 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_ChannelMessageHandler(this_arg);
27417 return nativeResponseValue;
27419 // void MessageHandler_free(struct LDKMessageHandler this_obj);
27421 export function MessageHandler_free(this_obj: bigint): void {
27422 if(!isWasmInitialized) {
27423 throw new Error("initializeWasm() must be awaited first!");
27425 const nativeResponseValue = wasm.TS_MessageHandler_free(this_obj);
27426 // debug statements here
27428 // const struct LDKChannelMessageHandler *MessageHandler_get_chan_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
27430 export function MessageHandler_get_chan_handler(this_ptr: bigint): bigint {
27431 if(!isWasmInitialized) {
27432 throw new Error("initializeWasm() must be awaited first!");
27434 const nativeResponseValue = wasm.TS_MessageHandler_get_chan_handler(this_ptr);
27435 return nativeResponseValue;
27437 // void MessageHandler_set_chan_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKChannelMessageHandler val);
27439 export function MessageHandler_set_chan_handler(this_ptr: bigint, val: bigint): void {
27440 if(!isWasmInitialized) {
27441 throw new Error("initializeWasm() must be awaited first!");
27443 const nativeResponseValue = wasm.TS_MessageHandler_set_chan_handler(this_ptr, val);
27444 // debug statements here
27446 // const struct LDKRoutingMessageHandler *MessageHandler_get_route_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
27448 export function MessageHandler_get_route_handler(this_ptr: bigint): bigint {
27449 if(!isWasmInitialized) {
27450 throw new Error("initializeWasm() must be awaited first!");
27452 const nativeResponseValue = wasm.TS_MessageHandler_get_route_handler(this_ptr);
27453 return nativeResponseValue;
27455 // void MessageHandler_set_route_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKRoutingMessageHandler val);
27457 export function MessageHandler_set_route_handler(this_ptr: bigint, val: bigint): void {
27458 if(!isWasmInitialized) {
27459 throw new Error("initializeWasm() must be awaited first!");
27461 const nativeResponseValue = wasm.TS_MessageHandler_set_route_handler(this_ptr, val);
27462 // debug statements here
27464 // const struct LDKOnionMessageHandler *MessageHandler_get_onion_message_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
27466 export function MessageHandler_get_onion_message_handler(this_ptr: bigint): bigint {
27467 if(!isWasmInitialized) {
27468 throw new Error("initializeWasm() must be awaited first!");
27470 const nativeResponseValue = wasm.TS_MessageHandler_get_onion_message_handler(this_ptr);
27471 return nativeResponseValue;
27473 // void MessageHandler_set_onion_message_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKOnionMessageHandler val);
27475 export function MessageHandler_set_onion_message_handler(this_ptr: bigint, val: bigint): void {
27476 if(!isWasmInitialized) {
27477 throw new Error("initializeWasm() must be awaited first!");
27479 const nativeResponseValue = wasm.TS_MessageHandler_set_onion_message_handler(this_ptr, val);
27480 // debug statements here
27482 // MUST_USE_RES struct LDKMessageHandler MessageHandler_new(struct LDKChannelMessageHandler chan_handler_arg, struct LDKRoutingMessageHandler route_handler_arg, struct LDKOnionMessageHandler onion_message_handler_arg);
27484 export function MessageHandler_new(chan_handler_arg: bigint, route_handler_arg: bigint, onion_message_handler_arg: bigint): bigint {
27485 if(!isWasmInitialized) {
27486 throw new Error("initializeWasm() must be awaited first!");
27488 const nativeResponseValue = wasm.TS_MessageHandler_new(chan_handler_arg, route_handler_arg, onion_message_handler_arg);
27489 return nativeResponseValue;
27491 // uint64_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg);
27493 export function SocketDescriptor_clone_ptr(arg: bigint): bigint {
27494 if(!isWasmInitialized) {
27495 throw new Error("initializeWasm() must be awaited first!");
27497 const nativeResponseValue = wasm.TS_SocketDescriptor_clone_ptr(arg);
27498 return nativeResponseValue;
27500 // struct LDKSocketDescriptor SocketDescriptor_clone(const struct LDKSocketDescriptor *NONNULL_PTR orig);
27502 export function SocketDescriptor_clone(orig: bigint): bigint {
27503 if(!isWasmInitialized) {
27504 throw new Error("initializeWasm() must be awaited first!");
27506 const nativeResponseValue = wasm.TS_SocketDescriptor_clone(orig);
27507 return nativeResponseValue;
27509 // void SocketDescriptor_free(struct LDKSocketDescriptor this_ptr);
27511 export function SocketDescriptor_free(this_ptr: bigint): void {
27512 if(!isWasmInitialized) {
27513 throw new Error("initializeWasm() must be awaited first!");
27515 const nativeResponseValue = wasm.TS_SocketDescriptor_free(this_ptr);
27516 // debug statements here
27518 // void PeerHandleError_free(struct LDKPeerHandleError this_obj);
27520 export function PeerHandleError_free(this_obj: bigint): void {
27521 if(!isWasmInitialized) {
27522 throw new Error("initializeWasm() must be awaited first!");
27524 const nativeResponseValue = wasm.TS_PeerHandleError_free(this_obj);
27525 // debug statements here
27527 // bool PeerHandleError_get_no_connection_possible(const struct LDKPeerHandleError *NONNULL_PTR this_ptr);
27529 export function PeerHandleError_get_no_connection_possible(this_ptr: bigint): boolean {
27530 if(!isWasmInitialized) {
27531 throw new Error("initializeWasm() must be awaited first!");
27533 const nativeResponseValue = wasm.TS_PeerHandleError_get_no_connection_possible(this_ptr);
27534 return nativeResponseValue;
27536 // void PeerHandleError_set_no_connection_possible(struct LDKPeerHandleError *NONNULL_PTR this_ptr, bool val);
27538 export function PeerHandleError_set_no_connection_possible(this_ptr: bigint, val: boolean): void {
27539 if(!isWasmInitialized) {
27540 throw new Error("initializeWasm() must be awaited first!");
27542 const nativeResponseValue = wasm.TS_PeerHandleError_set_no_connection_possible(this_ptr, val);
27543 // debug statements here
27545 // MUST_USE_RES struct LDKPeerHandleError PeerHandleError_new(bool no_connection_possible_arg);
27547 export function PeerHandleError_new(no_connection_possible_arg: boolean): bigint {
27548 if(!isWasmInitialized) {
27549 throw new Error("initializeWasm() must be awaited first!");
27551 const nativeResponseValue = wasm.TS_PeerHandleError_new(no_connection_possible_arg);
27552 return nativeResponseValue;
27554 // uint64_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg);
27556 export function PeerHandleError_clone_ptr(arg: bigint): bigint {
27557 if(!isWasmInitialized) {
27558 throw new Error("initializeWasm() must be awaited first!");
27560 const nativeResponseValue = wasm.TS_PeerHandleError_clone_ptr(arg);
27561 return nativeResponseValue;
27563 // struct LDKPeerHandleError PeerHandleError_clone(const struct LDKPeerHandleError *NONNULL_PTR orig);
27565 export function PeerHandleError_clone(orig: bigint): bigint {
27566 if(!isWasmInitialized) {
27567 throw new Error("initializeWasm() must be awaited first!");
27569 const nativeResponseValue = wasm.TS_PeerHandleError_clone(orig);
27570 return nativeResponseValue;
27572 // void PeerManager_free(struct LDKPeerManager this_obj);
27574 export function PeerManager_free(this_obj: bigint): void {
27575 if(!isWasmInitialized) {
27576 throw new Error("initializeWasm() must be awaited first!");
27578 const nativeResponseValue = wasm.TS_PeerManager_free(this_obj);
27579 // debug statements here
27581 // MUST_USE_RES struct LDKPeerManager PeerManager_new(struct LDKMessageHandler message_handler, struct LDKSecretKey our_node_secret, uint32_t current_time, const uint8_t (*ephemeral_random_data)[32], struct LDKLogger logger, struct LDKCustomMessageHandler custom_message_handler);
27583 export function PeerManager_new(message_handler: bigint, our_node_secret: number, current_time: number, ephemeral_random_data: number, logger: bigint, custom_message_handler: bigint): bigint {
27584 if(!isWasmInitialized) {
27585 throw new Error("initializeWasm() must be awaited first!");
27587 const nativeResponseValue = wasm.TS_PeerManager_new(message_handler, our_node_secret, current_time, ephemeral_random_data, logger, custom_message_handler);
27588 return nativeResponseValue;
27590 // MUST_USE_RES struct LDKCVec_PublicKeyZ PeerManager_get_peer_node_ids(const struct LDKPeerManager *NONNULL_PTR this_arg);
27592 export function PeerManager_get_peer_node_ids(this_arg: bigint): number {
27593 if(!isWasmInitialized) {
27594 throw new Error("initializeWasm() must be awaited first!");
27596 const nativeResponseValue = wasm.TS_PeerManager_get_peer_node_ids(this_arg);
27597 return nativeResponseValue;
27599 // 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);
27601 export function PeerManager_new_outbound_connection(this_arg: bigint, their_node_id: number, descriptor: bigint, remote_network_address: bigint): bigint {
27602 if(!isWasmInitialized) {
27603 throw new Error("initializeWasm() must be awaited first!");
27605 const nativeResponseValue = wasm.TS_PeerManager_new_outbound_connection(this_arg, their_node_id, descriptor, remote_network_address);
27606 return nativeResponseValue;
27608 // 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);
27610 export function PeerManager_new_inbound_connection(this_arg: bigint, descriptor: bigint, remote_network_address: bigint): bigint {
27611 if(!isWasmInitialized) {
27612 throw new Error("initializeWasm() must be awaited first!");
27614 const nativeResponseValue = wasm.TS_PeerManager_new_inbound_connection(this_arg, descriptor, remote_network_address);
27615 return nativeResponseValue;
27617 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_write_buffer_space_avail(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor *NONNULL_PTR descriptor);
27619 export function PeerManager_write_buffer_space_avail(this_arg: bigint, descriptor: bigint): bigint {
27620 if(!isWasmInitialized) {
27621 throw new Error("initializeWasm() must be awaited first!");
27623 const nativeResponseValue = wasm.TS_PeerManager_write_buffer_space_avail(this_arg, descriptor);
27624 return nativeResponseValue;
27626 // 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);
27628 export function PeerManager_read_event(this_arg: bigint, peer_descriptor: bigint, data: number): bigint {
27629 if(!isWasmInitialized) {
27630 throw new Error("initializeWasm() must be awaited first!");
27632 const nativeResponseValue = wasm.TS_PeerManager_read_event(this_arg, peer_descriptor, data);
27633 return nativeResponseValue;
27635 // void PeerManager_process_events(const struct LDKPeerManager *NONNULL_PTR this_arg);
27637 export function PeerManager_process_events(this_arg: bigint): void {
27638 if(!isWasmInitialized) {
27639 throw new Error("initializeWasm() must be awaited first!");
27641 const nativeResponseValue = wasm.TS_PeerManager_process_events(this_arg);
27642 // debug statements here
27644 // void PeerManager_socket_disconnected(const struct LDKPeerManager *NONNULL_PTR this_arg, const struct LDKSocketDescriptor *NONNULL_PTR descriptor);
27646 export function PeerManager_socket_disconnected(this_arg: bigint, descriptor: bigint): void {
27647 if(!isWasmInitialized) {
27648 throw new Error("initializeWasm() must be awaited first!");
27650 const nativeResponseValue = wasm.TS_PeerManager_socket_disconnected(this_arg, descriptor);
27651 // debug statements here
27653 // void PeerManager_disconnect_by_node_id(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id, bool no_connection_possible);
27655 export function PeerManager_disconnect_by_node_id(this_arg: bigint, node_id: number, no_connection_possible: boolean): void {
27656 if(!isWasmInitialized) {
27657 throw new Error("initializeWasm() must be awaited first!");
27659 const nativeResponseValue = wasm.TS_PeerManager_disconnect_by_node_id(this_arg, node_id, no_connection_possible);
27660 // debug statements here
27662 // void PeerManager_disconnect_all_peers(const struct LDKPeerManager *NONNULL_PTR this_arg);
27664 export function PeerManager_disconnect_all_peers(this_arg: bigint): void {
27665 if(!isWasmInitialized) {
27666 throw new Error("initializeWasm() must be awaited first!");
27668 const nativeResponseValue = wasm.TS_PeerManager_disconnect_all_peers(this_arg);
27669 // debug statements here
27671 // void PeerManager_timer_tick_occurred(const struct LDKPeerManager *NONNULL_PTR this_arg);
27673 export function PeerManager_timer_tick_occurred(this_arg: bigint): void {
27674 if(!isWasmInitialized) {
27675 throw new Error("initializeWasm() must be awaited first!");
27677 const nativeResponseValue = wasm.TS_PeerManager_timer_tick_occurred(this_arg);
27678 // debug statements here
27680 // void PeerManager_broadcast_node_announcement(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKThreeBytes rgb, struct LDKThirtyTwoBytes alias, struct LDKCVec_NetAddressZ addresses);
27682 export function PeerManager_broadcast_node_announcement(this_arg: bigint, rgb: number, alias: number, addresses: number): void {
27683 if(!isWasmInitialized) {
27684 throw new Error("initializeWasm() must be awaited first!");
27686 const nativeResponseValue = wasm.TS_PeerManager_broadcast_node_announcement(this_arg, rgb, alias, addresses);
27687 // debug statements here
27689 // uint64_t htlc_success_tx_weight(bool opt_anchors);
27691 export function htlc_success_tx_weight(opt_anchors: boolean): bigint {
27692 if(!isWasmInitialized) {
27693 throw new Error("initializeWasm() must be awaited first!");
27695 const nativeResponseValue = wasm.TS_htlc_success_tx_weight(opt_anchors);
27696 return nativeResponseValue;
27698 // uint64_t htlc_timeout_tx_weight(bool opt_anchors);
27700 export function htlc_timeout_tx_weight(opt_anchors: boolean): bigint {
27701 if(!isWasmInitialized) {
27702 throw new Error("initializeWasm() must be awaited first!");
27704 const nativeResponseValue = wasm.TS_htlc_timeout_tx_weight(opt_anchors);
27705 return nativeResponseValue;
27707 // struct LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx);
27709 export function build_commitment_secret(commitment_seed: number, idx: bigint): number {
27710 if(!isWasmInitialized) {
27711 throw new Error("initializeWasm() must be awaited first!");
27713 const nativeResponseValue = wasm.TS_build_commitment_secret(commitment_seed, idx);
27714 return nativeResponseValue;
27716 // 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);
27718 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 {
27719 if(!isWasmInitialized) {
27720 throw new Error("initializeWasm() must be awaited first!");
27722 const nativeResponseValue = wasm.TS_build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
27723 return nativeResponseValue;
27725 // void CounterpartyCommitmentSecrets_free(struct LDKCounterpartyCommitmentSecrets this_obj);
27727 export function CounterpartyCommitmentSecrets_free(this_obj: bigint): void {
27728 if(!isWasmInitialized) {
27729 throw new Error("initializeWasm() must be awaited first!");
27731 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_free(this_obj);
27732 // debug statements here
27734 // uint64_t CounterpartyCommitmentSecrets_clone_ptr(LDKCounterpartyCommitmentSecrets *NONNULL_PTR arg);
27736 export function CounterpartyCommitmentSecrets_clone_ptr(arg: bigint): bigint {
27737 if(!isWasmInitialized) {
27738 throw new Error("initializeWasm() must be awaited first!");
27740 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone_ptr(arg);
27741 return nativeResponseValue;
27743 // struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_clone(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR orig);
27745 export function CounterpartyCommitmentSecrets_clone(orig: bigint): bigint {
27746 if(!isWasmInitialized) {
27747 throw new Error("initializeWasm() must be awaited first!");
27749 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone(orig);
27750 return nativeResponseValue;
27752 // MUST_USE_RES struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_new(void);
27754 export function CounterpartyCommitmentSecrets_new(): bigint {
27755 if(!isWasmInitialized) {
27756 throw new Error("initializeWasm() must be awaited first!");
27758 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_new();
27759 return nativeResponseValue;
27761 // MUST_USE_RES uint64_t CounterpartyCommitmentSecrets_get_min_seen_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg);
27763 export function CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg: bigint): bigint {
27764 if(!isWasmInitialized) {
27765 throw new Error("initializeWasm() must be awaited first!");
27767 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg);
27768 return nativeResponseValue;
27770 // MUST_USE_RES struct LDKCResult_NoneNoneZ CounterpartyCommitmentSecrets_provide_secret(struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx, struct LDKThirtyTwoBytes secret);
27772 export function CounterpartyCommitmentSecrets_provide_secret(this_arg: bigint, idx: bigint, secret: number): bigint {
27773 if(!isWasmInitialized) {
27774 throw new Error("initializeWasm() must be awaited first!");
27776 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_provide_secret(this_arg, idx, secret);
27777 return nativeResponseValue;
27779 // MUST_USE_RES struct LDKThirtyTwoBytes CounterpartyCommitmentSecrets_get_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx);
27781 export function CounterpartyCommitmentSecrets_get_secret(this_arg: bigint, idx: bigint): number {
27782 if(!isWasmInitialized) {
27783 throw new Error("initializeWasm() must be awaited first!");
27785 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_secret(this_arg, idx);
27786 return nativeResponseValue;
27788 // struct LDKCVec_u8Z CounterpartyCommitmentSecrets_write(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR obj);
27790 export function CounterpartyCommitmentSecrets_write(obj: bigint): number {
27791 if(!isWasmInitialized) {
27792 throw new Error("initializeWasm() must be awaited first!");
27794 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_write(obj);
27795 return nativeResponseValue;
27797 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CounterpartyCommitmentSecrets_read(struct LDKu8slice ser);
27799 export function CounterpartyCommitmentSecrets_read(ser: number): bigint {
27800 if(!isWasmInitialized) {
27801 throw new Error("initializeWasm() must be awaited first!");
27803 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_read(ser);
27804 return nativeResponseValue;
27806 // struct LDKCResult_SecretKeyErrorZ derive_private_key(struct LDKPublicKey per_commitment_point, const uint8_t (*base_secret)[32]);
27808 export function derive_private_key(per_commitment_point: number, base_secret: number): bigint {
27809 if(!isWasmInitialized) {
27810 throw new Error("initializeWasm() must be awaited first!");
27812 const nativeResponseValue = wasm.TS_derive_private_key(per_commitment_point, base_secret);
27813 return nativeResponseValue;
27815 // struct LDKCResult_PublicKeyErrorZ derive_public_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey base_point);
27817 export function derive_public_key(per_commitment_point: number, base_point: number): bigint {
27818 if(!isWasmInitialized) {
27819 throw new Error("initializeWasm() must be awaited first!");
27821 const nativeResponseValue = wasm.TS_derive_public_key(per_commitment_point, base_point);
27822 return nativeResponseValue;
27824 // struct LDKCResult_SecretKeyErrorZ derive_private_revocation_key(const uint8_t (*per_commitment_secret)[32], const uint8_t (*countersignatory_revocation_base_secret)[32]);
27826 export function derive_private_revocation_key(per_commitment_secret: number, countersignatory_revocation_base_secret: number): bigint {
27827 if(!isWasmInitialized) {
27828 throw new Error("initializeWasm() must be awaited first!");
27830 const nativeResponseValue = wasm.TS_derive_private_revocation_key(per_commitment_secret, countersignatory_revocation_base_secret);
27831 return nativeResponseValue;
27833 // struct LDKCResult_PublicKeyErrorZ derive_public_revocation_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey countersignatory_revocation_base_point);
27835 export function derive_public_revocation_key(per_commitment_point: number, countersignatory_revocation_base_point: number): bigint {
27836 if(!isWasmInitialized) {
27837 throw new Error("initializeWasm() must be awaited first!");
27839 const nativeResponseValue = wasm.TS_derive_public_revocation_key(per_commitment_point, countersignatory_revocation_base_point);
27840 return nativeResponseValue;
27842 // void TxCreationKeys_free(struct LDKTxCreationKeys this_obj);
27844 export function TxCreationKeys_free(this_obj: bigint): void {
27845 if(!isWasmInitialized) {
27846 throw new Error("initializeWasm() must be awaited first!");
27848 const nativeResponseValue = wasm.TS_TxCreationKeys_free(this_obj);
27849 // debug statements here
27851 // struct LDKPublicKey TxCreationKeys_get_per_commitment_point(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
27853 export function TxCreationKeys_get_per_commitment_point(this_ptr: bigint): number {
27854 if(!isWasmInitialized) {
27855 throw new Error("initializeWasm() must be awaited first!");
27857 const nativeResponseValue = wasm.TS_TxCreationKeys_get_per_commitment_point(this_ptr);
27858 return nativeResponseValue;
27860 // void TxCreationKeys_set_per_commitment_point(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
27862 export function TxCreationKeys_set_per_commitment_point(this_ptr: bigint, val: number): void {
27863 if(!isWasmInitialized) {
27864 throw new Error("initializeWasm() must be awaited first!");
27866 const nativeResponseValue = wasm.TS_TxCreationKeys_set_per_commitment_point(this_ptr, val);
27867 // debug statements here
27869 // struct LDKPublicKey TxCreationKeys_get_revocation_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
27871 export function TxCreationKeys_get_revocation_key(this_ptr: bigint): number {
27872 if(!isWasmInitialized) {
27873 throw new Error("initializeWasm() must be awaited first!");
27875 const nativeResponseValue = wasm.TS_TxCreationKeys_get_revocation_key(this_ptr);
27876 return nativeResponseValue;
27878 // void TxCreationKeys_set_revocation_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
27880 export function TxCreationKeys_set_revocation_key(this_ptr: bigint, val: number): void {
27881 if(!isWasmInitialized) {
27882 throw new Error("initializeWasm() must be awaited first!");
27884 const nativeResponseValue = wasm.TS_TxCreationKeys_set_revocation_key(this_ptr, val);
27885 // debug statements here
27887 // struct LDKPublicKey TxCreationKeys_get_broadcaster_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
27889 export function TxCreationKeys_get_broadcaster_htlc_key(this_ptr: bigint): number {
27890 if(!isWasmInitialized) {
27891 throw new Error("initializeWasm() must be awaited first!");
27893 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_htlc_key(this_ptr);
27894 return nativeResponseValue;
27896 // void TxCreationKeys_set_broadcaster_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
27898 export function TxCreationKeys_set_broadcaster_htlc_key(this_ptr: bigint, val: number): void {
27899 if(!isWasmInitialized) {
27900 throw new Error("initializeWasm() must be awaited first!");
27902 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_htlc_key(this_ptr, val);
27903 // debug statements here
27905 // struct LDKPublicKey TxCreationKeys_get_countersignatory_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
27907 export function TxCreationKeys_get_countersignatory_htlc_key(this_ptr: bigint): number {
27908 if(!isWasmInitialized) {
27909 throw new Error("initializeWasm() must be awaited first!");
27911 const nativeResponseValue = wasm.TS_TxCreationKeys_get_countersignatory_htlc_key(this_ptr);
27912 return nativeResponseValue;
27914 // void TxCreationKeys_set_countersignatory_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
27916 export function TxCreationKeys_set_countersignatory_htlc_key(this_ptr: bigint, val: number): void {
27917 if(!isWasmInitialized) {
27918 throw new Error("initializeWasm() must be awaited first!");
27920 const nativeResponseValue = wasm.TS_TxCreationKeys_set_countersignatory_htlc_key(this_ptr, val);
27921 // debug statements here
27923 // struct LDKPublicKey TxCreationKeys_get_broadcaster_delayed_payment_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
27925 export function TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr: bigint): number {
27926 if(!isWasmInitialized) {
27927 throw new Error("initializeWasm() must be awaited first!");
27929 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr);
27930 return nativeResponseValue;
27932 // void TxCreationKeys_set_broadcaster_delayed_payment_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
27934 export function TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr: bigint, val: number): void {
27935 if(!isWasmInitialized) {
27936 throw new Error("initializeWasm() must be awaited first!");
27938 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr, val);
27939 // debug statements here
27941 // 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);
27943 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 {
27944 if(!isWasmInitialized) {
27945 throw new Error("initializeWasm() must be awaited first!");
27947 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);
27948 return nativeResponseValue;
27950 // bool TxCreationKeys_eq(const struct LDKTxCreationKeys *NONNULL_PTR a, const struct LDKTxCreationKeys *NONNULL_PTR b);
27952 export function TxCreationKeys_eq(a: bigint, b: bigint): boolean {
27953 if(!isWasmInitialized) {
27954 throw new Error("initializeWasm() must be awaited first!");
27956 const nativeResponseValue = wasm.TS_TxCreationKeys_eq(a, b);
27957 return nativeResponseValue;
27959 // uint64_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg);
27961 export function TxCreationKeys_clone_ptr(arg: bigint): bigint {
27962 if(!isWasmInitialized) {
27963 throw new Error("initializeWasm() must be awaited first!");
27965 const nativeResponseValue = wasm.TS_TxCreationKeys_clone_ptr(arg);
27966 return nativeResponseValue;
27968 // struct LDKTxCreationKeys TxCreationKeys_clone(const struct LDKTxCreationKeys *NONNULL_PTR orig);
27970 export function TxCreationKeys_clone(orig: bigint): bigint {
27971 if(!isWasmInitialized) {
27972 throw new Error("initializeWasm() must be awaited first!");
27974 const nativeResponseValue = wasm.TS_TxCreationKeys_clone(orig);
27975 return nativeResponseValue;
27977 // struct LDKCVec_u8Z TxCreationKeys_write(const struct LDKTxCreationKeys *NONNULL_PTR obj);
27979 export function TxCreationKeys_write(obj: bigint): number {
27980 if(!isWasmInitialized) {
27981 throw new Error("initializeWasm() must be awaited first!");
27983 const nativeResponseValue = wasm.TS_TxCreationKeys_write(obj);
27984 return nativeResponseValue;
27986 // struct LDKCResult_TxCreationKeysDecodeErrorZ TxCreationKeys_read(struct LDKu8slice ser);
27988 export function TxCreationKeys_read(ser: number): bigint {
27989 if(!isWasmInitialized) {
27990 throw new Error("initializeWasm() must be awaited first!");
27992 const nativeResponseValue = wasm.TS_TxCreationKeys_read(ser);
27993 return nativeResponseValue;
27995 // void ChannelPublicKeys_free(struct LDKChannelPublicKeys this_obj);
27997 export function ChannelPublicKeys_free(this_obj: bigint): void {
27998 if(!isWasmInitialized) {
27999 throw new Error("initializeWasm() must be awaited first!");
28001 const nativeResponseValue = wasm.TS_ChannelPublicKeys_free(this_obj);
28002 // debug statements here
28004 // struct LDKPublicKey ChannelPublicKeys_get_funding_pubkey(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
28006 export function ChannelPublicKeys_get_funding_pubkey(this_ptr: bigint): number {
28007 if(!isWasmInitialized) {
28008 throw new Error("initializeWasm() must be awaited first!");
28010 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_funding_pubkey(this_ptr);
28011 return nativeResponseValue;
28013 // void ChannelPublicKeys_set_funding_pubkey(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28015 export function ChannelPublicKeys_set_funding_pubkey(this_ptr: bigint, val: number): void {
28016 if(!isWasmInitialized) {
28017 throw new Error("initializeWasm() must be awaited first!");
28019 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_funding_pubkey(this_ptr, val);
28020 // debug statements here
28022 // struct LDKPublicKey ChannelPublicKeys_get_revocation_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
28024 export function ChannelPublicKeys_get_revocation_basepoint(this_ptr: bigint): number {
28025 if(!isWasmInitialized) {
28026 throw new Error("initializeWasm() must be awaited first!");
28028 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_revocation_basepoint(this_ptr);
28029 return nativeResponseValue;
28031 // void ChannelPublicKeys_set_revocation_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28033 export function ChannelPublicKeys_set_revocation_basepoint(this_ptr: bigint, val: number): void {
28034 if(!isWasmInitialized) {
28035 throw new Error("initializeWasm() must be awaited first!");
28037 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_revocation_basepoint(this_ptr, val);
28038 // debug statements here
28040 // struct LDKPublicKey ChannelPublicKeys_get_payment_point(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
28042 export function ChannelPublicKeys_get_payment_point(this_ptr: bigint): number {
28043 if(!isWasmInitialized) {
28044 throw new Error("initializeWasm() must be awaited first!");
28046 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_payment_point(this_ptr);
28047 return nativeResponseValue;
28049 // void ChannelPublicKeys_set_payment_point(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28051 export function ChannelPublicKeys_set_payment_point(this_ptr: bigint, val: number): void {
28052 if(!isWasmInitialized) {
28053 throw new Error("initializeWasm() must be awaited first!");
28055 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_payment_point(this_ptr, val);
28056 // debug statements here
28058 // struct LDKPublicKey ChannelPublicKeys_get_delayed_payment_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
28060 export function ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr: bigint): number {
28061 if(!isWasmInitialized) {
28062 throw new Error("initializeWasm() must be awaited first!");
28064 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr);
28065 return nativeResponseValue;
28067 // void ChannelPublicKeys_set_delayed_payment_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28069 export function ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
28070 if(!isWasmInitialized) {
28071 throw new Error("initializeWasm() must be awaited first!");
28073 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr, val);
28074 // debug statements here
28076 // struct LDKPublicKey ChannelPublicKeys_get_htlc_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
28078 export function ChannelPublicKeys_get_htlc_basepoint(this_ptr: bigint): number {
28079 if(!isWasmInitialized) {
28080 throw new Error("initializeWasm() must be awaited first!");
28082 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_htlc_basepoint(this_ptr);
28083 return nativeResponseValue;
28085 // void ChannelPublicKeys_set_htlc_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28087 export function ChannelPublicKeys_set_htlc_basepoint(this_ptr: bigint, val: number): void {
28088 if(!isWasmInitialized) {
28089 throw new Error("initializeWasm() must be awaited first!");
28091 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_htlc_basepoint(this_ptr, val);
28092 // debug statements here
28094 // 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);
28096 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 {
28097 if(!isWasmInitialized) {
28098 throw new Error("initializeWasm() must be awaited first!");
28100 const nativeResponseValue = wasm.TS_ChannelPublicKeys_new(funding_pubkey_arg, revocation_basepoint_arg, payment_point_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg);
28101 return nativeResponseValue;
28103 // uint64_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg);
28105 export function ChannelPublicKeys_clone_ptr(arg: bigint): bigint {
28106 if(!isWasmInitialized) {
28107 throw new Error("initializeWasm() must be awaited first!");
28109 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone_ptr(arg);
28110 return nativeResponseValue;
28112 // struct LDKChannelPublicKeys ChannelPublicKeys_clone(const struct LDKChannelPublicKeys *NONNULL_PTR orig);
28114 export function ChannelPublicKeys_clone(orig: bigint): bigint {
28115 if(!isWasmInitialized) {
28116 throw new Error("initializeWasm() must be awaited first!");
28118 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone(orig);
28119 return nativeResponseValue;
28121 // bool ChannelPublicKeys_eq(const struct LDKChannelPublicKeys *NONNULL_PTR a, const struct LDKChannelPublicKeys *NONNULL_PTR b);
28123 export function ChannelPublicKeys_eq(a: bigint, b: bigint): boolean {
28124 if(!isWasmInitialized) {
28125 throw new Error("initializeWasm() must be awaited first!");
28127 const nativeResponseValue = wasm.TS_ChannelPublicKeys_eq(a, b);
28128 return nativeResponseValue;
28130 // struct LDKCVec_u8Z ChannelPublicKeys_write(const struct LDKChannelPublicKeys *NONNULL_PTR obj);
28132 export function ChannelPublicKeys_write(obj: bigint): number {
28133 if(!isWasmInitialized) {
28134 throw new Error("initializeWasm() must be awaited first!");
28136 const nativeResponseValue = wasm.TS_ChannelPublicKeys_write(obj);
28137 return nativeResponseValue;
28139 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ ChannelPublicKeys_read(struct LDKu8slice ser);
28141 export function ChannelPublicKeys_read(ser: number): bigint {
28142 if(!isWasmInitialized) {
28143 throw new Error("initializeWasm() must be awaited first!");
28145 const nativeResponseValue = wasm.TS_ChannelPublicKeys_read(ser);
28146 return nativeResponseValue;
28148 // 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);
28150 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 {
28151 if(!isWasmInitialized) {
28152 throw new Error("initializeWasm() must be awaited first!");
28154 const nativeResponseValue = wasm.TS_TxCreationKeys_derive_new(per_commitment_point, broadcaster_delayed_payment_base, broadcaster_htlc_base, countersignatory_revocation_base, countersignatory_htlc_base);
28155 return nativeResponseValue;
28157 // 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);
28159 export function TxCreationKeys_from_channel_static_keys(per_commitment_point: number, broadcaster_keys: bigint, countersignatory_keys: bigint): bigint {
28160 if(!isWasmInitialized) {
28161 throw new Error("initializeWasm() must be awaited first!");
28163 const nativeResponseValue = wasm.TS_TxCreationKeys_from_channel_static_keys(per_commitment_point, broadcaster_keys, countersignatory_keys);
28164 return nativeResponseValue;
28166 // struct LDKCVec_u8Z get_revokeable_redeemscript(struct LDKPublicKey revocation_key, uint16_t contest_delay, struct LDKPublicKey broadcaster_delayed_payment_key);
28168 export function get_revokeable_redeemscript(revocation_key: number, contest_delay: number, broadcaster_delayed_payment_key: number): number {
28169 if(!isWasmInitialized) {
28170 throw new Error("initializeWasm() must be awaited first!");
28172 const nativeResponseValue = wasm.TS_get_revokeable_redeemscript(revocation_key, contest_delay, broadcaster_delayed_payment_key);
28173 return nativeResponseValue;
28175 // void HTLCOutputInCommitment_free(struct LDKHTLCOutputInCommitment this_obj);
28177 export function HTLCOutputInCommitment_free(this_obj: bigint): void {
28178 if(!isWasmInitialized) {
28179 throw new Error("initializeWasm() must be awaited first!");
28181 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_free(this_obj);
28182 // debug statements here
28184 // bool HTLCOutputInCommitment_get_offered(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
28186 export function HTLCOutputInCommitment_get_offered(this_ptr: bigint): boolean {
28187 if(!isWasmInitialized) {
28188 throw new Error("initializeWasm() must be awaited first!");
28190 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_offered(this_ptr);
28191 return nativeResponseValue;
28193 // void HTLCOutputInCommitment_set_offered(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, bool val);
28195 export function HTLCOutputInCommitment_set_offered(this_ptr: bigint, val: boolean): void {
28196 if(!isWasmInitialized) {
28197 throw new Error("initializeWasm() must be awaited first!");
28199 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_offered(this_ptr, val);
28200 // debug statements here
28202 // uint64_t HTLCOutputInCommitment_get_amount_msat(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
28204 export function HTLCOutputInCommitment_get_amount_msat(this_ptr: bigint): bigint {
28205 if(!isWasmInitialized) {
28206 throw new Error("initializeWasm() must be awaited first!");
28208 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_amount_msat(this_ptr);
28209 return nativeResponseValue;
28211 // void HTLCOutputInCommitment_set_amount_msat(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint64_t val);
28213 export function HTLCOutputInCommitment_set_amount_msat(this_ptr: bigint, val: bigint): void {
28214 if(!isWasmInitialized) {
28215 throw new Error("initializeWasm() must be awaited first!");
28217 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_amount_msat(this_ptr, val);
28218 // debug statements here
28220 // uint32_t HTLCOutputInCommitment_get_cltv_expiry(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
28222 export function HTLCOutputInCommitment_get_cltv_expiry(this_ptr: bigint): number {
28223 if(!isWasmInitialized) {
28224 throw new Error("initializeWasm() must be awaited first!");
28226 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_cltv_expiry(this_ptr);
28227 return nativeResponseValue;
28229 // void HTLCOutputInCommitment_set_cltv_expiry(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint32_t val);
28231 export function HTLCOutputInCommitment_set_cltv_expiry(this_ptr: bigint, val: number): void {
28232 if(!isWasmInitialized) {
28233 throw new Error("initializeWasm() must be awaited first!");
28235 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_cltv_expiry(this_ptr, val);
28236 // debug statements here
28238 // const uint8_t (*HTLCOutputInCommitment_get_payment_hash(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr))[32];
28240 export function HTLCOutputInCommitment_get_payment_hash(this_ptr: bigint): number {
28241 if(!isWasmInitialized) {
28242 throw new Error("initializeWasm() must be awaited first!");
28244 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_payment_hash(this_ptr);
28245 return nativeResponseValue;
28247 // void HTLCOutputInCommitment_set_payment_hash(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
28249 export function HTLCOutputInCommitment_set_payment_hash(this_ptr: bigint, val: number): void {
28250 if(!isWasmInitialized) {
28251 throw new Error("initializeWasm() must be awaited first!");
28253 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_payment_hash(this_ptr, val);
28254 // debug statements here
28256 // struct LDKCOption_u32Z HTLCOutputInCommitment_get_transaction_output_index(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
28258 export function HTLCOutputInCommitment_get_transaction_output_index(this_ptr: bigint): bigint {
28259 if(!isWasmInitialized) {
28260 throw new Error("initializeWasm() must be awaited first!");
28262 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_transaction_output_index(this_ptr);
28263 return nativeResponseValue;
28265 // void HTLCOutputInCommitment_set_transaction_output_index(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
28267 export function HTLCOutputInCommitment_set_transaction_output_index(this_ptr: bigint, val: bigint): void {
28268 if(!isWasmInitialized) {
28269 throw new Error("initializeWasm() must be awaited first!");
28271 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_transaction_output_index(this_ptr, val);
28272 // debug statements here
28274 // 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);
28276 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 {
28277 if(!isWasmInitialized) {
28278 throw new Error("initializeWasm() must be awaited first!");
28280 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg, transaction_output_index_arg);
28281 return nativeResponseValue;
28283 // uint64_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg);
28285 export function HTLCOutputInCommitment_clone_ptr(arg: bigint): bigint {
28286 if(!isWasmInitialized) {
28287 throw new Error("initializeWasm() must be awaited first!");
28289 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone_ptr(arg);
28290 return nativeResponseValue;
28292 // struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_clone(const struct LDKHTLCOutputInCommitment *NONNULL_PTR orig);
28294 export function HTLCOutputInCommitment_clone(orig: bigint): bigint {
28295 if(!isWasmInitialized) {
28296 throw new Error("initializeWasm() must be awaited first!");
28298 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone(orig);
28299 return nativeResponseValue;
28301 // bool HTLCOutputInCommitment_eq(const struct LDKHTLCOutputInCommitment *NONNULL_PTR a, const struct LDKHTLCOutputInCommitment *NONNULL_PTR b);
28303 export function HTLCOutputInCommitment_eq(a: bigint, b: bigint): boolean {
28304 if(!isWasmInitialized) {
28305 throw new Error("initializeWasm() must be awaited first!");
28307 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_eq(a, b);
28308 return nativeResponseValue;
28310 // struct LDKCVec_u8Z HTLCOutputInCommitment_write(const struct LDKHTLCOutputInCommitment *NONNULL_PTR obj);
28312 export function HTLCOutputInCommitment_write(obj: bigint): number {
28313 if(!isWasmInitialized) {
28314 throw new Error("initializeWasm() must be awaited first!");
28316 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_write(obj);
28317 return nativeResponseValue;
28319 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ HTLCOutputInCommitment_read(struct LDKu8slice ser);
28321 export function HTLCOutputInCommitment_read(ser: number): bigint {
28322 if(!isWasmInitialized) {
28323 throw new Error("initializeWasm() must be awaited first!");
28325 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_read(ser);
28326 return nativeResponseValue;
28328 // struct LDKCVec_u8Z get_htlc_redeemscript(const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc, bool opt_anchors, const struct LDKTxCreationKeys *NONNULL_PTR keys);
28330 export function get_htlc_redeemscript(htlc: bigint, opt_anchors: boolean, keys: bigint): number {
28331 if(!isWasmInitialized) {
28332 throw new Error("initializeWasm() must be awaited first!");
28334 const nativeResponseValue = wasm.TS_get_htlc_redeemscript(htlc, opt_anchors, keys);
28335 return nativeResponseValue;
28337 // struct LDKCVec_u8Z make_funding_redeemscript(struct LDKPublicKey broadcaster, struct LDKPublicKey countersignatory);
28339 export function make_funding_redeemscript(broadcaster: number, countersignatory: number): number {
28340 if(!isWasmInitialized) {
28341 throw new Error("initializeWasm() must be awaited first!");
28343 const nativeResponseValue = wasm.TS_make_funding_redeemscript(broadcaster, countersignatory);
28344 return nativeResponseValue;
28346 // 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);
28348 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 {
28349 if(!isWasmInitialized) {
28350 throw new Error("initializeWasm() must be awaited first!");
28352 const nativeResponseValue = wasm.TS_build_htlc_transaction(commitment_txid, feerate_per_kw, contest_delay, htlc, opt_anchors, broadcaster_delayed_payment_key, revocation_key);
28353 return nativeResponseValue;
28355 // struct LDKCVec_u8Z get_anchor_redeemscript(struct LDKPublicKey funding_pubkey);
28357 export function get_anchor_redeemscript(funding_pubkey: number): number {
28358 if(!isWasmInitialized) {
28359 throw new Error("initializeWasm() must be awaited first!");
28361 const nativeResponseValue = wasm.TS_get_anchor_redeemscript(funding_pubkey);
28362 return nativeResponseValue;
28364 // void ChannelTransactionParameters_free(struct LDKChannelTransactionParameters this_obj);
28366 export function ChannelTransactionParameters_free(this_obj: bigint): void {
28367 if(!isWasmInitialized) {
28368 throw new Error("initializeWasm() must be awaited first!");
28370 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_free(this_obj);
28371 // debug statements here
28373 // struct LDKChannelPublicKeys ChannelTransactionParameters_get_holder_pubkeys(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
28375 export function ChannelTransactionParameters_get_holder_pubkeys(this_ptr: bigint): bigint {
28376 if(!isWasmInitialized) {
28377 throw new Error("initializeWasm() must be awaited first!");
28379 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_pubkeys(this_ptr);
28380 return nativeResponseValue;
28382 // void ChannelTransactionParameters_set_holder_pubkeys(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
28384 export function ChannelTransactionParameters_set_holder_pubkeys(this_ptr: bigint, val: bigint): void {
28385 if(!isWasmInitialized) {
28386 throw new Error("initializeWasm() must be awaited first!");
28388 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_pubkeys(this_ptr, val);
28389 // debug statements here
28391 // uint16_t ChannelTransactionParameters_get_holder_selected_contest_delay(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
28393 export function ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr: bigint): number {
28394 if(!isWasmInitialized) {
28395 throw new Error("initializeWasm() must be awaited first!");
28397 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr);
28398 return nativeResponseValue;
28400 // void ChannelTransactionParameters_set_holder_selected_contest_delay(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
28402 export function ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr: bigint, val: number): void {
28403 if(!isWasmInitialized) {
28404 throw new Error("initializeWasm() must be awaited first!");
28406 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr, val);
28407 // debug statements here
28409 // bool ChannelTransactionParameters_get_is_outbound_from_holder(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
28411 export function ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr: bigint): boolean {
28412 if(!isWasmInitialized) {
28413 throw new Error("initializeWasm() must be awaited first!");
28415 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr);
28416 return nativeResponseValue;
28418 // void ChannelTransactionParameters_set_is_outbound_from_holder(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, bool val);
28420 export function ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr: bigint, val: boolean): void {
28421 if(!isWasmInitialized) {
28422 throw new Error("initializeWasm() must be awaited first!");
28424 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr, val);
28425 // debug statements here
28427 // struct LDKCounterpartyChannelTransactionParameters ChannelTransactionParameters_get_counterparty_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
28429 export function ChannelTransactionParameters_get_counterparty_parameters(this_ptr: bigint): bigint {
28430 if(!isWasmInitialized) {
28431 throw new Error("initializeWasm() must be awaited first!");
28433 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_counterparty_parameters(this_ptr);
28434 return nativeResponseValue;
28436 // void ChannelTransactionParameters_set_counterparty_parameters(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKCounterpartyChannelTransactionParameters val);
28438 export function ChannelTransactionParameters_set_counterparty_parameters(this_ptr: bigint, val: bigint): void {
28439 if(!isWasmInitialized) {
28440 throw new Error("initializeWasm() must be awaited first!");
28442 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_counterparty_parameters(this_ptr, val);
28443 // debug statements here
28445 // struct LDKOutPoint ChannelTransactionParameters_get_funding_outpoint(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
28447 export function ChannelTransactionParameters_get_funding_outpoint(this_ptr: bigint): bigint {
28448 if(!isWasmInitialized) {
28449 throw new Error("initializeWasm() must be awaited first!");
28451 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_funding_outpoint(this_ptr);
28452 return nativeResponseValue;
28454 // void ChannelTransactionParameters_set_funding_outpoint(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKOutPoint val);
28456 export function ChannelTransactionParameters_set_funding_outpoint(this_ptr: bigint, val: bigint): void {
28457 if(!isWasmInitialized) {
28458 throw new Error("initializeWasm() must be awaited first!");
28460 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_funding_outpoint(this_ptr, val);
28461 // debug statements here
28463 // enum LDKCOption_NoneZ ChannelTransactionParameters_get_opt_anchors(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
28465 export function ChannelTransactionParameters_get_opt_anchors(this_ptr: bigint): COption_NoneZ {
28466 if(!isWasmInitialized) {
28467 throw new Error("initializeWasm() must be awaited first!");
28469 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_opt_anchors(this_ptr);
28470 return nativeResponseValue;
28472 // void ChannelTransactionParameters_set_opt_anchors(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
28474 export function ChannelTransactionParameters_set_opt_anchors(this_ptr: bigint, val: COption_NoneZ): void {
28475 if(!isWasmInitialized) {
28476 throw new Error("initializeWasm() must be awaited first!");
28478 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_opt_anchors(this_ptr, val);
28479 // debug statements here
28481 // 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);
28483 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 {
28484 if(!isWasmInitialized) {
28485 throw new Error("initializeWasm() must be awaited first!");
28487 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);
28488 return nativeResponseValue;
28490 // uint64_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg);
28492 export function ChannelTransactionParameters_clone_ptr(arg: bigint): bigint {
28493 if(!isWasmInitialized) {
28494 throw new Error("initializeWasm() must be awaited first!");
28496 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone_ptr(arg);
28497 return nativeResponseValue;
28499 // struct LDKChannelTransactionParameters ChannelTransactionParameters_clone(const struct LDKChannelTransactionParameters *NONNULL_PTR orig);
28501 export function ChannelTransactionParameters_clone(orig: bigint): bigint {
28502 if(!isWasmInitialized) {
28503 throw new Error("initializeWasm() must be awaited first!");
28505 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone(orig);
28506 return nativeResponseValue;
28508 // void CounterpartyChannelTransactionParameters_free(struct LDKCounterpartyChannelTransactionParameters this_obj);
28510 export function CounterpartyChannelTransactionParameters_free(this_obj: bigint): void {
28511 if(!isWasmInitialized) {
28512 throw new Error("initializeWasm() must be awaited first!");
28514 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_free(this_obj);
28515 // debug statements here
28517 // struct LDKChannelPublicKeys CounterpartyChannelTransactionParameters_get_pubkeys(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
28519 export function CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr: bigint): bigint {
28520 if(!isWasmInitialized) {
28521 throw new Error("initializeWasm() must be awaited first!");
28523 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr);
28524 return nativeResponseValue;
28526 // void CounterpartyChannelTransactionParameters_set_pubkeys(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
28528 export function CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr: bigint, val: bigint): void {
28529 if(!isWasmInitialized) {
28530 throw new Error("initializeWasm() must be awaited first!");
28532 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr, val);
28533 // debug statements here
28535 // uint16_t CounterpartyChannelTransactionParameters_get_selected_contest_delay(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
28537 export function CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr: bigint): number {
28538 if(!isWasmInitialized) {
28539 throw new Error("initializeWasm() must be awaited first!");
28541 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr);
28542 return nativeResponseValue;
28544 // void CounterpartyChannelTransactionParameters_set_selected_contest_delay(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
28546 export function CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr: bigint, val: number): void {
28547 if(!isWasmInitialized) {
28548 throw new Error("initializeWasm() must be awaited first!");
28550 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr, val);
28551 // debug statements here
28553 // MUST_USE_RES struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_new(struct LDKChannelPublicKeys pubkeys_arg, uint16_t selected_contest_delay_arg);
28555 export function CounterpartyChannelTransactionParameters_new(pubkeys_arg: bigint, selected_contest_delay_arg: number): bigint {
28556 if(!isWasmInitialized) {
28557 throw new Error("initializeWasm() must be awaited first!");
28559 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_new(pubkeys_arg, selected_contest_delay_arg);
28560 return nativeResponseValue;
28562 // uint64_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg);
28564 export function CounterpartyChannelTransactionParameters_clone_ptr(arg: bigint): bigint {
28565 if(!isWasmInitialized) {
28566 throw new Error("initializeWasm() must be awaited first!");
28568 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone_ptr(arg);
28569 return nativeResponseValue;
28571 // struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_clone(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR orig);
28573 export function CounterpartyChannelTransactionParameters_clone(orig: bigint): bigint {
28574 if(!isWasmInitialized) {
28575 throw new Error("initializeWasm() must be awaited first!");
28577 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone(orig);
28578 return nativeResponseValue;
28580 // MUST_USE_RES bool ChannelTransactionParameters_is_populated(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
28582 export function ChannelTransactionParameters_is_populated(this_arg: bigint): boolean {
28583 if(!isWasmInitialized) {
28584 throw new Error("initializeWasm() must be awaited first!");
28586 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_is_populated(this_arg);
28587 return nativeResponseValue;
28589 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_holder_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
28591 export function ChannelTransactionParameters_as_holder_broadcastable(this_arg: bigint): bigint {
28592 if(!isWasmInitialized) {
28593 throw new Error("initializeWasm() must be awaited first!");
28595 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_holder_broadcastable(this_arg);
28596 return nativeResponseValue;
28598 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_counterparty_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
28600 export function ChannelTransactionParameters_as_counterparty_broadcastable(this_arg: bigint): bigint {
28601 if(!isWasmInitialized) {
28602 throw new Error("initializeWasm() must be awaited first!");
28604 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_counterparty_broadcastable(this_arg);
28605 return nativeResponseValue;
28607 // struct LDKCVec_u8Z CounterpartyChannelTransactionParameters_write(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR obj);
28609 export function CounterpartyChannelTransactionParameters_write(obj: bigint): number {
28610 if(!isWasmInitialized) {
28611 throw new Error("initializeWasm() must be awaited first!");
28613 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_write(obj);
28614 return nativeResponseValue;
28616 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CounterpartyChannelTransactionParameters_read(struct LDKu8slice ser);
28618 export function CounterpartyChannelTransactionParameters_read(ser: number): bigint {
28619 if(!isWasmInitialized) {
28620 throw new Error("initializeWasm() must be awaited first!");
28622 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_read(ser);
28623 return nativeResponseValue;
28625 // struct LDKCVec_u8Z ChannelTransactionParameters_write(const struct LDKChannelTransactionParameters *NONNULL_PTR obj);
28627 export function ChannelTransactionParameters_write(obj: bigint): number {
28628 if(!isWasmInitialized) {
28629 throw new Error("initializeWasm() must be awaited first!");
28631 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_write(obj);
28632 return nativeResponseValue;
28634 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ ChannelTransactionParameters_read(struct LDKu8slice ser);
28636 export function ChannelTransactionParameters_read(ser: number): bigint {
28637 if(!isWasmInitialized) {
28638 throw new Error("initializeWasm() must be awaited first!");
28640 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_read(ser);
28641 return nativeResponseValue;
28643 // void DirectedChannelTransactionParameters_free(struct LDKDirectedChannelTransactionParameters this_obj);
28645 export function DirectedChannelTransactionParameters_free(this_obj: bigint): void {
28646 if(!isWasmInitialized) {
28647 throw new Error("initializeWasm() must be awaited first!");
28649 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_free(this_obj);
28650 // debug statements here
28652 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_broadcaster_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
28654 export function DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg: bigint): bigint {
28655 if(!isWasmInitialized) {
28656 throw new Error("initializeWasm() must be awaited first!");
28658 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg);
28659 return nativeResponseValue;
28661 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_countersignatory_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
28663 export function DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg: bigint): bigint {
28664 if(!isWasmInitialized) {
28665 throw new Error("initializeWasm() must be awaited first!");
28667 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg);
28668 return nativeResponseValue;
28670 // MUST_USE_RES uint16_t DirectedChannelTransactionParameters_contest_delay(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
28672 export function DirectedChannelTransactionParameters_contest_delay(this_arg: bigint): number {
28673 if(!isWasmInitialized) {
28674 throw new Error("initializeWasm() must be awaited first!");
28676 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_contest_delay(this_arg);
28677 return nativeResponseValue;
28679 // MUST_USE_RES bool DirectedChannelTransactionParameters_is_outbound(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
28681 export function DirectedChannelTransactionParameters_is_outbound(this_arg: bigint): boolean {
28682 if(!isWasmInitialized) {
28683 throw new Error("initializeWasm() must be awaited first!");
28685 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_is_outbound(this_arg);
28686 return nativeResponseValue;
28688 // MUST_USE_RES struct LDKOutPoint DirectedChannelTransactionParameters_funding_outpoint(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
28690 export function DirectedChannelTransactionParameters_funding_outpoint(this_arg: bigint): bigint {
28691 if(!isWasmInitialized) {
28692 throw new Error("initializeWasm() must be awaited first!");
28694 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_funding_outpoint(this_arg);
28695 return nativeResponseValue;
28697 // MUST_USE_RES bool DirectedChannelTransactionParameters_opt_anchors(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
28699 export function DirectedChannelTransactionParameters_opt_anchors(this_arg: bigint): boolean {
28700 if(!isWasmInitialized) {
28701 throw new Error("initializeWasm() must be awaited first!");
28703 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_opt_anchors(this_arg);
28704 return nativeResponseValue;
28706 // void HolderCommitmentTransaction_free(struct LDKHolderCommitmentTransaction this_obj);
28708 export function HolderCommitmentTransaction_free(this_obj: bigint): void {
28709 if(!isWasmInitialized) {
28710 throw new Error("initializeWasm() must be awaited first!");
28712 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_free(this_obj);
28713 // debug statements here
28715 // struct LDKSignature HolderCommitmentTransaction_get_counterparty_sig(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
28717 export function HolderCommitmentTransaction_get_counterparty_sig(this_ptr: bigint): number {
28718 if(!isWasmInitialized) {
28719 throw new Error("initializeWasm() must be awaited first!");
28721 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_sig(this_ptr);
28722 return nativeResponseValue;
28724 // void HolderCommitmentTransaction_set_counterparty_sig(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKSignature val);
28726 export function HolderCommitmentTransaction_set_counterparty_sig(this_ptr: bigint, val: number): void {
28727 if(!isWasmInitialized) {
28728 throw new Error("initializeWasm() must be awaited first!");
28730 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_sig(this_ptr, val);
28731 // debug statements here
28733 // struct LDKCVec_SignatureZ HolderCommitmentTransaction_get_counterparty_htlc_sigs(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
28735 export function HolderCommitmentTransaction_get_counterparty_htlc_sigs(this_ptr: bigint): number {
28736 if(!isWasmInitialized) {
28737 throw new Error("initializeWasm() must be awaited first!");
28739 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_htlc_sigs(this_ptr);
28740 return nativeResponseValue;
28742 // void HolderCommitmentTransaction_set_counterparty_htlc_sigs(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
28744 export function HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr: bigint, val: number): void {
28745 if(!isWasmInitialized) {
28746 throw new Error("initializeWasm() must be awaited first!");
28748 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr, val);
28749 // debug statements here
28751 // uint64_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg);
28753 export function HolderCommitmentTransaction_clone_ptr(arg: bigint): bigint {
28754 if(!isWasmInitialized) {
28755 throw new Error("initializeWasm() must be awaited first!");
28757 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone_ptr(arg);
28758 return nativeResponseValue;
28760 // struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_clone(const struct LDKHolderCommitmentTransaction *NONNULL_PTR orig);
28762 export function HolderCommitmentTransaction_clone(orig: bigint): bigint {
28763 if(!isWasmInitialized) {
28764 throw new Error("initializeWasm() must be awaited first!");
28766 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone(orig);
28767 return nativeResponseValue;
28769 // struct LDKCVec_u8Z HolderCommitmentTransaction_write(const struct LDKHolderCommitmentTransaction *NONNULL_PTR obj);
28771 export function HolderCommitmentTransaction_write(obj: bigint): number {
28772 if(!isWasmInitialized) {
28773 throw new Error("initializeWasm() must be awaited first!");
28775 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_write(obj);
28776 return nativeResponseValue;
28778 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ HolderCommitmentTransaction_read(struct LDKu8slice ser);
28780 export function HolderCommitmentTransaction_read(ser: number): bigint {
28781 if(!isWasmInitialized) {
28782 throw new Error("initializeWasm() must be awaited first!");
28784 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_read(ser);
28785 return nativeResponseValue;
28787 // 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);
28789 export function HolderCommitmentTransaction_new(commitment_tx: bigint, counterparty_sig: number, counterparty_htlc_sigs: number, holder_funding_key: number, counterparty_funding_key: number): bigint {
28790 if(!isWasmInitialized) {
28791 throw new Error("initializeWasm() must be awaited first!");
28793 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_new(commitment_tx, counterparty_sig, counterparty_htlc_sigs, holder_funding_key, counterparty_funding_key);
28794 return nativeResponseValue;
28796 // void BuiltCommitmentTransaction_free(struct LDKBuiltCommitmentTransaction this_obj);
28798 export function BuiltCommitmentTransaction_free(this_obj: bigint): void {
28799 if(!isWasmInitialized) {
28800 throw new Error("initializeWasm() must be awaited first!");
28802 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_free(this_obj);
28803 // debug statements here
28805 // struct LDKTransaction BuiltCommitmentTransaction_get_transaction(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr);
28807 export function BuiltCommitmentTransaction_get_transaction(this_ptr: bigint): number {
28808 if(!isWasmInitialized) {
28809 throw new Error("initializeWasm() must be awaited first!");
28811 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_transaction(this_ptr);
28812 return nativeResponseValue;
28814 // void BuiltCommitmentTransaction_set_transaction(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKTransaction val);
28816 export function BuiltCommitmentTransaction_set_transaction(this_ptr: bigint, val: number): void {
28817 if(!isWasmInitialized) {
28818 throw new Error("initializeWasm() must be awaited first!");
28820 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_transaction(this_ptr, val);
28821 // debug statements here
28823 // const uint8_t (*BuiltCommitmentTransaction_get_txid(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr))[32];
28825 export function BuiltCommitmentTransaction_get_txid(this_ptr: bigint): number {
28826 if(!isWasmInitialized) {
28827 throw new Error("initializeWasm() must be awaited first!");
28829 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_txid(this_ptr);
28830 return nativeResponseValue;
28832 // void BuiltCommitmentTransaction_set_txid(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
28834 export function BuiltCommitmentTransaction_set_txid(this_ptr: bigint, val: number): void {
28835 if(!isWasmInitialized) {
28836 throw new Error("initializeWasm() must be awaited first!");
28838 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_txid(this_ptr, val);
28839 // debug statements here
28841 // MUST_USE_RES struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_new(struct LDKTransaction transaction_arg, struct LDKThirtyTwoBytes txid_arg);
28843 export function BuiltCommitmentTransaction_new(transaction_arg: number, txid_arg: number): bigint {
28844 if(!isWasmInitialized) {
28845 throw new Error("initializeWasm() must be awaited first!");
28847 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_new(transaction_arg, txid_arg);
28848 return nativeResponseValue;
28850 // uint64_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg);
28852 export function BuiltCommitmentTransaction_clone_ptr(arg: bigint): bigint {
28853 if(!isWasmInitialized) {
28854 throw new Error("initializeWasm() must be awaited first!");
28856 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone_ptr(arg);
28857 return nativeResponseValue;
28859 // struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_clone(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR orig);
28861 export function BuiltCommitmentTransaction_clone(orig: bigint): bigint {
28862 if(!isWasmInitialized) {
28863 throw new Error("initializeWasm() must be awaited first!");
28865 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone(orig);
28866 return nativeResponseValue;
28868 // struct LDKCVec_u8Z BuiltCommitmentTransaction_write(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR obj);
28870 export function BuiltCommitmentTransaction_write(obj: bigint): number {
28871 if(!isWasmInitialized) {
28872 throw new Error("initializeWasm() must be awaited first!");
28874 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_write(obj);
28875 return nativeResponseValue;
28877 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ BuiltCommitmentTransaction_read(struct LDKu8slice ser);
28879 export function BuiltCommitmentTransaction_read(ser: number): bigint {
28880 if(!isWasmInitialized) {
28881 throw new Error("initializeWasm() must be awaited first!");
28883 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_read(ser);
28884 return nativeResponseValue;
28886 // 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);
28888 export function BuiltCommitmentTransaction_get_sighash_all(this_arg: bigint, funding_redeemscript: number, channel_value_satoshis: bigint): number {
28889 if(!isWasmInitialized) {
28890 throw new Error("initializeWasm() must be awaited first!");
28892 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
28893 return nativeResponseValue;
28895 // 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);
28897 export function BuiltCommitmentTransaction_sign(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
28898 if(!isWasmInitialized) {
28899 throw new Error("initializeWasm() must be awaited first!");
28901 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
28902 return nativeResponseValue;
28904 // void ClosingTransaction_free(struct LDKClosingTransaction this_obj);
28906 export function ClosingTransaction_free(this_obj: bigint): void {
28907 if(!isWasmInitialized) {
28908 throw new Error("initializeWasm() must be awaited first!");
28910 const nativeResponseValue = wasm.TS_ClosingTransaction_free(this_obj);
28911 // debug statements here
28913 // uint64_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg);
28915 export function ClosingTransaction_clone_ptr(arg: bigint): bigint {
28916 if(!isWasmInitialized) {
28917 throw new Error("initializeWasm() must be awaited first!");
28919 const nativeResponseValue = wasm.TS_ClosingTransaction_clone_ptr(arg);
28920 return nativeResponseValue;
28922 // struct LDKClosingTransaction ClosingTransaction_clone(const struct LDKClosingTransaction *NONNULL_PTR orig);
28924 export function ClosingTransaction_clone(orig: bigint): bigint {
28925 if(!isWasmInitialized) {
28926 throw new Error("initializeWasm() must be awaited first!");
28928 const nativeResponseValue = wasm.TS_ClosingTransaction_clone(orig);
28929 return nativeResponseValue;
28931 // uint64_t ClosingTransaction_hash(const struct LDKClosingTransaction *NONNULL_PTR o);
28933 export function ClosingTransaction_hash(o: bigint): bigint {
28934 if(!isWasmInitialized) {
28935 throw new Error("initializeWasm() must be awaited first!");
28937 const nativeResponseValue = wasm.TS_ClosingTransaction_hash(o);
28938 return nativeResponseValue;
28940 // bool ClosingTransaction_eq(const struct LDKClosingTransaction *NONNULL_PTR a, const struct LDKClosingTransaction *NONNULL_PTR b);
28942 export function ClosingTransaction_eq(a: bigint, b: bigint): boolean {
28943 if(!isWasmInitialized) {
28944 throw new Error("initializeWasm() must be awaited first!");
28946 const nativeResponseValue = wasm.TS_ClosingTransaction_eq(a, b);
28947 return nativeResponseValue;
28949 // 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);
28951 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 {
28952 if(!isWasmInitialized) {
28953 throw new Error("initializeWasm() must be awaited first!");
28955 const nativeResponseValue = wasm.TS_ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
28956 return nativeResponseValue;
28958 // MUST_USE_RES struct LDKTrustedClosingTransaction ClosingTransaction_trust(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
28960 export function ClosingTransaction_trust(this_arg: bigint): bigint {
28961 if(!isWasmInitialized) {
28962 throw new Error("initializeWasm() must be awaited first!");
28964 const nativeResponseValue = wasm.TS_ClosingTransaction_trust(this_arg);
28965 return nativeResponseValue;
28967 // MUST_USE_RES struct LDKCResult_TrustedClosingTransactionNoneZ ClosingTransaction_verify(const struct LDKClosingTransaction *NONNULL_PTR this_arg, struct LDKOutPoint funding_outpoint);
28969 export function ClosingTransaction_verify(this_arg: bigint, funding_outpoint: bigint): bigint {
28970 if(!isWasmInitialized) {
28971 throw new Error("initializeWasm() must be awaited first!");
28973 const nativeResponseValue = wasm.TS_ClosingTransaction_verify(this_arg, funding_outpoint);
28974 return nativeResponseValue;
28976 // MUST_USE_RES uint64_t ClosingTransaction_to_holder_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
28978 export function ClosingTransaction_to_holder_value_sat(this_arg: bigint): bigint {
28979 if(!isWasmInitialized) {
28980 throw new Error("initializeWasm() must be awaited first!");
28982 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_value_sat(this_arg);
28983 return nativeResponseValue;
28985 // MUST_USE_RES uint64_t ClosingTransaction_to_counterparty_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
28987 export function ClosingTransaction_to_counterparty_value_sat(this_arg: bigint): bigint {
28988 if(!isWasmInitialized) {
28989 throw new Error("initializeWasm() must be awaited first!");
28991 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_value_sat(this_arg);
28992 return nativeResponseValue;
28994 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_holder_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
28996 export function ClosingTransaction_to_holder_script(this_arg: bigint): number {
28997 if(!isWasmInitialized) {
28998 throw new Error("initializeWasm() must be awaited first!");
29000 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_script(this_arg);
29001 return nativeResponseValue;
29003 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_counterparty_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
29005 export function ClosingTransaction_to_counterparty_script(this_arg: bigint): number {
29006 if(!isWasmInitialized) {
29007 throw new Error("initializeWasm() must be awaited first!");
29009 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_script(this_arg);
29010 return nativeResponseValue;
29012 // void TrustedClosingTransaction_free(struct LDKTrustedClosingTransaction this_obj);
29014 export function TrustedClosingTransaction_free(this_obj: bigint): void {
29015 if(!isWasmInitialized) {
29016 throw new Error("initializeWasm() must be awaited first!");
29018 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_free(this_obj);
29019 // debug statements here
29021 // MUST_USE_RES struct LDKTransaction TrustedClosingTransaction_built_transaction(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg);
29023 export function TrustedClosingTransaction_built_transaction(this_arg: bigint): number {
29024 if(!isWasmInitialized) {
29025 throw new Error("initializeWasm() must be awaited first!");
29027 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_built_transaction(this_arg);
29028 return nativeResponseValue;
29030 // 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);
29032 export function TrustedClosingTransaction_get_sighash_all(this_arg: bigint, funding_redeemscript: number, channel_value_satoshis: bigint): number {
29033 if(!isWasmInitialized) {
29034 throw new Error("initializeWasm() must be awaited first!");
29036 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
29037 return nativeResponseValue;
29039 // 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);
29041 export function TrustedClosingTransaction_sign(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
29042 if(!isWasmInitialized) {
29043 throw new Error("initializeWasm() must be awaited first!");
29045 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
29046 return nativeResponseValue;
29048 // void CommitmentTransaction_free(struct LDKCommitmentTransaction this_obj);
29050 export function CommitmentTransaction_free(this_obj: bigint): void {
29051 if(!isWasmInitialized) {
29052 throw new Error("initializeWasm() must be awaited first!");
29054 const nativeResponseValue = wasm.TS_CommitmentTransaction_free(this_obj);
29055 // debug statements here
29057 // uint64_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg);
29059 export function CommitmentTransaction_clone_ptr(arg: bigint): bigint {
29060 if(!isWasmInitialized) {
29061 throw new Error("initializeWasm() must be awaited first!");
29063 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone_ptr(arg);
29064 return nativeResponseValue;
29066 // struct LDKCommitmentTransaction CommitmentTransaction_clone(const struct LDKCommitmentTransaction *NONNULL_PTR orig);
29068 export function CommitmentTransaction_clone(orig: bigint): bigint {
29069 if(!isWasmInitialized) {
29070 throw new Error("initializeWasm() must be awaited first!");
29072 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone(orig);
29073 return nativeResponseValue;
29075 // struct LDKCVec_u8Z CommitmentTransaction_write(const struct LDKCommitmentTransaction *NONNULL_PTR obj);
29077 export function CommitmentTransaction_write(obj: bigint): number {
29078 if(!isWasmInitialized) {
29079 throw new Error("initializeWasm() must be awaited first!");
29081 const nativeResponseValue = wasm.TS_CommitmentTransaction_write(obj);
29082 return nativeResponseValue;
29084 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CommitmentTransaction_read(struct LDKu8slice ser);
29086 export function CommitmentTransaction_read(ser: number): bigint {
29087 if(!isWasmInitialized) {
29088 throw new Error("initializeWasm() must be awaited first!");
29090 const nativeResponseValue = wasm.TS_CommitmentTransaction_read(ser);
29091 return nativeResponseValue;
29093 // MUST_USE_RES uint64_t CommitmentTransaction_commitment_number(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
29095 export function CommitmentTransaction_commitment_number(this_arg: bigint): bigint {
29096 if(!isWasmInitialized) {
29097 throw new Error("initializeWasm() must be awaited first!");
29099 const nativeResponseValue = wasm.TS_CommitmentTransaction_commitment_number(this_arg);
29100 return nativeResponseValue;
29102 // MUST_USE_RES uint64_t CommitmentTransaction_to_broadcaster_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
29104 export function CommitmentTransaction_to_broadcaster_value_sat(this_arg: bigint): bigint {
29105 if(!isWasmInitialized) {
29106 throw new Error("initializeWasm() must be awaited first!");
29108 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_broadcaster_value_sat(this_arg);
29109 return nativeResponseValue;
29111 // MUST_USE_RES uint64_t CommitmentTransaction_to_countersignatory_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
29113 export function CommitmentTransaction_to_countersignatory_value_sat(this_arg: bigint): bigint {
29114 if(!isWasmInitialized) {
29115 throw new Error("initializeWasm() must be awaited first!");
29117 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_countersignatory_value_sat(this_arg);
29118 return nativeResponseValue;
29120 // MUST_USE_RES uint32_t CommitmentTransaction_feerate_per_kw(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
29122 export function CommitmentTransaction_feerate_per_kw(this_arg: bigint): number {
29123 if(!isWasmInitialized) {
29124 throw new Error("initializeWasm() must be awaited first!");
29126 const nativeResponseValue = wasm.TS_CommitmentTransaction_feerate_per_kw(this_arg);
29127 return nativeResponseValue;
29129 // MUST_USE_RES struct LDKTrustedCommitmentTransaction CommitmentTransaction_trust(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
29131 export function CommitmentTransaction_trust(this_arg: bigint): bigint {
29132 if(!isWasmInitialized) {
29133 throw new Error("initializeWasm() must be awaited first!");
29135 const nativeResponseValue = wasm.TS_CommitmentTransaction_trust(this_arg);
29136 return nativeResponseValue;
29138 // 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);
29140 export function CommitmentTransaction_verify(this_arg: bigint, channel_parameters: bigint, broadcaster_keys: bigint, countersignatory_keys: bigint): bigint {
29141 if(!isWasmInitialized) {
29142 throw new Error("initializeWasm() must be awaited first!");
29144 const nativeResponseValue = wasm.TS_CommitmentTransaction_verify(this_arg, channel_parameters, broadcaster_keys, countersignatory_keys);
29145 return nativeResponseValue;
29147 // void TrustedCommitmentTransaction_free(struct LDKTrustedCommitmentTransaction this_obj);
29149 export function TrustedCommitmentTransaction_free(this_obj: bigint): void {
29150 if(!isWasmInitialized) {
29151 throw new Error("initializeWasm() must be awaited first!");
29153 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_free(this_obj);
29154 // debug statements here
29156 // MUST_USE_RES struct LDKThirtyTwoBytes TrustedCommitmentTransaction_txid(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
29158 export function TrustedCommitmentTransaction_txid(this_arg: bigint): number {
29159 if(!isWasmInitialized) {
29160 throw new Error("initializeWasm() must be awaited first!");
29162 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_txid(this_arg);
29163 return nativeResponseValue;
29165 // MUST_USE_RES struct LDKBuiltCommitmentTransaction TrustedCommitmentTransaction_built_transaction(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
29167 export function TrustedCommitmentTransaction_built_transaction(this_arg: bigint): bigint {
29168 if(!isWasmInitialized) {
29169 throw new Error("initializeWasm() must be awaited first!");
29171 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_built_transaction(this_arg);
29172 return nativeResponseValue;
29174 // MUST_USE_RES struct LDKTxCreationKeys TrustedCommitmentTransaction_keys(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
29176 export function TrustedCommitmentTransaction_keys(this_arg: bigint): bigint {
29177 if(!isWasmInitialized) {
29178 throw new Error("initializeWasm() must be awaited first!");
29180 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_keys(this_arg);
29181 return nativeResponseValue;
29183 // MUST_USE_RES bool TrustedCommitmentTransaction_opt_anchors(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
29185 export function TrustedCommitmentTransaction_opt_anchors(this_arg: bigint): boolean {
29186 if(!isWasmInitialized) {
29187 throw new Error("initializeWasm() must be awaited first!");
29189 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_opt_anchors(this_arg);
29190 return nativeResponseValue;
29192 // 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);
29194 export function TrustedCommitmentTransaction_get_htlc_sigs(this_arg: bigint, htlc_base_key: number, channel_parameters: bigint): bigint {
29195 if(!isWasmInitialized) {
29196 throw new Error("initializeWasm() must be awaited first!");
29198 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_get_htlc_sigs(this_arg, htlc_base_key, channel_parameters);
29199 return nativeResponseValue;
29201 // uint64_t get_commitment_transaction_number_obscure_factor(struct LDKPublicKey broadcaster_payment_basepoint, struct LDKPublicKey countersignatory_payment_basepoint, bool outbound_from_broadcaster);
29203 export function get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint: number, countersignatory_payment_basepoint: number, outbound_from_broadcaster: boolean): bigint {
29204 if(!isWasmInitialized) {
29205 throw new Error("initializeWasm() must be awaited first!");
29207 const nativeResponseValue = wasm.TS_get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint, countersignatory_payment_basepoint, outbound_from_broadcaster);
29208 return nativeResponseValue;
29210 // bool InitFeatures_eq(const struct LDKInitFeatures *NONNULL_PTR a, const struct LDKInitFeatures *NONNULL_PTR b);
29212 export function InitFeatures_eq(a: bigint, b: bigint): boolean {
29213 if(!isWasmInitialized) {
29214 throw new Error("initializeWasm() must be awaited first!");
29216 const nativeResponseValue = wasm.TS_InitFeatures_eq(a, b);
29217 return nativeResponseValue;
29219 // bool NodeFeatures_eq(const struct LDKNodeFeatures *NONNULL_PTR a, const struct LDKNodeFeatures *NONNULL_PTR b);
29221 export function NodeFeatures_eq(a: bigint, b: bigint): boolean {
29222 if(!isWasmInitialized) {
29223 throw new Error("initializeWasm() must be awaited first!");
29225 const nativeResponseValue = wasm.TS_NodeFeatures_eq(a, b);
29226 return nativeResponseValue;
29228 // bool ChannelFeatures_eq(const struct LDKChannelFeatures *NONNULL_PTR a, const struct LDKChannelFeatures *NONNULL_PTR b);
29230 export function ChannelFeatures_eq(a: bigint, b: bigint): boolean {
29231 if(!isWasmInitialized) {
29232 throw new Error("initializeWasm() must be awaited first!");
29234 const nativeResponseValue = wasm.TS_ChannelFeatures_eq(a, b);
29235 return nativeResponseValue;
29237 // bool InvoiceFeatures_eq(const struct LDKInvoiceFeatures *NONNULL_PTR a, const struct LDKInvoiceFeatures *NONNULL_PTR b);
29239 export function InvoiceFeatures_eq(a: bigint, b: bigint): boolean {
29240 if(!isWasmInitialized) {
29241 throw new Error("initializeWasm() must be awaited first!");
29243 const nativeResponseValue = wasm.TS_InvoiceFeatures_eq(a, b);
29244 return nativeResponseValue;
29246 // bool ChannelTypeFeatures_eq(const struct LDKChannelTypeFeatures *NONNULL_PTR a, const struct LDKChannelTypeFeatures *NONNULL_PTR b);
29248 export function ChannelTypeFeatures_eq(a: bigint, b: bigint): boolean {
29249 if(!isWasmInitialized) {
29250 throw new Error("initializeWasm() must be awaited first!");
29252 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_eq(a, b);
29253 return nativeResponseValue;
29255 // uint64_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg);
29257 export function InitFeatures_clone_ptr(arg: bigint): bigint {
29258 if(!isWasmInitialized) {
29259 throw new Error("initializeWasm() must be awaited first!");
29261 const nativeResponseValue = wasm.TS_InitFeatures_clone_ptr(arg);
29262 return nativeResponseValue;
29264 // struct LDKInitFeatures InitFeatures_clone(const struct LDKInitFeatures *NONNULL_PTR orig);
29266 export function InitFeatures_clone(orig: bigint): bigint {
29267 if(!isWasmInitialized) {
29268 throw new Error("initializeWasm() must be awaited first!");
29270 const nativeResponseValue = wasm.TS_InitFeatures_clone(orig);
29271 return nativeResponseValue;
29273 // uint64_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg);
29275 export function NodeFeatures_clone_ptr(arg: bigint): bigint {
29276 if(!isWasmInitialized) {
29277 throw new Error("initializeWasm() must be awaited first!");
29279 const nativeResponseValue = wasm.TS_NodeFeatures_clone_ptr(arg);
29280 return nativeResponseValue;
29282 // struct LDKNodeFeatures NodeFeatures_clone(const struct LDKNodeFeatures *NONNULL_PTR orig);
29284 export function NodeFeatures_clone(orig: bigint): bigint {
29285 if(!isWasmInitialized) {
29286 throw new Error("initializeWasm() must be awaited first!");
29288 const nativeResponseValue = wasm.TS_NodeFeatures_clone(orig);
29289 return nativeResponseValue;
29291 // uint64_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg);
29293 export function ChannelFeatures_clone_ptr(arg: bigint): bigint {
29294 if(!isWasmInitialized) {
29295 throw new Error("initializeWasm() must be awaited first!");
29297 const nativeResponseValue = wasm.TS_ChannelFeatures_clone_ptr(arg);
29298 return nativeResponseValue;
29300 // struct LDKChannelFeatures ChannelFeatures_clone(const struct LDKChannelFeatures *NONNULL_PTR orig);
29302 export function ChannelFeatures_clone(orig: bigint): bigint {
29303 if(!isWasmInitialized) {
29304 throw new Error("initializeWasm() must be awaited first!");
29306 const nativeResponseValue = wasm.TS_ChannelFeatures_clone(orig);
29307 return nativeResponseValue;
29309 // uint64_t InvoiceFeatures_clone_ptr(LDKInvoiceFeatures *NONNULL_PTR arg);
29311 export function InvoiceFeatures_clone_ptr(arg: bigint): bigint {
29312 if(!isWasmInitialized) {
29313 throw new Error("initializeWasm() must be awaited first!");
29315 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone_ptr(arg);
29316 return nativeResponseValue;
29318 // struct LDKInvoiceFeatures InvoiceFeatures_clone(const struct LDKInvoiceFeatures *NONNULL_PTR orig);
29320 export function InvoiceFeatures_clone(orig: bigint): bigint {
29321 if(!isWasmInitialized) {
29322 throw new Error("initializeWasm() must be awaited first!");
29324 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone(orig);
29325 return nativeResponseValue;
29327 // uint64_t ChannelTypeFeatures_clone_ptr(LDKChannelTypeFeatures *NONNULL_PTR arg);
29329 export function ChannelTypeFeatures_clone_ptr(arg: bigint): bigint {
29330 if(!isWasmInitialized) {
29331 throw new Error("initializeWasm() must be awaited first!");
29333 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone_ptr(arg);
29334 return nativeResponseValue;
29336 // struct LDKChannelTypeFeatures ChannelTypeFeatures_clone(const struct LDKChannelTypeFeatures *NONNULL_PTR orig);
29338 export function ChannelTypeFeatures_clone(orig: bigint): bigint {
29339 if(!isWasmInitialized) {
29340 throw new Error("initializeWasm() must be awaited first!");
29342 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone(orig);
29343 return nativeResponseValue;
29345 // void InitFeatures_free(struct LDKInitFeatures this_obj);
29347 export function InitFeatures_free(this_obj: bigint): void {
29348 if(!isWasmInitialized) {
29349 throw new Error("initializeWasm() must be awaited first!");
29351 const nativeResponseValue = wasm.TS_InitFeatures_free(this_obj);
29352 // debug statements here
29354 // void NodeFeatures_free(struct LDKNodeFeatures this_obj);
29356 export function NodeFeatures_free(this_obj: bigint): void {
29357 if(!isWasmInitialized) {
29358 throw new Error("initializeWasm() must be awaited first!");
29360 const nativeResponseValue = wasm.TS_NodeFeatures_free(this_obj);
29361 // debug statements here
29363 // void ChannelFeatures_free(struct LDKChannelFeatures this_obj);
29365 export function ChannelFeatures_free(this_obj: bigint): void {
29366 if(!isWasmInitialized) {
29367 throw new Error("initializeWasm() must be awaited first!");
29369 const nativeResponseValue = wasm.TS_ChannelFeatures_free(this_obj);
29370 // debug statements here
29372 // void InvoiceFeatures_free(struct LDKInvoiceFeatures this_obj);
29374 export function InvoiceFeatures_free(this_obj: bigint): void {
29375 if(!isWasmInitialized) {
29376 throw new Error("initializeWasm() must be awaited first!");
29378 const nativeResponseValue = wasm.TS_InvoiceFeatures_free(this_obj);
29379 // debug statements here
29381 // void ChannelTypeFeatures_free(struct LDKChannelTypeFeatures this_obj);
29383 export function ChannelTypeFeatures_free(this_obj: bigint): void {
29384 if(!isWasmInitialized) {
29385 throw new Error("initializeWasm() must be awaited first!");
29387 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_free(this_obj);
29388 // debug statements here
29390 // MUST_USE_RES struct LDKInitFeatures InitFeatures_empty(void);
29392 export function InitFeatures_empty(): bigint {
29393 if(!isWasmInitialized) {
29394 throw new Error("initializeWasm() must be awaited first!");
29396 const nativeResponseValue = wasm.TS_InitFeatures_empty();
29397 return nativeResponseValue;
29399 // MUST_USE_RES bool InitFeatures_requires_unknown_bits(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29401 export function InitFeatures_requires_unknown_bits(this_arg: bigint): boolean {
29402 if(!isWasmInitialized) {
29403 throw new Error("initializeWasm() must be awaited first!");
29405 const nativeResponseValue = wasm.TS_InitFeatures_requires_unknown_bits(this_arg);
29406 return nativeResponseValue;
29408 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_empty(void);
29410 export function NodeFeatures_empty(): bigint {
29411 if(!isWasmInitialized) {
29412 throw new Error("initializeWasm() must be awaited first!");
29414 const nativeResponseValue = wasm.TS_NodeFeatures_empty();
29415 return nativeResponseValue;
29417 // MUST_USE_RES bool NodeFeatures_requires_unknown_bits(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29419 export function NodeFeatures_requires_unknown_bits(this_arg: bigint): boolean {
29420 if(!isWasmInitialized) {
29421 throw new Error("initializeWasm() must be awaited first!");
29423 const nativeResponseValue = wasm.TS_NodeFeatures_requires_unknown_bits(this_arg);
29424 return nativeResponseValue;
29426 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_empty(void);
29428 export function ChannelFeatures_empty(): bigint {
29429 if(!isWasmInitialized) {
29430 throw new Error("initializeWasm() must be awaited first!");
29432 const nativeResponseValue = wasm.TS_ChannelFeatures_empty();
29433 return nativeResponseValue;
29435 // MUST_USE_RES bool ChannelFeatures_requires_unknown_bits(const struct LDKChannelFeatures *NONNULL_PTR this_arg);
29437 export function ChannelFeatures_requires_unknown_bits(this_arg: bigint): boolean {
29438 if(!isWasmInitialized) {
29439 throw new Error("initializeWasm() must be awaited first!");
29441 const nativeResponseValue = wasm.TS_ChannelFeatures_requires_unknown_bits(this_arg);
29442 return nativeResponseValue;
29444 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_empty(void);
29446 export function InvoiceFeatures_empty(): bigint {
29447 if(!isWasmInitialized) {
29448 throw new Error("initializeWasm() must be awaited first!");
29450 const nativeResponseValue = wasm.TS_InvoiceFeatures_empty();
29451 return nativeResponseValue;
29453 // MUST_USE_RES bool InvoiceFeatures_requires_unknown_bits(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
29455 export function InvoiceFeatures_requires_unknown_bits(this_arg: bigint): boolean {
29456 if(!isWasmInitialized) {
29457 throw new Error("initializeWasm() must be awaited first!");
29459 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_unknown_bits(this_arg);
29460 return nativeResponseValue;
29462 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_empty(void);
29464 export function ChannelTypeFeatures_empty(): bigint {
29465 if(!isWasmInitialized) {
29466 throw new Error("initializeWasm() must be awaited first!");
29468 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_empty();
29469 return nativeResponseValue;
29471 // MUST_USE_RES bool ChannelTypeFeatures_requires_unknown_bits(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
29473 export function ChannelTypeFeatures_requires_unknown_bits(this_arg: bigint): boolean {
29474 if(!isWasmInitialized) {
29475 throw new Error("initializeWasm() must be awaited first!");
29477 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_unknown_bits(this_arg);
29478 return nativeResponseValue;
29480 // struct LDKCVec_u8Z InitFeatures_write(const struct LDKInitFeatures *NONNULL_PTR obj);
29482 export function InitFeatures_write(obj: bigint): number {
29483 if(!isWasmInitialized) {
29484 throw new Error("initializeWasm() must be awaited first!");
29486 const nativeResponseValue = wasm.TS_InitFeatures_write(obj);
29487 return nativeResponseValue;
29489 // struct LDKCResult_InitFeaturesDecodeErrorZ InitFeatures_read(struct LDKu8slice ser);
29491 export function InitFeatures_read(ser: number): bigint {
29492 if(!isWasmInitialized) {
29493 throw new Error("initializeWasm() must be awaited first!");
29495 const nativeResponseValue = wasm.TS_InitFeatures_read(ser);
29496 return nativeResponseValue;
29498 // struct LDKCVec_u8Z ChannelFeatures_write(const struct LDKChannelFeatures *NONNULL_PTR obj);
29500 export function ChannelFeatures_write(obj: bigint): number {
29501 if(!isWasmInitialized) {
29502 throw new Error("initializeWasm() must be awaited first!");
29504 const nativeResponseValue = wasm.TS_ChannelFeatures_write(obj);
29505 return nativeResponseValue;
29507 // struct LDKCResult_ChannelFeaturesDecodeErrorZ ChannelFeatures_read(struct LDKu8slice ser);
29509 export function ChannelFeatures_read(ser: number): bigint {
29510 if(!isWasmInitialized) {
29511 throw new Error("initializeWasm() must be awaited first!");
29513 const nativeResponseValue = wasm.TS_ChannelFeatures_read(ser);
29514 return nativeResponseValue;
29516 // struct LDKCVec_u8Z NodeFeatures_write(const struct LDKNodeFeatures *NONNULL_PTR obj);
29518 export function NodeFeatures_write(obj: bigint): number {
29519 if(!isWasmInitialized) {
29520 throw new Error("initializeWasm() must be awaited first!");
29522 const nativeResponseValue = wasm.TS_NodeFeatures_write(obj);
29523 return nativeResponseValue;
29525 // struct LDKCResult_NodeFeaturesDecodeErrorZ NodeFeatures_read(struct LDKu8slice ser);
29527 export function NodeFeatures_read(ser: number): bigint {
29528 if(!isWasmInitialized) {
29529 throw new Error("initializeWasm() must be awaited first!");
29531 const nativeResponseValue = wasm.TS_NodeFeatures_read(ser);
29532 return nativeResponseValue;
29534 // struct LDKCVec_u8Z InvoiceFeatures_write(const struct LDKInvoiceFeatures *NONNULL_PTR obj);
29536 export function InvoiceFeatures_write(obj: bigint): number {
29537 if(!isWasmInitialized) {
29538 throw new Error("initializeWasm() must be awaited first!");
29540 const nativeResponseValue = wasm.TS_InvoiceFeatures_write(obj);
29541 return nativeResponseValue;
29543 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ InvoiceFeatures_read(struct LDKu8slice ser);
29545 export function InvoiceFeatures_read(ser: number): bigint {
29546 if(!isWasmInitialized) {
29547 throw new Error("initializeWasm() must be awaited first!");
29549 const nativeResponseValue = wasm.TS_InvoiceFeatures_read(ser);
29550 return nativeResponseValue;
29552 // struct LDKCVec_u8Z ChannelTypeFeatures_write(const struct LDKChannelTypeFeatures *NONNULL_PTR obj);
29554 export function ChannelTypeFeatures_write(obj: bigint): number {
29555 if(!isWasmInitialized) {
29556 throw new Error("initializeWasm() must be awaited first!");
29558 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_write(obj);
29559 return nativeResponseValue;
29561 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ ChannelTypeFeatures_read(struct LDKu8slice ser);
29563 export function ChannelTypeFeatures_read(ser: number): bigint {
29564 if(!isWasmInitialized) {
29565 throw new Error("initializeWasm() must be awaited first!");
29567 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_read(ser);
29568 return nativeResponseValue;
29570 // void InitFeatures_set_data_loss_protect_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
29572 export function InitFeatures_set_data_loss_protect_optional(this_arg: bigint): void {
29573 if(!isWasmInitialized) {
29574 throw new Error("initializeWasm() must be awaited first!");
29576 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_optional(this_arg);
29577 // debug statements here
29579 // void InitFeatures_set_data_loss_protect_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
29581 export function InitFeatures_set_data_loss_protect_required(this_arg: bigint): void {
29582 if(!isWasmInitialized) {
29583 throw new Error("initializeWasm() must be awaited first!");
29585 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_required(this_arg);
29586 // debug statements here
29588 // MUST_USE_RES bool InitFeatures_supports_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29590 export function InitFeatures_supports_data_loss_protect(this_arg: bigint): boolean {
29591 if(!isWasmInitialized) {
29592 throw new Error("initializeWasm() must be awaited first!");
29594 const nativeResponseValue = wasm.TS_InitFeatures_supports_data_loss_protect(this_arg);
29595 return nativeResponseValue;
29597 // void NodeFeatures_set_data_loss_protect_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29599 export function NodeFeatures_set_data_loss_protect_optional(this_arg: bigint): void {
29600 if(!isWasmInitialized) {
29601 throw new Error("initializeWasm() must be awaited first!");
29603 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_optional(this_arg);
29604 // debug statements here
29606 // void NodeFeatures_set_data_loss_protect_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29608 export function NodeFeatures_set_data_loss_protect_required(this_arg: bigint): void {
29609 if(!isWasmInitialized) {
29610 throw new Error("initializeWasm() must be awaited first!");
29612 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_required(this_arg);
29613 // debug statements here
29615 // MUST_USE_RES bool NodeFeatures_supports_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29617 export function NodeFeatures_supports_data_loss_protect(this_arg: bigint): boolean {
29618 if(!isWasmInitialized) {
29619 throw new Error("initializeWasm() must be awaited first!");
29621 const nativeResponseValue = wasm.TS_NodeFeatures_supports_data_loss_protect(this_arg);
29622 return nativeResponseValue;
29624 // MUST_USE_RES bool InitFeatures_requires_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29626 export function InitFeatures_requires_data_loss_protect(this_arg: bigint): boolean {
29627 if(!isWasmInitialized) {
29628 throw new Error("initializeWasm() must be awaited first!");
29630 const nativeResponseValue = wasm.TS_InitFeatures_requires_data_loss_protect(this_arg);
29631 return nativeResponseValue;
29633 // MUST_USE_RES bool NodeFeatures_requires_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29635 export function NodeFeatures_requires_data_loss_protect(this_arg: bigint): boolean {
29636 if(!isWasmInitialized) {
29637 throw new Error("initializeWasm() must be awaited first!");
29639 const nativeResponseValue = wasm.TS_NodeFeatures_requires_data_loss_protect(this_arg);
29640 return nativeResponseValue;
29642 // void InitFeatures_set_initial_routing_sync_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
29644 export function InitFeatures_set_initial_routing_sync_optional(this_arg: bigint): void {
29645 if(!isWasmInitialized) {
29646 throw new Error("initializeWasm() must be awaited first!");
29648 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_optional(this_arg);
29649 // debug statements here
29651 // void InitFeatures_set_initial_routing_sync_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
29653 export function InitFeatures_set_initial_routing_sync_required(this_arg: bigint): void {
29654 if(!isWasmInitialized) {
29655 throw new Error("initializeWasm() must be awaited first!");
29657 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_required(this_arg);
29658 // debug statements here
29660 // MUST_USE_RES bool InitFeatures_initial_routing_sync(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29662 export function InitFeatures_initial_routing_sync(this_arg: bigint): boolean {
29663 if(!isWasmInitialized) {
29664 throw new Error("initializeWasm() must be awaited first!");
29666 const nativeResponseValue = wasm.TS_InitFeatures_initial_routing_sync(this_arg);
29667 return nativeResponseValue;
29669 // void InitFeatures_set_upfront_shutdown_script_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
29671 export function InitFeatures_set_upfront_shutdown_script_optional(this_arg: bigint): void {
29672 if(!isWasmInitialized) {
29673 throw new Error("initializeWasm() must be awaited first!");
29675 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_optional(this_arg);
29676 // debug statements here
29678 // void InitFeatures_set_upfront_shutdown_script_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
29680 export function InitFeatures_set_upfront_shutdown_script_required(this_arg: bigint): void {
29681 if(!isWasmInitialized) {
29682 throw new Error("initializeWasm() must be awaited first!");
29684 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_required(this_arg);
29685 // debug statements here
29687 // MUST_USE_RES bool InitFeatures_supports_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29689 export function InitFeatures_supports_upfront_shutdown_script(this_arg: bigint): boolean {
29690 if(!isWasmInitialized) {
29691 throw new Error("initializeWasm() must be awaited first!");
29693 const nativeResponseValue = wasm.TS_InitFeatures_supports_upfront_shutdown_script(this_arg);
29694 return nativeResponseValue;
29696 // void NodeFeatures_set_upfront_shutdown_script_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29698 export function NodeFeatures_set_upfront_shutdown_script_optional(this_arg: bigint): void {
29699 if(!isWasmInitialized) {
29700 throw new Error("initializeWasm() must be awaited first!");
29702 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_optional(this_arg);
29703 // debug statements here
29705 // void NodeFeatures_set_upfront_shutdown_script_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29707 export function NodeFeatures_set_upfront_shutdown_script_required(this_arg: bigint): void {
29708 if(!isWasmInitialized) {
29709 throw new Error("initializeWasm() must be awaited first!");
29711 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_required(this_arg);
29712 // debug statements here
29714 // MUST_USE_RES bool NodeFeatures_supports_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29716 export function NodeFeatures_supports_upfront_shutdown_script(this_arg: bigint): boolean {
29717 if(!isWasmInitialized) {
29718 throw new Error("initializeWasm() must be awaited first!");
29720 const nativeResponseValue = wasm.TS_NodeFeatures_supports_upfront_shutdown_script(this_arg);
29721 return nativeResponseValue;
29723 // MUST_USE_RES bool InitFeatures_requires_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29725 export function InitFeatures_requires_upfront_shutdown_script(this_arg: bigint): boolean {
29726 if(!isWasmInitialized) {
29727 throw new Error("initializeWasm() must be awaited first!");
29729 const nativeResponseValue = wasm.TS_InitFeatures_requires_upfront_shutdown_script(this_arg);
29730 return nativeResponseValue;
29732 // MUST_USE_RES bool NodeFeatures_requires_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29734 export function NodeFeatures_requires_upfront_shutdown_script(this_arg: bigint): boolean {
29735 if(!isWasmInitialized) {
29736 throw new Error("initializeWasm() must be awaited first!");
29738 const nativeResponseValue = wasm.TS_NodeFeatures_requires_upfront_shutdown_script(this_arg);
29739 return nativeResponseValue;
29741 // void InitFeatures_set_gossip_queries_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
29743 export function InitFeatures_set_gossip_queries_optional(this_arg: bigint): void {
29744 if(!isWasmInitialized) {
29745 throw new Error("initializeWasm() must be awaited first!");
29747 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_optional(this_arg);
29748 // debug statements here
29750 // void InitFeatures_set_gossip_queries_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
29752 export function InitFeatures_set_gossip_queries_required(this_arg: bigint): void {
29753 if(!isWasmInitialized) {
29754 throw new Error("initializeWasm() must be awaited first!");
29756 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_required(this_arg);
29757 // debug statements here
29759 // MUST_USE_RES bool InitFeatures_supports_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29761 export function InitFeatures_supports_gossip_queries(this_arg: bigint): boolean {
29762 if(!isWasmInitialized) {
29763 throw new Error("initializeWasm() must be awaited first!");
29765 const nativeResponseValue = wasm.TS_InitFeatures_supports_gossip_queries(this_arg);
29766 return nativeResponseValue;
29768 // void NodeFeatures_set_gossip_queries_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29770 export function NodeFeatures_set_gossip_queries_optional(this_arg: bigint): void {
29771 if(!isWasmInitialized) {
29772 throw new Error("initializeWasm() must be awaited first!");
29774 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_optional(this_arg);
29775 // debug statements here
29777 // void NodeFeatures_set_gossip_queries_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29779 export function NodeFeatures_set_gossip_queries_required(this_arg: bigint): void {
29780 if(!isWasmInitialized) {
29781 throw new Error("initializeWasm() must be awaited first!");
29783 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_required(this_arg);
29784 // debug statements here
29786 // MUST_USE_RES bool NodeFeatures_supports_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29788 export function NodeFeatures_supports_gossip_queries(this_arg: bigint): boolean {
29789 if(!isWasmInitialized) {
29790 throw new Error("initializeWasm() must be awaited first!");
29792 const nativeResponseValue = wasm.TS_NodeFeatures_supports_gossip_queries(this_arg);
29793 return nativeResponseValue;
29795 // MUST_USE_RES bool InitFeatures_requires_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29797 export function InitFeatures_requires_gossip_queries(this_arg: bigint): boolean {
29798 if(!isWasmInitialized) {
29799 throw new Error("initializeWasm() must be awaited first!");
29801 const nativeResponseValue = wasm.TS_InitFeatures_requires_gossip_queries(this_arg);
29802 return nativeResponseValue;
29804 // MUST_USE_RES bool NodeFeatures_requires_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29806 export function NodeFeatures_requires_gossip_queries(this_arg: bigint): boolean {
29807 if(!isWasmInitialized) {
29808 throw new Error("initializeWasm() must be awaited first!");
29810 const nativeResponseValue = wasm.TS_NodeFeatures_requires_gossip_queries(this_arg);
29811 return nativeResponseValue;
29813 // void InitFeatures_set_variable_length_onion_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
29815 export function InitFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
29816 if(!isWasmInitialized) {
29817 throw new Error("initializeWasm() must be awaited first!");
29819 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_optional(this_arg);
29820 // debug statements here
29822 // void InitFeatures_set_variable_length_onion_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
29824 export function InitFeatures_set_variable_length_onion_required(this_arg: bigint): void {
29825 if(!isWasmInitialized) {
29826 throw new Error("initializeWasm() must be awaited first!");
29828 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_required(this_arg);
29829 // debug statements here
29831 // MUST_USE_RES bool InitFeatures_supports_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29833 export function InitFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
29834 if(!isWasmInitialized) {
29835 throw new Error("initializeWasm() must be awaited first!");
29837 const nativeResponseValue = wasm.TS_InitFeatures_supports_variable_length_onion(this_arg);
29838 return nativeResponseValue;
29840 // void NodeFeatures_set_variable_length_onion_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29842 export function NodeFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
29843 if(!isWasmInitialized) {
29844 throw new Error("initializeWasm() must be awaited first!");
29846 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_optional(this_arg);
29847 // debug statements here
29849 // void NodeFeatures_set_variable_length_onion_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29851 export function NodeFeatures_set_variable_length_onion_required(this_arg: bigint): void {
29852 if(!isWasmInitialized) {
29853 throw new Error("initializeWasm() must be awaited first!");
29855 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_required(this_arg);
29856 // debug statements here
29858 // MUST_USE_RES bool NodeFeatures_supports_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29860 export function NodeFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
29861 if(!isWasmInitialized) {
29862 throw new Error("initializeWasm() must be awaited first!");
29864 const nativeResponseValue = wasm.TS_NodeFeatures_supports_variable_length_onion(this_arg);
29865 return nativeResponseValue;
29867 // void InvoiceFeatures_set_variable_length_onion_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
29869 export function InvoiceFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
29870 if(!isWasmInitialized) {
29871 throw new Error("initializeWasm() must be awaited first!");
29873 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_variable_length_onion_optional(this_arg);
29874 // debug statements here
29876 // void InvoiceFeatures_set_variable_length_onion_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
29878 export function InvoiceFeatures_set_variable_length_onion_required(this_arg: bigint): void {
29879 if(!isWasmInitialized) {
29880 throw new Error("initializeWasm() must be awaited first!");
29882 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_variable_length_onion_required(this_arg);
29883 // debug statements here
29885 // MUST_USE_RES bool InvoiceFeatures_supports_variable_length_onion(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
29887 export function InvoiceFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
29888 if(!isWasmInitialized) {
29889 throw new Error("initializeWasm() must be awaited first!");
29891 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_variable_length_onion(this_arg);
29892 return nativeResponseValue;
29894 // MUST_USE_RES bool InitFeatures_requires_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29896 export function InitFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
29897 if(!isWasmInitialized) {
29898 throw new Error("initializeWasm() must be awaited first!");
29900 const nativeResponseValue = wasm.TS_InitFeatures_requires_variable_length_onion(this_arg);
29901 return nativeResponseValue;
29903 // MUST_USE_RES bool NodeFeatures_requires_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29905 export function NodeFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
29906 if(!isWasmInitialized) {
29907 throw new Error("initializeWasm() must be awaited first!");
29909 const nativeResponseValue = wasm.TS_NodeFeatures_requires_variable_length_onion(this_arg);
29910 return nativeResponseValue;
29912 // MUST_USE_RES bool InvoiceFeatures_requires_variable_length_onion(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
29914 export function InvoiceFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
29915 if(!isWasmInitialized) {
29916 throw new Error("initializeWasm() must be awaited first!");
29918 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_variable_length_onion(this_arg);
29919 return nativeResponseValue;
29921 // void InitFeatures_set_static_remote_key_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
29923 export function InitFeatures_set_static_remote_key_optional(this_arg: bigint): void {
29924 if(!isWasmInitialized) {
29925 throw new Error("initializeWasm() must be awaited first!");
29927 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_optional(this_arg);
29928 // debug statements here
29930 // void InitFeatures_set_static_remote_key_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
29932 export function InitFeatures_set_static_remote_key_required(this_arg: bigint): void {
29933 if(!isWasmInitialized) {
29934 throw new Error("initializeWasm() must be awaited first!");
29936 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_required(this_arg);
29937 // debug statements here
29939 // MUST_USE_RES bool InitFeatures_supports_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
29941 export function InitFeatures_supports_static_remote_key(this_arg: bigint): boolean {
29942 if(!isWasmInitialized) {
29943 throw new Error("initializeWasm() must be awaited first!");
29945 const nativeResponseValue = wasm.TS_InitFeatures_supports_static_remote_key(this_arg);
29946 return nativeResponseValue;
29948 // void NodeFeatures_set_static_remote_key_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29950 export function NodeFeatures_set_static_remote_key_optional(this_arg: bigint): void {
29951 if(!isWasmInitialized) {
29952 throw new Error("initializeWasm() must be awaited first!");
29954 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_optional(this_arg);
29955 // debug statements here
29957 // void NodeFeatures_set_static_remote_key_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
29959 export function NodeFeatures_set_static_remote_key_required(this_arg: bigint): void {
29960 if(!isWasmInitialized) {
29961 throw new Error("initializeWasm() must be awaited first!");
29963 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_required(this_arg);
29964 // debug statements here
29966 // MUST_USE_RES bool NodeFeatures_supports_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
29968 export function NodeFeatures_supports_static_remote_key(this_arg: bigint): boolean {
29969 if(!isWasmInitialized) {
29970 throw new Error("initializeWasm() must be awaited first!");
29972 const nativeResponseValue = wasm.TS_NodeFeatures_supports_static_remote_key(this_arg);
29973 return nativeResponseValue;
29975 // void ChannelTypeFeatures_set_static_remote_key_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
29977 export function ChannelTypeFeatures_set_static_remote_key_optional(this_arg: bigint): void {
29978 if(!isWasmInitialized) {
29979 throw new Error("initializeWasm() must be awaited first!");
29981 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_optional(this_arg);
29982 // debug statements here
29984 // void ChannelTypeFeatures_set_static_remote_key_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
29986 export function ChannelTypeFeatures_set_static_remote_key_required(this_arg: bigint): void {
29987 if(!isWasmInitialized) {
29988 throw new Error("initializeWasm() must be awaited first!");
29990 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_required(this_arg);
29991 // debug statements here
29993 // MUST_USE_RES bool ChannelTypeFeatures_supports_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
29995 export function ChannelTypeFeatures_supports_static_remote_key(this_arg: bigint): boolean {
29996 if(!isWasmInitialized) {
29997 throw new Error("initializeWasm() must be awaited first!");
29999 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_static_remote_key(this_arg);
30000 return nativeResponseValue;
30002 // MUST_USE_RES bool InitFeatures_requires_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30004 export function InitFeatures_requires_static_remote_key(this_arg: bigint): boolean {
30005 if(!isWasmInitialized) {
30006 throw new Error("initializeWasm() must be awaited first!");
30008 const nativeResponseValue = wasm.TS_InitFeatures_requires_static_remote_key(this_arg);
30009 return nativeResponseValue;
30011 // MUST_USE_RES bool NodeFeatures_requires_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30013 export function NodeFeatures_requires_static_remote_key(this_arg: bigint): boolean {
30014 if(!isWasmInitialized) {
30015 throw new Error("initializeWasm() must be awaited first!");
30017 const nativeResponseValue = wasm.TS_NodeFeatures_requires_static_remote_key(this_arg);
30018 return nativeResponseValue;
30020 // MUST_USE_RES bool ChannelTypeFeatures_requires_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
30022 export function ChannelTypeFeatures_requires_static_remote_key(this_arg: bigint): boolean {
30023 if(!isWasmInitialized) {
30024 throw new Error("initializeWasm() must be awaited first!");
30026 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_static_remote_key(this_arg);
30027 return nativeResponseValue;
30029 // void InitFeatures_set_payment_secret_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
30031 export function InitFeatures_set_payment_secret_optional(this_arg: bigint): void {
30032 if(!isWasmInitialized) {
30033 throw new Error("initializeWasm() must be awaited first!");
30035 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_optional(this_arg);
30036 // debug statements here
30038 // void InitFeatures_set_payment_secret_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
30040 export function InitFeatures_set_payment_secret_required(this_arg: bigint): void {
30041 if(!isWasmInitialized) {
30042 throw new Error("initializeWasm() must be awaited first!");
30044 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_required(this_arg);
30045 // debug statements here
30047 // MUST_USE_RES bool InitFeatures_supports_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30049 export function InitFeatures_supports_payment_secret(this_arg: bigint): boolean {
30050 if(!isWasmInitialized) {
30051 throw new Error("initializeWasm() must be awaited first!");
30053 const nativeResponseValue = wasm.TS_InitFeatures_supports_payment_secret(this_arg);
30054 return nativeResponseValue;
30056 // void NodeFeatures_set_payment_secret_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
30058 export function NodeFeatures_set_payment_secret_optional(this_arg: bigint): void {
30059 if(!isWasmInitialized) {
30060 throw new Error("initializeWasm() must be awaited first!");
30062 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_optional(this_arg);
30063 // debug statements here
30065 // void NodeFeatures_set_payment_secret_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
30067 export function NodeFeatures_set_payment_secret_required(this_arg: bigint): void {
30068 if(!isWasmInitialized) {
30069 throw new Error("initializeWasm() must be awaited first!");
30071 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_required(this_arg);
30072 // debug statements here
30074 // MUST_USE_RES bool NodeFeatures_supports_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30076 export function NodeFeatures_supports_payment_secret(this_arg: bigint): boolean {
30077 if(!isWasmInitialized) {
30078 throw new Error("initializeWasm() must be awaited first!");
30080 const nativeResponseValue = wasm.TS_NodeFeatures_supports_payment_secret(this_arg);
30081 return nativeResponseValue;
30083 // void InvoiceFeatures_set_payment_secret_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
30085 export function InvoiceFeatures_set_payment_secret_optional(this_arg: bigint): void {
30086 if(!isWasmInitialized) {
30087 throw new Error("initializeWasm() must be awaited first!");
30089 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_payment_secret_optional(this_arg);
30090 // debug statements here
30092 // void InvoiceFeatures_set_payment_secret_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
30094 export function InvoiceFeatures_set_payment_secret_required(this_arg: bigint): void {
30095 if(!isWasmInitialized) {
30096 throw new Error("initializeWasm() must be awaited first!");
30098 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_payment_secret_required(this_arg);
30099 // debug statements here
30101 // MUST_USE_RES bool InvoiceFeatures_supports_payment_secret(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
30103 export function InvoiceFeatures_supports_payment_secret(this_arg: bigint): boolean {
30104 if(!isWasmInitialized) {
30105 throw new Error("initializeWasm() must be awaited first!");
30107 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_payment_secret(this_arg);
30108 return nativeResponseValue;
30110 // MUST_USE_RES bool InitFeatures_requires_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30112 export function InitFeatures_requires_payment_secret(this_arg: bigint): boolean {
30113 if(!isWasmInitialized) {
30114 throw new Error("initializeWasm() must be awaited first!");
30116 const nativeResponseValue = wasm.TS_InitFeatures_requires_payment_secret(this_arg);
30117 return nativeResponseValue;
30119 // MUST_USE_RES bool NodeFeatures_requires_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30121 export function NodeFeatures_requires_payment_secret(this_arg: bigint): boolean {
30122 if(!isWasmInitialized) {
30123 throw new Error("initializeWasm() must be awaited first!");
30125 const nativeResponseValue = wasm.TS_NodeFeatures_requires_payment_secret(this_arg);
30126 return nativeResponseValue;
30128 // MUST_USE_RES bool InvoiceFeatures_requires_payment_secret(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
30130 export function InvoiceFeatures_requires_payment_secret(this_arg: bigint): boolean {
30131 if(!isWasmInitialized) {
30132 throw new Error("initializeWasm() must be awaited first!");
30134 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_payment_secret(this_arg);
30135 return nativeResponseValue;
30137 // void InitFeatures_set_basic_mpp_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
30139 export function InitFeatures_set_basic_mpp_optional(this_arg: bigint): void {
30140 if(!isWasmInitialized) {
30141 throw new Error("initializeWasm() must be awaited first!");
30143 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_optional(this_arg);
30144 // debug statements here
30146 // void InitFeatures_set_basic_mpp_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
30148 export function InitFeatures_set_basic_mpp_required(this_arg: bigint): void {
30149 if(!isWasmInitialized) {
30150 throw new Error("initializeWasm() must be awaited first!");
30152 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_required(this_arg);
30153 // debug statements here
30155 // MUST_USE_RES bool InitFeatures_supports_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30157 export function InitFeatures_supports_basic_mpp(this_arg: bigint): boolean {
30158 if(!isWasmInitialized) {
30159 throw new Error("initializeWasm() must be awaited first!");
30161 const nativeResponseValue = wasm.TS_InitFeatures_supports_basic_mpp(this_arg);
30162 return nativeResponseValue;
30164 // void NodeFeatures_set_basic_mpp_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
30166 export function NodeFeatures_set_basic_mpp_optional(this_arg: bigint): void {
30167 if(!isWasmInitialized) {
30168 throw new Error("initializeWasm() must be awaited first!");
30170 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_optional(this_arg);
30171 // debug statements here
30173 // void NodeFeatures_set_basic_mpp_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
30175 export function NodeFeatures_set_basic_mpp_required(this_arg: bigint): void {
30176 if(!isWasmInitialized) {
30177 throw new Error("initializeWasm() must be awaited first!");
30179 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_required(this_arg);
30180 // debug statements here
30182 // MUST_USE_RES bool NodeFeatures_supports_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30184 export function NodeFeatures_supports_basic_mpp(this_arg: bigint): boolean {
30185 if(!isWasmInitialized) {
30186 throw new Error("initializeWasm() must be awaited first!");
30188 const nativeResponseValue = wasm.TS_NodeFeatures_supports_basic_mpp(this_arg);
30189 return nativeResponseValue;
30191 // void InvoiceFeatures_set_basic_mpp_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
30193 export function InvoiceFeatures_set_basic_mpp_optional(this_arg: bigint): void {
30194 if(!isWasmInitialized) {
30195 throw new Error("initializeWasm() must be awaited first!");
30197 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_basic_mpp_optional(this_arg);
30198 // debug statements here
30200 // void InvoiceFeatures_set_basic_mpp_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
30202 export function InvoiceFeatures_set_basic_mpp_required(this_arg: bigint): void {
30203 if(!isWasmInitialized) {
30204 throw new Error("initializeWasm() must be awaited first!");
30206 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_basic_mpp_required(this_arg);
30207 // debug statements here
30209 // MUST_USE_RES bool InvoiceFeatures_supports_basic_mpp(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
30211 export function InvoiceFeatures_supports_basic_mpp(this_arg: bigint): boolean {
30212 if(!isWasmInitialized) {
30213 throw new Error("initializeWasm() must be awaited first!");
30215 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_basic_mpp(this_arg);
30216 return nativeResponseValue;
30218 // MUST_USE_RES bool InitFeatures_requires_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30220 export function InitFeatures_requires_basic_mpp(this_arg: bigint): boolean {
30221 if(!isWasmInitialized) {
30222 throw new Error("initializeWasm() must be awaited first!");
30224 const nativeResponseValue = wasm.TS_InitFeatures_requires_basic_mpp(this_arg);
30225 return nativeResponseValue;
30227 // MUST_USE_RES bool NodeFeatures_requires_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30229 export function NodeFeatures_requires_basic_mpp(this_arg: bigint): boolean {
30230 if(!isWasmInitialized) {
30231 throw new Error("initializeWasm() must be awaited first!");
30233 const nativeResponseValue = wasm.TS_NodeFeatures_requires_basic_mpp(this_arg);
30234 return nativeResponseValue;
30236 // MUST_USE_RES bool InvoiceFeatures_requires_basic_mpp(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
30238 export function InvoiceFeatures_requires_basic_mpp(this_arg: bigint): boolean {
30239 if(!isWasmInitialized) {
30240 throw new Error("initializeWasm() must be awaited first!");
30242 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_basic_mpp(this_arg);
30243 return nativeResponseValue;
30245 // void InitFeatures_set_wumbo_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
30247 export function InitFeatures_set_wumbo_optional(this_arg: bigint): void {
30248 if(!isWasmInitialized) {
30249 throw new Error("initializeWasm() must be awaited first!");
30251 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_optional(this_arg);
30252 // debug statements here
30254 // void InitFeatures_set_wumbo_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
30256 export function InitFeatures_set_wumbo_required(this_arg: bigint): void {
30257 if(!isWasmInitialized) {
30258 throw new Error("initializeWasm() must be awaited first!");
30260 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_required(this_arg);
30261 // debug statements here
30263 // MUST_USE_RES bool InitFeatures_supports_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30265 export function InitFeatures_supports_wumbo(this_arg: bigint): boolean {
30266 if(!isWasmInitialized) {
30267 throw new Error("initializeWasm() must be awaited first!");
30269 const nativeResponseValue = wasm.TS_InitFeatures_supports_wumbo(this_arg);
30270 return nativeResponseValue;
30272 // void NodeFeatures_set_wumbo_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
30274 export function NodeFeatures_set_wumbo_optional(this_arg: bigint): void {
30275 if(!isWasmInitialized) {
30276 throw new Error("initializeWasm() must be awaited first!");
30278 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_optional(this_arg);
30279 // debug statements here
30281 // void NodeFeatures_set_wumbo_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
30283 export function NodeFeatures_set_wumbo_required(this_arg: bigint): void {
30284 if(!isWasmInitialized) {
30285 throw new Error("initializeWasm() must be awaited first!");
30287 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_required(this_arg);
30288 // debug statements here
30290 // MUST_USE_RES bool NodeFeatures_supports_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30292 export function NodeFeatures_supports_wumbo(this_arg: bigint): boolean {
30293 if(!isWasmInitialized) {
30294 throw new Error("initializeWasm() must be awaited first!");
30296 const nativeResponseValue = wasm.TS_NodeFeatures_supports_wumbo(this_arg);
30297 return nativeResponseValue;
30299 // MUST_USE_RES bool InitFeatures_requires_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30301 export function InitFeatures_requires_wumbo(this_arg: bigint): boolean {
30302 if(!isWasmInitialized) {
30303 throw new Error("initializeWasm() must be awaited first!");
30305 const nativeResponseValue = wasm.TS_InitFeatures_requires_wumbo(this_arg);
30306 return nativeResponseValue;
30308 // MUST_USE_RES bool NodeFeatures_requires_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30310 export function NodeFeatures_requires_wumbo(this_arg: bigint): boolean {
30311 if(!isWasmInitialized) {
30312 throw new Error("initializeWasm() must be awaited first!");
30314 const nativeResponseValue = wasm.TS_NodeFeatures_requires_wumbo(this_arg);
30315 return nativeResponseValue;
30317 // void InitFeatures_set_shutdown_any_segwit_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
30319 export function InitFeatures_set_shutdown_any_segwit_optional(this_arg: bigint): void {
30320 if(!isWasmInitialized) {
30321 throw new Error("initializeWasm() must be awaited first!");
30323 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_optional(this_arg);
30324 // debug statements here
30326 // void InitFeatures_set_shutdown_any_segwit_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
30328 export function InitFeatures_set_shutdown_any_segwit_required(this_arg: bigint): void {
30329 if(!isWasmInitialized) {
30330 throw new Error("initializeWasm() must be awaited first!");
30332 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_required(this_arg);
30333 // debug statements here
30335 // MUST_USE_RES bool InitFeatures_supports_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30337 export function InitFeatures_supports_shutdown_anysegwit(this_arg: bigint): boolean {
30338 if(!isWasmInitialized) {
30339 throw new Error("initializeWasm() must be awaited first!");
30341 const nativeResponseValue = wasm.TS_InitFeatures_supports_shutdown_anysegwit(this_arg);
30342 return nativeResponseValue;
30344 // void NodeFeatures_set_shutdown_any_segwit_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
30346 export function NodeFeatures_set_shutdown_any_segwit_optional(this_arg: bigint): void {
30347 if(!isWasmInitialized) {
30348 throw new Error("initializeWasm() must be awaited first!");
30350 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_optional(this_arg);
30351 // debug statements here
30353 // void NodeFeatures_set_shutdown_any_segwit_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
30355 export function NodeFeatures_set_shutdown_any_segwit_required(this_arg: bigint): void {
30356 if(!isWasmInitialized) {
30357 throw new Error("initializeWasm() must be awaited first!");
30359 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_required(this_arg);
30360 // debug statements here
30362 // MUST_USE_RES bool NodeFeatures_supports_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30364 export function NodeFeatures_supports_shutdown_anysegwit(this_arg: bigint): boolean {
30365 if(!isWasmInitialized) {
30366 throw new Error("initializeWasm() must be awaited first!");
30368 const nativeResponseValue = wasm.TS_NodeFeatures_supports_shutdown_anysegwit(this_arg);
30369 return nativeResponseValue;
30371 // MUST_USE_RES bool InitFeatures_requires_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30373 export function InitFeatures_requires_shutdown_anysegwit(this_arg: bigint): boolean {
30374 if(!isWasmInitialized) {
30375 throw new Error("initializeWasm() must be awaited first!");
30377 const nativeResponseValue = wasm.TS_InitFeatures_requires_shutdown_anysegwit(this_arg);
30378 return nativeResponseValue;
30380 // MUST_USE_RES bool NodeFeatures_requires_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30382 export function NodeFeatures_requires_shutdown_anysegwit(this_arg: bigint): boolean {
30383 if(!isWasmInitialized) {
30384 throw new Error("initializeWasm() must be awaited first!");
30386 const nativeResponseValue = wasm.TS_NodeFeatures_requires_shutdown_anysegwit(this_arg);
30387 return nativeResponseValue;
30389 // void InitFeatures_set_onion_messages_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
30391 export function InitFeatures_set_onion_messages_optional(this_arg: bigint): void {
30392 if(!isWasmInitialized) {
30393 throw new Error("initializeWasm() must be awaited first!");
30395 const nativeResponseValue = wasm.TS_InitFeatures_set_onion_messages_optional(this_arg);
30396 // debug statements here
30398 // void InitFeatures_set_onion_messages_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
30400 export function InitFeatures_set_onion_messages_required(this_arg: bigint): void {
30401 if(!isWasmInitialized) {
30402 throw new Error("initializeWasm() must be awaited first!");
30404 const nativeResponseValue = wasm.TS_InitFeatures_set_onion_messages_required(this_arg);
30405 // debug statements here
30407 // MUST_USE_RES bool InitFeatures_supports_onion_messages(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30409 export function InitFeatures_supports_onion_messages(this_arg: bigint): boolean {
30410 if(!isWasmInitialized) {
30411 throw new Error("initializeWasm() must be awaited first!");
30413 const nativeResponseValue = wasm.TS_InitFeatures_supports_onion_messages(this_arg);
30414 return nativeResponseValue;
30416 // void NodeFeatures_set_onion_messages_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
30418 export function NodeFeatures_set_onion_messages_optional(this_arg: bigint): void {
30419 if(!isWasmInitialized) {
30420 throw new Error("initializeWasm() must be awaited first!");
30422 const nativeResponseValue = wasm.TS_NodeFeatures_set_onion_messages_optional(this_arg);
30423 // debug statements here
30425 // void NodeFeatures_set_onion_messages_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
30427 export function NodeFeatures_set_onion_messages_required(this_arg: bigint): void {
30428 if(!isWasmInitialized) {
30429 throw new Error("initializeWasm() must be awaited first!");
30431 const nativeResponseValue = wasm.TS_NodeFeatures_set_onion_messages_required(this_arg);
30432 // debug statements here
30434 // MUST_USE_RES bool NodeFeatures_supports_onion_messages(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30436 export function NodeFeatures_supports_onion_messages(this_arg: bigint): boolean {
30437 if(!isWasmInitialized) {
30438 throw new Error("initializeWasm() must be awaited first!");
30440 const nativeResponseValue = wasm.TS_NodeFeatures_supports_onion_messages(this_arg);
30441 return nativeResponseValue;
30443 // MUST_USE_RES bool InitFeatures_requires_onion_messages(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30445 export function InitFeatures_requires_onion_messages(this_arg: bigint): boolean {
30446 if(!isWasmInitialized) {
30447 throw new Error("initializeWasm() must be awaited first!");
30449 const nativeResponseValue = wasm.TS_InitFeatures_requires_onion_messages(this_arg);
30450 return nativeResponseValue;
30452 // MUST_USE_RES bool NodeFeatures_requires_onion_messages(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30454 export function NodeFeatures_requires_onion_messages(this_arg: bigint): boolean {
30455 if(!isWasmInitialized) {
30456 throw new Error("initializeWasm() must be awaited first!");
30458 const nativeResponseValue = wasm.TS_NodeFeatures_requires_onion_messages(this_arg);
30459 return nativeResponseValue;
30461 // void InitFeatures_set_channel_type_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
30463 export function InitFeatures_set_channel_type_optional(this_arg: bigint): void {
30464 if(!isWasmInitialized) {
30465 throw new Error("initializeWasm() must be awaited first!");
30467 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_optional(this_arg);
30468 // debug statements here
30470 // void InitFeatures_set_channel_type_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
30472 export function InitFeatures_set_channel_type_required(this_arg: bigint): void {
30473 if(!isWasmInitialized) {
30474 throw new Error("initializeWasm() must be awaited first!");
30476 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_required(this_arg);
30477 // debug statements here
30479 // MUST_USE_RES bool InitFeatures_supports_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30481 export function InitFeatures_supports_channel_type(this_arg: bigint): boolean {
30482 if(!isWasmInitialized) {
30483 throw new Error("initializeWasm() must be awaited first!");
30485 const nativeResponseValue = wasm.TS_InitFeatures_supports_channel_type(this_arg);
30486 return nativeResponseValue;
30488 // void NodeFeatures_set_channel_type_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
30490 export function NodeFeatures_set_channel_type_optional(this_arg: bigint): void {
30491 if(!isWasmInitialized) {
30492 throw new Error("initializeWasm() must be awaited first!");
30494 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_optional(this_arg);
30495 // debug statements here
30497 // void NodeFeatures_set_channel_type_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
30499 export function NodeFeatures_set_channel_type_required(this_arg: bigint): void {
30500 if(!isWasmInitialized) {
30501 throw new Error("initializeWasm() must be awaited first!");
30503 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_required(this_arg);
30504 // debug statements here
30506 // MUST_USE_RES bool NodeFeatures_supports_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30508 export function NodeFeatures_supports_channel_type(this_arg: bigint): boolean {
30509 if(!isWasmInitialized) {
30510 throw new Error("initializeWasm() must be awaited first!");
30512 const nativeResponseValue = wasm.TS_NodeFeatures_supports_channel_type(this_arg);
30513 return nativeResponseValue;
30515 // MUST_USE_RES bool InitFeatures_requires_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30517 export function InitFeatures_requires_channel_type(this_arg: bigint): boolean {
30518 if(!isWasmInitialized) {
30519 throw new Error("initializeWasm() must be awaited first!");
30521 const nativeResponseValue = wasm.TS_InitFeatures_requires_channel_type(this_arg);
30522 return nativeResponseValue;
30524 // MUST_USE_RES bool NodeFeatures_requires_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30526 export function NodeFeatures_requires_channel_type(this_arg: bigint): boolean {
30527 if(!isWasmInitialized) {
30528 throw new Error("initializeWasm() must be awaited first!");
30530 const nativeResponseValue = wasm.TS_NodeFeatures_requires_channel_type(this_arg);
30531 return nativeResponseValue;
30533 // void InitFeatures_set_scid_privacy_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
30535 export function InitFeatures_set_scid_privacy_optional(this_arg: bigint): void {
30536 if(!isWasmInitialized) {
30537 throw new Error("initializeWasm() must be awaited first!");
30539 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_optional(this_arg);
30540 // debug statements here
30542 // void InitFeatures_set_scid_privacy_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
30544 export function InitFeatures_set_scid_privacy_required(this_arg: bigint): void {
30545 if(!isWasmInitialized) {
30546 throw new Error("initializeWasm() must be awaited first!");
30548 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_required(this_arg);
30549 // debug statements here
30551 // MUST_USE_RES bool InitFeatures_supports_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30553 export function InitFeatures_supports_scid_privacy(this_arg: bigint): boolean {
30554 if(!isWasmInitialized) {
30555 throw new Error("initializeWasm() must be awaited first!");
30557 const nativeResponseValue = wasm.TS_InitFeatures_supports_scid_privacy(this_arg);
30558 return nativeResponseValue;
30560 // void NodeFeatures_set_scid_privacy_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
30562 export function NodeFeatures_set_scid_privacy_optional(this_arg: bigint): void {
30563 if(!isWasmInitialized) {
30564 throw new Error("initializeWasm() must be awaited first!");
30566 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_optional(this_arg);
30567 // debug statements here
30569 // void NodeFeatures_set_scid_privacy_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
30571 export function NodeFeatures_set_scid_privacy_required(this_arg: bigint): void {
30572 if(!isWasmInitialized) {
30573 throw new Error("initializeWasm() must be awaited first!");
30575 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_required(this_arg);
30576 // debug statements here
30578 // MUST_USE_RES bool NodeFeatures_supports_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30580 export function NodeFeatures_supports_scid_privacy(this_arg: bigint): boolean {
30581 if(!isWasmInitialized) {
30582 throw new Error("initializeWasm() must be awaited first!");
30584 const nativeResponseValue = wasm.TS_NodeFeatures_supports_scid_privacy(this_arg);
30585 return nativeResponseValue;
30587 // void ChannelTypeFeatures_set_scid_privacy_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
30589 export function ChannelTypeFeatures_set_scid_privacy_optional(this_arg: bigint): void {
30590 if(!isWasmInitialized) {
30591 throw new Error("initializeWasm() must be awaited first!");
30593 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_optional(this_arg);
30594 // debug statements here
30596 // void ChannelTypeFeatures_set_scid_privacy_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
30598 export function ChannelTypeFeatures_set_scid_privacy_required(this_arg: bigint): void {
30599 if(!isWasmInitialized) {
30600 throw new Error("initializeWasm() must be awaited first!");
30602 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_required(this_arg);
30603 // debug statements here
30605 // MUST_USE_RES bool ChannelTypeFeatures_supports_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
30607 export function ChannelTypeFeatures_supports_scid_privacy(this_arg: bigint): boolean {
30608 if(!isWasmInitialized) {
30609 throw new Error("initializeWasm() must be awaited first!");
30611 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_scid_privacy(this_arg);
30612 return nativeResponseValue;
30614 // MUST_USE_RES bool InitFeatures_requires_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30616 export function InitFeatures_requires_scid_privacy(this_arg: bigint): boolean {
30617 if(!isWasmInitialized) {
30618 throw new Error("initializeWasm() must be awaited first!");
30620 const nativeResponseValue = wasm.TS_InitFeatures_requires_scid_privacy(this_arg);
30621 return nativeResponseValue;
30623 // MUST_USE_RES bool NodeFeatures_requires_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30625 export function NodeFeatures_requires_scid_privacy(this_arg: bigint): boolean {
30626 if(!isWasmInitialized) {
30627 throw new Error("initializeWasm() must be awaited first!");
30629 const nativeResponseValue = wasm.TS_NodeFeatures_requires_scid_privacy(this_arg);
30630 return nativeResponseValue;
30632 // MUST_USE_RES bool ChannelTypeFeatures_requires_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
30634 export function ChannelTypeFeatures_requires_scid_privacy(this_arg: bigint): boolean {
30635 if(!isWasmInitialized) {
30636 throw new Error("initializeWasm() must be awaited first!");
30638 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_scid_privacy(this_arg);
30639 return nativeResponseValue;
30641 // void InitFeatures_set_zero_conf_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
30643 export function InitFeatures_set_zero_conf_optional(this_arg: bigint): void {
30644 if(!isWasmInitialized) {
30645 throw new Error("initializeWasm() must be awaited first!");
30647 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_optional(this_arg);
30648 // debug statements here
30650 // void InitFeatures_set_zero_conf_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
30652 export function InitFeatures_set_zero_conf_required(this_arg: bigint): void {
30653 if(!isWasmInitialized) {
30654 throw new Error("initializeWasm() must be awaited first!");
30656 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_required(this_arg);
30657 // debug statements here
30659 // MUST_USE_RES bool InitFeatures_supports_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30661 export function InitFeatures_supports_zero_conf(this_arg: bigint): boolean {
30662 if(!isWasmInitialized) {
30663 throw new Error("initializeWasm() must be awaited first!");
30665 const nativeResponseValue = wasm.TS_InitFeatures_supports_zero_conf(this_arg);
30666 return nativeResponseValue;
30668 // void NodeFeatures_set_zero_conf_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
30670 export function NodeFeatures_set_zero_conf_optional(this_arg: bigint): void {
30671 if(!isWasmInitialized) {
30672 throw new Error("initializeWasm() must be awaited first!");
30674 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_optional(this_arg);
30675 // debug statements here
30677 // void NodeFeatures_set_zero_conf_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
30679 export function NodeFeatures_set_zero_conf_required(this_arg: bigint): void {
30680 if(!isWasmInitialized) {
30681 throw new Error("initializeWasm() must be awaited first!");
30683 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_required(this_arg);
30684 // debug statements here
30686 // MUST_USE_RES bool NodeFeatures_supports_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30688 export function NodeFeatures_supports_zero_conf(this_arg: bigint): boolean {
30689 if(!isWasmInitialized) {
30690 throw new Error("initializeWasm() must be awaited first!");
30692 const nativeResponseValue = wasm.TS_NodeFeatures_supports_zero_conf(this_arg);
30693 return nativeResponseValue;
30695 // void ChannelTypeFeatures_set_zero_conf_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
30697 export function ChannelTypeFeatures_set_zero_conf_optional(this_arg: bigint): void {
30698 if(!isWasmInitialized) {
30699 throw new Error("initializeWasm() must be awaited first!");
30701 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_optional(this_arg);
30702 // debug statements here
30704 // void ChannelTypeFeatures_set_zero_conf_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
30706 export function ChannelTypeFeatures_set_zero_conf_required(this_arg: bigint): void {
30707 if(!isWasmInitialized) {
30708 throw new Error("initializeWasm() must be awaited first!");
30710 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_required(this_arg);
30711 // debug statements here
30713 // MUST_USE_RES bool ChannelTypeFeatures_supports_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
30715 export function ChannelTypeFeatures_supports_zero_conf(this_arg: bigint): boolean {
30716 if(!isWasmInitialized) {
30717 throw new Error("initializeWasm() must be awaited first!");
30719 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_zero_conf(this_arg);
30720 return nativeResponseValue;
30722 // MUST_USE_RES bool InitFeatures_requires_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30724 export function InitFeatures_requires_zero_conf(this_arg: bigint): boolean {
30725 if(!isWasmInitialized) {
30726 throw new Error("initializeWasm() must be awaited first!");
30728 const nativeResponseValue = wasm.TS_InitFeatures_requires_zero_conf(this_arg);
30729 return nativeResponseValue;
30731 // MUST_USE_RES bool NodeFeatures_requires_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30733 export function NodeFeatures_requires_zero_conf(this_arg: bigint): boolean {
30734 if(!isWasmInitialized) {
30735 throw new Error("initializeWasm() must be awaited first!");
30737 const nativeResponseValue = wasm.TS_NodeFeatures_requires_zero_conf(this_arg);
30738 return nativeResponseValue;
30740 // MUST_USE_RES bool ChannelTypeFeatures_requires_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
30742 export function ChannelTypeFeatures_requires_zero_conf(this_arg: bigint): boolean {
30743 if(!isWasmInitialized) {
30744 throw new Error("initializeWasm() must be awaited first!");
30746 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_zero_conf(this_arg);
30747 return nativeResponseValue;
30749 // void NodeFeatures_set_keysend_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
30751 export function NodeFeatures_set_keysend_optional(this_arg: bigint): void {
30752 if(!isWasmInitialized) {
30753 throw new Error("initializeWasm() must be awaited first!");
30755 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_optional(this_arg);
30756 // debug statements here
30758 // void NodeFeatures_set_keysend_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
30760 export function NodeFeatures_set_keysend_required(this_arg: bigint): void {
30761 if(!isWasmInitialized) {
30762 throw new Error("initializeWasm() must be awaited first!");
30764 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_required(this_arg);
30765 // debug statements here
30767 // MUST_USE_RES bool NodeFeatures_supports_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30769 export function NodeFeatures_supports_keysend(this_arg: bigint): boolean {
30770 if(!isWasmInitialized) {
30771 throw new Error("initializeWasm() must be awaited first!");
30773 const nativeResponseValue = wasm.TS_NodeFeatures_supports_keysend(this_arg);
30774 return nativeResponseValue;
30776 // MUST_USE_RES bool NodeFeatures_requires_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30778 export function NodeFeatures_requires_keysend(this_arg: bigint): boolean {
30779 if(!isWasmInitialized) {
30780 throw new Error("initializeWasm() must be awaited first!");
30782 const nativeResponseValue = wasm.TS_NodeFeatures_requires_keysend(this_arg);
30783 return nativeResponseValue;
30785 // void ShutdownScript_free(struct LDKShutdownScript this_obj);
30787 export function ShutdownScript_free(this_obj: bigint): void {
30788 if(!isWasmInitialized) {
30789 throw new Error("initializeWasm() must be awaited first!");
30791 const nativeResponseValue = wasm.TS_ShutdownScript_free(this_obj);
30792 // debug statements here
30794 // uint64_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg);
30796 export function ShutdownScript_clone_ptr(arg: bigint): bigint {
30797 if(!isWasmInitialized) {
30798 throw new Error("initializeWasm() must be awaited first!");
30800 const nativeResponseValue = wasm.TS_ShutdownScript_clone_ptr(arg);
30801 return nativeResponseValue;
30803 // struct LDKShutdownScript ShutdownScript_clone(const struct LDKShutdownScript *NONNULL_PTR orig);
30805 export function ShutdownScript_clone(orig: bigint): bigint {
30806 if(!isWasmInitialized) {
30807 throw new Error("initializeWasm() must be awaited first!");
30809 const nativeResponseValue = wasm.TS_ShutdownScript_clone(orig);
30810 return nativeResponseValue;
30812 // bool ShutdownScript_eq(const struct LDKShutdownScript *NONNULL_PTR a, const struct LDKShutdownScript *NONNULL_PTR b);
30814 export function ShutdownScript_eq(a: bigint, b: bigint): boolean {
30815 if(!isWasmInitialized) {
30816 throw new Error("initializeWasm() must be awaited first!");
30818 const nativeResponseValue = wasm.TS_ShutdownScript_eq(a, b);
30819 return nativeResponseValue;
30821 // void InvalidShutdownScript_free(struct LDKInvalidShutdownScript this_obj);
30823 export function InvalidShutdownScript_free(this_obj: bigint): void {
30824 if(!isWasmInitialized) {
30825 throw new Error("initializeWasm() must be awaited first!");
30827 const nativeResponseValue = wasm.TS_InvalidShutdownScript_free(this_obj);
30828 // debug statements here
30830 // struct LDKu8slice InvalidShutdownScript_get_script(const struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr);
30832 export function InvalidShutdownScript_get_script(this_ptr: bigint): number {
30833 if(!isWasmInitialized) {
30834 throw new Error("initializeWasm() must be awaited first!");
30836 const nativeResponseValue = wasm.TS_InvalidShutdownScript_get_script(this_ptr);
30837 return nativeResponseValue;
30839 // void InvalidShutdownScript_set_script(struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
30841 export function InvalidShutdownScript_set_script(this_ptr: bigint, val: number): void {
30842 if(!isWasmInitialized) {
30843 throw new Error("initializeWasm() must be awaited first!");
30845 const nativeResponseValue = wasm.TS_InvalidShutdownScript_set_script(this_ptr, val);
30846 // debug statements here
30848 // MUST_USE_RES struct LDKInvalidShutdownScript InvalidShutdownScript_new(struct LDKCVec_u8Z script_arg);
30850 export function InvalidShutdownScript_new(script_arg: number): bigint {
30851 if(!isWasmInitialized) {
30852 throw new Error("initializeWasm() must be awaited first!");
30854 const nativeResponseValue = wasm.TS_InvalidShutdownScript_new(script_arg);
30855 return nativeResponseValue;
30857 // uint64_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg);
30859 export function InvalidShutdownScript_clone_ptr(arg: bigint): bigint {
30860 if(!isWasmInitialized) {
30861 throw new Error("initializeWasm() must be awaited first!");
30863 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone_ptr(arg);
30864 return nativeResponseValue;
30866 // struct LDKInvalidShutdownScript InvalidShutdownScript_clone(const struct LDKInvalidShutdownScript *NONNULL_PTR orig);
30868 export function InvalidShutdownScript_clone(orig: bigint): bigint {
30869 if(!isWasmInitialized) {
30870 throw new Error("initializeWasm() must be awaited first!");
30872 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone(orig);
30873 return nativeResponseValue;
30875 // struct LDKCVec_u8Z ShutdownScript_write(const struct LDKShutdownScript *NONNULL_PTR obj);
30877 export function ShutdownScript_write(obj: bigint): number {
30878 if(!isWasmInitialized) {
30879 throw new Error("initializeWasm() must be awaited first!");
30881 const nativeResponseValue = wasm.TS_ShutdownScript_write(obj);
30882 return nativeResponseValue;
30884 // struct LDKCResult_ShutdownScriptDecodeErrorZ ShutdownScript_read(struct LDKu8slice ser);
30886 export function ShutdownScript_read(ser: number): bigint {
30887 if(!isWasmInitialized) {
30888 throw new Error("initializeWasm() must be awaited first!");
30890 const nativeResponseValue = wasm.TS_ShutdownScript_read(ser);
30891 return nativeResponseValue;
30893 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wpkh(const uint8_t (*pubkey_hash)[20]);
30895 export function ShutdownScript_new_p2wpkh(pubkey_hash: number): bigint {
30896 if(!isWasmInitialized) {
30897 throw new Error("initializeWasm() must be awaited first!");
30899 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wpkh(pubkey_hash);
30900 return nativeResponseValue;
30902 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wsh(const uint8_t (*script_hash)[32]);
30904 export function ShutdownScript_new_p2wsh(script_hash: number): bigint {
30905 if(!isWasmInitialized) {
30906 throw new Error("initializeWasm() must be awaited first!");
30908 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wsh(script_hash);
30909 return nativeResponseValue;
30911 // MUST_USE_RES struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ ShutdownScript_new_witness_program(struct LDKWitnessVersion version, struct LDKu8slice program);
30913 export function ShutdownScript_new_witness_program(version: number, program: number): bigint {
30914 if(!isWasmInitialized) {
30915 throw new Error("initializeWasm() must be awaited first!");
30917 const nativeResponseValue = wasm.TS_ShutdownScript_new_witness_program(version, program);
30918 return nativeResponseValue;
30920 // MUST_USE_RES struct LDKCVec_u8Z ShutdownScript_into_inner(struct LDKShutdownScript this_arg);
30922 export function ShutdownScript_into_inner(this_arg: bigint): number {
30923 if(!isWasmInitialized) {
30924 throw new Error("initializeWasm() must be awaited first!");
30926 const nativeResponseValue = wasm.TS_ShutdownScript_into_inner(this_arg);
30927 return nativeResponseValue;
30929 // MUST_USE_RES struct LDKPublicKey ShutdownScript_as_legacy_pubkey(const struct LDKShutdownScript *NONNULL_PTR this_arg);
30931 export function ShutdownScript_as_legacy_pubkey(this_arg: bigint): number {
30932 if(!isWasmInitialized) {
30933 throw new Error("initializeWasm() must be awaited first!");
30935 const nativeResponseValue = wasm.TS_ShutdownScript_as_legacy_pubkey(this_arg);
30936 return nativeResponseValue;
30938 // MUST_USE_RES bool ShutdownScript_is_compatible(const struct LDKShutdownScript *NONNULL_PTR this_arg, const struct LDKInitFeatures *NONNULL_PTR features);
30940 export function ShutdownScript_is_compatible(this_arg: bigint, features: bigint): boolean {
30941 if(!isWasmInitialized) {
30942 throw new Error("initializeWasm() must be awaited first!");
30944 const nativeResponseValue = wasm.TS_ShutdownScript_is_compatible(this_arg, features);
30945 return nativeResponseValue;
30947 // void CustomMessageReader_free(struct LDKCustomMessageReader this_ptr);
30949 export function CustomMessageReader_free(this_ptr: bigint): void {
30950 if(!isWasmInitialized) {
30951 throw new Error("initializeWasm() must be awaited first!");
30953 const nativeResponseValue = wasm.TS_CustomMessageReader_free(this_ptr);
30954 // debug statements here
30956 // uint64_t Type_clone_ptr(LDKType *NONNULL_PTR arg);
30958 export function Type_clone_ptr(arg: bigint): bigint {
30959 if(!isWasmInitialized) {
30960 throw new Error("initializeWasm() must be awaited first!");
30962 const nativeResponseValue = wasm.TS_Type_clone_ptr(arg);
30963 return nativeResponseValue;
30965 // struct LDKType Type_clone(const struct LDKType *NONNULL_PTR orig);
30967 export function Type_clone(orig: bigint): bigint {
30968 if(!isWasmInitialized) {
30969 throw new Error("initializeWasm() must be awaited first!");
30971 const nativeResponseValue = wasm.TS_Type_clone(orig);
30972 return nativeResponseValue;
30974 // void Type_free(struct LDKType this_ptr);
30976 export function Type_free(this_ptr: bigint): void {
30977 if(!isWasmInitialized) {
30978 throw new Error("initializeWasm() must be awaited first!");
30980 const nativeResponseValue = wasm.TS_Type_free(this_ptr);
30981 // debug statements here
30983 // void NodeId_free(struct LDKNodeId this_obj);
30985 export function NodeId_free(this_obj: bigint): void {
30986 if(!isWasmInitialized) {
30987 throw new Error("initializeWasm() must be awaited first!");
30989 const nativeResponseValue = wasm.TS_NodeId_free(this_obj);
30990 // debug statements here
30992 // uint64_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg);
30994 export function NodeId_clone_ptr(arg: bigint): bigint {
30995 if(!isWasmInitialized) {
30996 throw new Error("initializeWasm() must be awaited first!");
30998 const nativeResponseValue = wasm.TS_NodeId_clone_ptr(arg);
30999 return nativeResponseValue;
31001 // struct LDKNodeId NodeId_clone(const struct LDKNodeId *NONNULL_PTR orig);
31003 export function NodeId_clone(orig: bigint): bigint {
31004 if(!isWasmInitialized) {
31005 throw new Error("initializeWasm() must be awaited first!");
31007 const nativeResponseValue = wasm.TS_NodeId_clone(orig);
31008 return nativeResponseValue;
31010 // MUST_USE_RES struct LDKNodeId NodeId_from_pubkey(struct LDKPublicKey pubkey);
31012 export function NodeId_from_pubkey(pubkey: number): bigint {
31013 if(!isWasmInitialized) {
31014 throw new Error("initializeWasm() must be awaited first!");
31016 const nativeResponseValue = wasm.TS_NodeId_from_pubkey(pubkey);
31017 return nativeResponseValue;
31019 // MUST_USE_RES struct LDKu8slice NodeId_as_slice(const struct LDKNodeId *NONNULL_PTR this_arg);
31021 export function NodeId_as_slice(this_arg: bigint): number {
31022 if(!isWasmInitialized) {
31023 throw new Error("initializeWasm() must be awaited first!");
31025 const nativeResponseValue = wasm.TS_NodeId_as_slice(this_arg);
31026 return nativeResponseValue;
31028 // uint64_t NodeId_hash(const struct LDKNodeId *NONNULL_PTR o);
31030 export function NodeId_hash(o: bigint): bigint {
31031 if(!isWasmInitialized) {
31032 throw new Error("initializeWasm() must be awaited first!");
31034 const nativeResponseValue = wasm.TS_NodeId_hash(o);
31035 return nativeResponseValue;
31037 // struct LDKCVec_u8Z NodeId_write(const struct LDKNodeId *NONNULL_PTR obj);
31039 export function NodeId_write(obj: bigint): number {
31040 if(!isWasmInitialized) {
31041 throw new Error("initializeWasm() must be awaited first!");
31043 const nativeResponseValue = wasm.TS_NodeId_write(obj);
31044 return nativeResponseValue;
31046 // struct LDKCResult_NodeIdDecodeErrorZ NodeId_read(struct LDKu8slice ser);
31048 export function NodeId_read(ser: number): bigint {
31049 if(!isWasmInitialized) {
31050 throw new Error("initializeWasm() must be awaited first!");
31052 const nativeResponseValue = wasm.TS_NodeId_read(ser);
31053 return nativeResponseValue;
31055 // void NetworkGraph_free(struct LDKNetworkGraph this_obj);
31057 export function NetworkGraph_free(this_obj: bigint): void {
31058 if(!isWasmInitialized) {
31059 throw new Error("initializeWasm() must be awaited first!");
31061 const nativeResponseValue = wasm.TS_NetworkGraph_free(this_obj);
31062 // debug statements here
31064 // void ReadOnlyNetworkGraph_free(struct LDKReadOnlyNetworkGraph this_obj);
31066 export function ReadOnlyNetworkGraph_free(this_obj: bigint): void {
31067 if(!isWasmInitialized) {
31068 throw new Error("initializeWasm() must be awaited first!");
31070 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_free(this_obj);
31071 // debug statements here
31073 // void NetworkUpdate_free(struct LDKNetworkUpdate this_ptr);
31075 export function NetworkUpdate_free(this_ptr: bigint): void {
31076 if(!isWasmInitialized) {
31077 throw new Error("initializeWasm() must be awaited first!");
31079 const nativeResponseValue = wasm.TS_NetworkUpdate_free(this_ptr);
31080 // debug statements here
31082 // uint64_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg);
31084 export function NetworkUpdate_clone_ptr(arg: bigint): bigint {
31085 if(!isWasmInitialized) {
31086 throw new Error("initializeWasm() must be awaited first!");
31088 const nativeResponseValue = wasm.TS_NetworkUpdate_clone_ptr(arg);
31089 return nativeResponseValue;
31091 // struct LDKNetworkUpdate NetworkUpdate_clone(const struct LDKNetworkUpdate *NONNULL_PTR orig);
31093 export function NetworkUpdate_clone(orig: bigint): bigint {
31094 if(!isWasmInitialized) {
31095 throw new Error("initializeWasm() must be awaited first!");
31097 const nativeResponseValue = wasm.TS_NetworkUpdate_clone(orig);
31098 return nativeResponseValue;
31100 // struct LDKNetworkUpdate NetworkUpdate_channel_update_message(struct LDKChannelUpdate msg);
31102 export function NetworkUpdate_channel_update_message(msg: bigint): bigint {
31103 if(!isWasmInitialized) {
31104 throw new Error("initializeWasm() must be awaited first!");
31106 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_update_message(msg);
31107 return nativeResponseValue;
31109 // struct LDKNetworkUpdate NetworkUpdate_channel_failure(uint64_t short_channel_id, bool is_permanent);
31111 export function NetworkUpdate_channel_failure(short_channel_id: bigint, is_permanent: boolean): bigint {
31112 if(!isWasmInitialized) {
31113 throw new Error("initializeWasm() must be awaited first!");
31115 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_failure(short_channel_id, is_permanent);
31116 return nativeResponseValue;
31118 // struct LDKNetworkUpdate NetworkUpdate_node_failure(struct LDKPublicKey node_id, bool is_permanent);
31120 export function NetworkUpdate_node_failure(node_id: number, is_permanent: boolean): bigint {
31121 if(!isWasmInitialized) {
31122 throw new Error("initializeWasm() must be awaited first!");
31124 const nativeResponseValue = wasm.TS_NetworkUpdate_node_failure(node_id, is_permanent);
31125 return nativeResponseValue;
31127 // bool NetworkUpdate_eq(const struct LDKNetworkUpdate *NONNULL_PTR a, const struct LDKNetworkUpdate *NONNULL_PTR b);
31129 export function NetworkUpdate_eq(a: bigint, b: bigint): boolean {
31130 if(!isWasmInitialized) {
31131 throw new Error("initializeWasm() must be awaited first!");
31133 const nativeResponseValue = wasm.TS_NetworkUpdate_eq(a, b);
31134 return nativeResponseValue;
31136 // struct LDKCVec_u8Z NetworkUpdate_write(const struct LDKNetworkUpdate *NONNULL_PTR obj);
31138 export function NetworkUpdate_write(obj: bigint): number {
31139 if(!isWasmInitialized) {
31140 throw new Error("initializeWasm() must be awaited first!");
31142 const nativeResponseValue = wasm.TS_NetworkUpdate_write(obj);
31143 return nativeResponseValue;
31145 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ NetworkUpdate_read(struct LDKu8slice ser);
31147 export function NetworkUpdate_read(ser: number): bigint {
31148 if(!isWasmInitialized) {
31149 throw new Error("initializeWasm() must be awaited first!");
31151 const nativeResponseValue = wasm.TS_NetworkUpdate_read(ser);
31152 return nativeResponseValue;
31154 // void P2PGossipSync_free(struct LDKP2PGossipSync this_obj);
31156 export function P2PGossipSync_free(this_obj: bigint): void {
31157 if(!isWasmInitialized) {
31158 throw new Error("initializeWasm() must be awaited first!");
31160 const nativeResponseValue = wasm.TS_P2PGossipSync_free(this_obj);
31161 // debug statements here
31163 // MUST_USE_RES struct LDKP2PGossipSync P2PGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCOption_AccessZ chain_access, struct LDKLogger logger);
31165 export function P2PGossipSync_new(network_graph: bigint, chain_access: bigint, logger: bigint): bigint {
31166 if(!isWasmInitialized) {
31167 throw new Error("initializeWasm() must be awaited first!");
31169 const nativeResponseValue = wasm.TS_P2PGossipSync_new(network_graph, chain_access, logger);
31170 return nativeResponseValue;
31172 // void P2PGossipSync_add_chain_access(struct LDKP2PGossipSync *NONNULL_PTR this_arg, struct LDKCOption_AccessZ chain_access);
31174 export function P2PGossipSync_add_chain_access(this_arg: bigint, chain_access: bigint): void {
31175 if(!isWasmInitialized) {
31176 throw new Error("initializeWasm() must be awaited first!");
31178 const nativeResponseValue = wasm.TS_P2PGossipSync_add_chain_access(this_arg, chain_access);
31179 // debug statements here
31181 // struct LDKEventHandler NetworkGraph_as_EventHandler(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
31183 export function NetworkGraph_as_EventHandler(this_arg: bigint): bigint {
31184 if(!isWasmInitialized) {
31185 throw new Error("initializeWasm() must be awaited first!");
31187 const nativeResponseValue = wasm.TS_NetworkGraph_as_EventHandler(this_arg);
31188 return nativeResponseValue;
31190 // struct LDKRoutingMessageHandler P2PGossipSync_as_RoutingMessageHandler(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
31192 export function P2PGossipSync_as_RoutingMessageHandler(this_arg: bigint): bigint {
31193 if(!isWasmInitialized) {
31194 throw new Error("initializeWasm() must be awaited first!");
31196 const nativeResponseValue = wasm.TS_P2PGossipSync_as_RoutingMessageHandler(this_arg);
31197 return nativeResponseValue;
31199 // struct LDKMessageSendEventsProvider P2PGossipSync_as_MessageSendEventsProvider(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
31201 export function P2PGossipSync_as_MessageSendEventsProvider(this_arg: bigint): bigint {
31202 if(!isWasmInitialized) {
31203 throw new Error("initializeWasm() must be awaited first!");
31205 const nativeResponseValue = wasm.TS_P2PGossipSync_as_MessageSendEventsProvider(this_arg);
31206 return nativeResponseValue;
31208 // void ChannelUpdateInfo_free(struct LDKChannelUpdateInfo this_obj);
31210 export function ChannelUpdateInfo_free(this_obj: bigint): void {
31211 if(!isWasmInitialized) {
31212 throw new Error("initializeWasm() must be awaited first!");
31214 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_free(this_obj);
31215 // debug statements here
31217 // uint32_t ChannelUpdateInfo_get_last_update(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
31219 export function ChannelUpdateInfo_get_last_update(this_ptr: bigint): number {
31220 if(!isWasmInitialized) {
31221 throw new Error("initializeWasm() must be awaited first!");
31223 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update(this_ptr);
31224 return nativeResponseValue;
31226 // void ChannelUpdateInfo_set_last_update(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint32_t val);
31228 export function ChannelUpdateInfo_set_last_update(this_ptr: bigint, val: number): void {
31229 if(!isWasmInitialized) {
31230 throw new Error("initializeWasm() must be awaited first!");
31232 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update(this_ptr, val);
31233 // debug statements here
31235 // bool ChannelUpdateInfo_get_enabled(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
31237 export function ChannelUpdateInfo_get_enabled(this_ptr: bigint): boolean {
31238 if(!isWasmInitialized) {
31239 throw new Error("initializeWasm() must be awaited first!");
31241 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_enabled(this_ptr);
31242 return nativeResponseValue;
31244 // void ChannelUpdateInfo_set_enabled(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, bool val);
31246 export function ChannelUpdateInfo_set_enabled(this_ptr: bigint, val: boolean): void {
31247 if(!isWasmInitialized) {
31248 throw new Error("initializeWasm() must be awaited first!");
31250 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_enabled(this_ptr, val);
31251 // debug statements here
31253 // uint16_t ChannelUpdateInfo_get_cltv_expiry_delta(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
31255 export function ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
31256 if(!isWasmInitialized) {
31257 throw new Error("initializeWasm() must be awaited first!");
31259 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr);
31260 return nativeResponseValue;
31262 // void ChannelUpdateInfo_set_cltv_expiry_delta(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint16_t val);
31264 export function ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
31265 if(!isWasmInitialized) {
31266 throw new Error("initializeWasm() must be awaited first!");
31268 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr, val);
31269 // debug statements here
31271 // uint64_t ChannelUpdateInfo_get_htlc_minimum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
31273 export function ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr: bigint): bigint {
31274 if(!isWasmInitialized) {
31275 throw new Error("initializeWasm() must be awaited first!");
31277 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr);
31278 return nativeResponseValue;
31280 // void ChannelUpdateInfo_set_htlc_minimum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
31282 export function ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
31283 if(!isWasmInitialized) {
31284 throw new Error("initializeWasm() must be awaited first!");
31286 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr, val);
31287 // debug statements here
31289 // uint64_t ChannelUpdateInfo_get_htlc_maximum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
31291 export function ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr: bigint): bigint {
31292 if(!isWasmInitialized) {
31293 throw new Error("initializeWasm() must be awaited first!");
31295 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr);
31296 return nativeResponseValue;
31298 // void ChannelUpdateInfo_set_htlc_maximum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
31300 export function ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
31301 if(!isWasmInitialized) {
31302 throw new Error("initializeWasm() must be awaited first!");
31304 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr, val);
31305 // debug statements here
31307 // struct LDKRoutingFees ChannelUpdateInfo_get_fees(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
31309 export function ChannelUpdateInfo_get_fees(this_ptr: bigint): bigint {
31310 if(!isWasmInitialized) {
31311 throw new Error("initializeWasm() must be awaited first!");
31313 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_fees(this_ptr);
31314 return nativeResponseValue;
31316 // void ChannelUpdateInfo_set_fees(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
31318 export function ChannelUpdateInfo_set_fees(this_ptr: bigint, val: bigint): void {
31319 if(!isWasmInitialized) {
31320 throw new Error("initializeWasm() must be awaited first!");
31322 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_fees(this_ptr, val);
31323 // debug statements here
31325 // struct LDKChannelUpdate ChannelUpdateInfo_get_last_update_message(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
31327 export function ChannelUpdateInfo_get_last_update_message(this_ptr: bigint): bigint {
31328 if(!isWasmInitialized) {
31329 throw new Error("initializeWasm() must be awaited first!");
31331 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update_message(this_ptr);
31332 return nativeResponseValue;
31334 // void ChannelUpdateInfo_set_last_update_message(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdate val);
31336 export function ChannelUpdateInfo_set_last_update_message(this_ptr: bigint, val: bigint): void {
31337 if(!isWasmInitialized) {
31338 throw new Error("initializeWasm() must be awaited first!");
31340 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update_message(this_ptr, val);
31341 // debug statements here
31343 // 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);
31345 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 {
31346 if(!isWasmInitialized) {
31347 throw new Error("initializeWasm() must be awaited first!");
31349 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);
31350 return nativeResponseValue;
31352 // uint64_t ChannelUpdateInfo_clone_ptr(LDKChannelUpdateInfo *NONNULL_PTR arg);
31354 export function ChannelUpdateInfo_clone_ptr(arg: bigint): bigint {
31355 if(!isWasmInitialized) {
31356 throw new Error("initializeWasm() must be awaited first!");
31358 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone_ptr(arg);
31359 return nativeResponseValue;
31361 // struct LDKChannelUpdateInfo ChannelUpdateInfo_clone(const struct LDKChannelUpdateInfo *NONNULL_PTR orig);
31363 export function ChannelUpdateInfo_clone(orig: bigint): bigint {
31364 if(!isWasmInitialized) {
31365 throw new Error("initializeWasm() must be awaited first!");
31367 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone(orig);
31368 return nativeResponseValue;
31370 // bool ChannelUpdateInfo_eq(const struct LDKChannelUpdateInfo *NONNULL_PTR a, const struct LDKChannelUpdateInfo *NONNULL_PTR b);
31372 export function ChannelUpdateInfo_eq(a: bigint, b: bigint): boolean {
31373 if(!isWasmInitialized) {
31374 throw new Error("initializeWasm() must be awaited first!");
31376 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_eq(a, b);
31377 return nativeResponseValue;
31379 // struct LDKCVec_u8Z ChannelUpdateInfo_write(const struct LDKChannelUpdateInfo *NONNULL_PTR obj);
31381 export function ChannelUpdateInfo_write(obj: bigint): number {
31382 if(!isWasmInitialized) {
31383 throw new Error("initializeWasm() must be awaited first!");
31385 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_write(obj);
31386 return nativeResponseValue;
31388 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ ChannelUpdateInfo_read(struct LDKu8slice ser);
31390 export function ChannelUpdateInfo_read(ser: number): bigint {
31391 if(!isWasmInitialized) {
31392 throw new Error("initializeWasm() must be awaited first!");
31394 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_read(ser);
31395 return nativeResponseValue;
31397 // void ChannelInfo_free(struct LDKChannelInfo this_obj);
31399 export function ChannelInfo_free(this_obj: bigint): void {
31400 if(!isWasmInitialized) {
31401 throw new Error("initializeWasm() must be awaited first!");
31403 const nativeResponseValue = wasm.TS_ChannelInfo_free(this_obj);
31404 // debug statements here
31406 // struct LDKChannelFeatures ChannelInfo_get_features(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
31408 export function ChannelInfo_get_features(this_ptr: bigint): bigint {
31409 if(!isWasmInitialized) {
31410 throw new Error("initializeWasm() must be awaited first!");
31412 const nativeResponseValue = wasm.TS_ChannelInfo_get_features(this_ptr);
31413 return nativeResponseValue;
31415 // void ChannelInfo_set_features(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
31417 export function ChannelInfo_set_features(this_ptr: bigint, val: bigint): void {
31418 if(!isWasmInitialized) {
31419 throw new Error("initializeWasm() must be awaited first!");
31421 const nativeResponseValue = wasm.TS_ChannelInfo_set_features(this_ptr, val);
31422 // debug statements here
31424 // struct LDKNodeId ChannelInfo_get_node_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
31426 export function ChannelInfo_get_node_one(this_ptr: bigint): bigint {
31427 if(!isWasmInitialized) {
31428 throw new Error("initializeWasm() must be awaited first!");
31430 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_one(this_ptr);
31431 return nativeResponseValue;
31433 // void ChannelInfo_set_node_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
31435 export function ChannelInfo_set_node_one(this_ptr: bigint, val: bigint): void {
31436 if(!isWasmInitialized) {
31437 throw new Error("initializeWasm() must be awaited first!");
31439 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_one(this_ptr, val);
31440 // debug statements here
31442 // struct LDKChannelUpdateInfo ChannelInfo_get_one_to_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
31444 export function ChannelInfo_get_one_to_two(this_ptr: bigint): bigint {
31445 if(!isWasmInitialized) {
31446 throw new Error("initializeWasm() must be awaited first!");
31448 const nativeResponseValue = wasm.TS_ChannelInfo_get_one_to_two(this_ptr);
31449 return nativeResponseValue;
31451 // void ChannelInfo_set_one_to_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
31453 export function ChannelInfo_set_one_to_two(this_ptr: bigint, val: bigint): void {
31454 if(!isWasmInitialized) {
31455 throw new Error("initializeWasm() must be awaited first!");
31457 const nativeResponseValue = wasm.TS_ChannelInfo_set_one_to_two(this_ptr, val);
31458 // debug statements here
31460 // struct LDKNodeId ChannelInfo_get_node_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
31462 export function ChannelInfo_get_node_two(this_ptr: bigint): bigint {
31463 if(!isWasmInitialized) {
31464 throw new Error("initializeWasm() must be awaited first!");
31466 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_two(this_ptr);
31467 return nativeResponseValue;
31469 // void ChannelInfo_set_node_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
31471 export function ChannelInfo_set_node_two(this_ptr: bigint, val: bigint): void {
31472 if(!isWasmInitialized) {
31473 throw new Error("initializeWasm() must be awaited first!");
31475 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_two(this_ptr, val);
31476 // debug statements here
31478 // struct LDKChannelUpdateInfo ChannelInfo_get_two_to_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
31480 export function ChannelInfo_get_two_to_one(this_ptr: bigint): bigint {
31481 if(!isWasmInitialized) {
31482 throw new Error("initializeWasm() must be awaited first!");
31484 const nativeResponseValue = wasm.TS_ChannelInfo_get_two_to_one(this_ptr);
31485 return nativeResponseValue;
31487 // void ChannelInfo_set_two_to_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
31489 export function ChannelInfo_set_two_to_one(this_ptr: bigint, val: bigint): void {
31490 if(!isWasmInitialized) {
31491 throw new Error("initializeWasm() must be awaited first!");
31493 const nativeResponseValue = wasm.TS_ChannelInfo_set_two_to_one(this_ptr, val);
31494 // debug statements here
31496 // struct LDKCOption_u64Z ChannelInfo_get_capacity_sats(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
31498 export function ChannelInfo_get_capacity_sats(this_ptr: bigint): bigint {
31499 if(!isWasmInitialized) {
31500 throw new Error("initializeWasm() must be awaited first!");
31502 const nativeResponseValue = wasm.TS_ChannelInfo_get_capacity_sats(this_ptr);
31503 return nativeResponseValue;
31505 // void ChannelInfo_set_capacity_sats(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
31507 export function ChannelInfo_set_capacity_sats(this_ptr: bigint, val: bigint): void {
31508 if(!isWasmInitialized) {
31509 throw new Error("initializeWasm() must be awaited first!");
31511 const nativeResponseValue = wasm.TS_ChannelInfo_set_capacity_sats(this_ptr, val);
31512 // debug statements here
31514 // struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
31516 export function ChannelInfo_get_announcement_message(this_ptr: bigint): bigint {
31517 if(!isWasmInitialized) {
31518 throw new Error("initializeWasm() must be awaited first!");
31520 const nativeResponseValue = wasm.TS_ChannelInfo_get_announcement_message(this_ptr);
31521 return nativeResponseValue;
31523 // void ChannelInfo_set_announcement_message(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelAnnouncement val);
31525 export function ChannelInfo_set_announcement_message(this_ptr: bigint, val: bigint): void {
31526 if(!isWasmInitialized) {
31527 throw new Error("initializeWasm() must be awaited first!");
31529 const nativeResponseValue = wasm.TS_ChannelInfo_set_announcement_message(this_ptr, val);
31530 // debug statements here
31532 // uint64_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg);
31534 export function ChannelInfo_clone_ptr(arg: bigint): bigint {
31535 if(!isWasmInitialized) {
31536 throw new Error("initializeWasm() must be awaited first!");
31538 const nativeResponseValue = wasm.TS_ChannelInfo_clone_ptr(arg);
31539 return nativeResponseValue;
31541 // struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
31543 export function ChannelInfo_clone(orig: bigint): bigint {
31544 if(!isWasmInitialized) {
31545 throw new Error("initializeWasm() must be awaited first!");
31547 const nativeResponseValue = wasm.TS_ChannelInfo_clone(orig);
31548 return nativeResponseValue;
31550 // bool ChannelInfo_eq(const struct LDKChannelInfo *NONNULL_PTR a, const struct LDKChannelInfo *NONNULL_PTR b);
31552 export function ChannelInfo_eq(a: bigint, b: bigint): boolean {
31553 if(!isWasmInitialized) {
31554 throw new Error("initializeWasm() must be awaited first!");
31556 const nativeResponseValue = wasm.TS_ChannelInfo_eq(a, b);
31557 return nativeResponseValue;
31559 // MUST_USE_RES struct LDKChannelUpdateInfo ChannelInfo_get_directional_info(const struct LDKChannelInfo *NONNULL_PTR this_arg, uint8_t channel_flags);
31561 export function ChannelInfo_get_directional_info(this_arg: bigint, channel_flags: number): bigint {
31562 if(!isWasmInitialized) {
31563 throw new Error("initializeWasm() must be awaited first!");
31565 const nativeResponseValue = wasm.TS_ChannelInfo_get_directional_info(this_arg, channel_flags);
31566 return nativeResponseValue;
31568 // struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
31570 export function ChannelInfo_write(obj: bigint): number {
31571 if(!isWasmInitialized) {
31572 throw new Error("initializeWasm() must be awaited first!");
31574 const nativeResponseValue = wasm.TS_ChannelInfo_write(obj);
31575 return nativeResponseValue;
31577 // struct LDKCResult_ChannelInfoDecodeErrorZ ChannelInfo_read(struct LDKu8slice ser);
31579 export function ChannelInfo_read(ser: number): bigint {
31580 if(!isWasmInitialized) {
31581 throw new Error("initializeWasm() must be awaited first!");
31583 const nativeResponseValue = wasm.TS_ChannelInfo_read(ser);
31584 return nativeResponseValue;
31586 // void DirectedChannelInfo_free(struct LDKDirectedChannelInfo this_obj);
31588 export function DirectedChannelInfo_free(this_obj: bigint): void {
31589 if(!isWasmInitialized) {
31590 throw new Error("initializeWasm() must be awaited first!");
31592 const nativeResponseValue = wasm.TS_DirectedChannelInfo_free(this_obj);
31593 // debug statements here
31595 // uint64_t DirectedChannelInfo_clone_ptr(LDKDirectedChannelInfo *NONNULL_PTR arg);
31597 export function DirectedChannelInfo_clone_ptr(arg: bigint): bigint {
31598 if(!isWasmInitialized) {
31599 throw new Error("initializeWasm() must be awaited first!");
31601 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone_ptr(arg);
31602 return nativeResponseValue;
31604 // struct LDKDirectedChannelInfo DirectedChannelInfo_clone(const struct LDKDirectedChannelInfo *NONNULL_PTR orig);
31606 export function DirectedChannelInfo_clone(orig: bigint): bigint {
31607 if(!isWasmInitialized) {
31608 throw new Error("initializeWasm() must be awaited first!");
31610 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone(orig);
31611 return nativeResponseValue;
31613 // MUST_USE_RES struct LDKChannelInfo DirectedChannelInfo_channel(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
31615 export function DirectedChannelInfo_channel(this_arg: bigint): bigint {
31616 if(!isWasmInitialized) {
31617 throw new Error("initializeWasm() must be awaited first!");
31619 const nativeResponseValue = wasm.TS_DirectedChannelInfo_channel(this_arg);
31620 return nativeResponseValue;
31622 // MUST_USE_RES struct LDKChannelUpdateInfo DirectedChannelInfo_direction(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
31624 export function DirectedChannelInfo_direction(this_arg: bigint): bigint {
31625 if(!isWasmInitialized) {
31626 throw new Error("initializeWasm() must be awaited first!");
31628 const nativeResponseValue = wasm.TS_DirectedChannelInfo_direction(this_arg);
31629 return nativeResponseValue;
31631 // MUST_USE_RES uint64_t DirectedChannelInfo_htlc_maximum_msat(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
31633 export function DirectedChannelInfo_htlc_maximum_msat(this_arg: bigint): bigint {
31634 if(!isWasmInitialized) {
31635 throw new Error("initializeWasm() must be awaited first!");
31637 const nativeResponseValue = wasm.TS_DirectedChannelInfo_htlc_maximum_msat(this_arg);
31638 return nativeResponseValue;
31640 // MUST_USE_RES struct LDKEffectiveCapacity DirectedChannelInfo_effective_capacity(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
31642 export function DirectedChannelInfo_effective_capacity(this_arg: bigint): bigint {
31643 if(!isWasmInitialized) {
31644 throw new Error("initializeWasm() must be awaited first!");
31646 const nativeResponseValue = wasm.TS_DirectedChannelInfo_effective_capacity(this_arg);
31647 return nativeResponseValue;
31649 // void EffectiveCapacity_free(struct LDKEffectiveCapacity this_ptr);
31651 export function EffectiveCapacity_free(this_ptr: bigint): void {
31652 if(!isWasmInitialized) {
31653 throw new Error("initializeWasm() must be awaited first!");
31655 const nativeResponseValue = wasm.TS_EffectiveCapacity_free(this_ptr);
31656 // debug statements here
31658 // uint64_t EffectiveCapacity_clone_ptr(LDKEffectiveCapacity *NONNULL_PTR arg);
31660 export function EffectiveCapacity_clone_ptr(arg: bigint): bigint {
31661 if(!isWasmInitialized) {
31662 throw new Error("initializeWasm() must be awaited first!");
31664 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone_ptr(arg);
31665 return nativeResponseValue;
31667 // struct LDKEffectiveCapacity EffectiveCapacity_clone(const struct LDKEffectiveCapacity *NONNULL_PTR orig);
31669 export function EffectiveCapacity_clone(orig: bigint): bigint {
31670 if(!isWasmInitialized) {
31671 throw new Error("initializeWasm() must be awaited first!");
31673 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone(orig);
31674 return nativeResponseValue;
31676 // struct LDKEffectiveCapacity EffectiveCapacity_exact_liquidity(uint64_t liquidity_msat);
31678 export function EffectiveCapacity_exact_liquidity(liquidity_msat: bigint): bigint {
31679 if(!isWasmInitialized) {
31680 throw new Error("initializeWasm() must be awaited first!");
31682 const nativeResponseValue = wasm.TS_EffectiveCapacity_exact_liquidity(liquidity_msat);
31683 return nativeResponseValue;
31685 // struct LDKEffectiveCapacity EffectiveCapacity_maximum_htlc(uint64_t amount_msat);
31687 export function EffectiveCapacity_maximum_htlc(amount_msat: bigint): bigint {
31688 if(!isWasmInitialized) {
31689 throw new Error("initializeWasm() must be awaited first!");
31691 const nativeResponseValue = wasm.TS_EffectiveCapacity_maximum_htlc(amount_msat);
31692 return nativeResponseValue;
31694 // struct LDKEffectiveCapacity EffectiveCapacity_total(uint64_t capacity_msat, struct LDKCOption_u64Z htlc_maximum_msat);
31696 export function EffectiveCapacity_total(capacity_msat: bigint, htlc_maximum_msat: bigint): bigint {
31697 if(!isWasmInitialized) {
31698 throw new Error("initializeWasm() must be awaited first!");
31700 const nativeResponseValue = wasm.TS_EffectiveCapacity_total(capacity_msat, htlc_maximum_msat);
31701 return nativeResponseValue;
31703 // struct LDKEffectiveCapacity EffectiveCapacity_infinite(void);
31705 export function EffectiveCapacity_infinite(): bigint {
31706 if(!isWasmInitialized) {
31707 throw new Error("initializeWasm() must be awaited first!");
31709 const nativeResponseValue = wasm.TS_EffectiveCapacity_infinite();
31710 return nativeResponseValue;
31712 // struct LDKEffectiveCapacity EffectiveCapacity_unknown(void);
31714 export function EffectiveCapacity_unknown(): bigint {
31715 if(!isWasmInitialized) {
31716 throw new Error("initializeWasm() must be awaited first!");
31718 const nativeResponseValue = wasm.TS_EffectiveCapacity_unknown();
31719 return nativeResponseValue;
31721 // MUST_USE_RES uint64_t EffectiveCapacity_as_msat(const struct LDKEffectiveCapacity *NONNULL_PTR this_arg);
31723 export function EffectiveCapacity_as_msat(this_arg: bigint): bigint {
31724 if(!isWasmInitialized) {
31725 throw new Error("initializeWasm() must be awaited first!");
31727 const nativeResponseValue = wasm.TS_EffectiveCapacity_as_msat(this_arg);
31728 return nativeResponseValue;
31730 // void RoutingFees_free(struct LDKRoutingFees this_obj);
31732 export function RoutingFees_free(this_obj: bigint): void {
31733 if(!isWasmInitialized) {
31734 throw new Error("initializeWasm() must be awaited first!");
31736 const nativeResponseValue = wasm.TS_RoutingFees_free(this_obj);
31737 // debug statements here
31739 // uint32_t RoutingFees_get_base_msat(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
31741 export function RoutingFees_get_base_msat(this_ptr: bigint): number {
31742 if(!isWasmInitialized) {
31743 throw new Error("initializeWasm() must be awaited first!");
31745 const nativeResponseValue = wasm.TS_RoutingFees_get_base_msat(this_ptr);
31746 return nativeResponseValue;
31748 // void RoutingFees_set_base_msat(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
31750 export function RoutingFees_set_base_msat(this_ptr: bigint, val: number): void {
31751 if(!isWasmInitialized) {
31752 throw new Error("initializeWasm() must be awaited first!");
31754 const nativeResponseValue = wasm.TS_RoutingFees_set_base_msat(this_ptr, val);
31755 // debug statements here
31757 // uint32_t RoutingFees_get_proportional_millionths(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
31759 export function RoutingFees_get_proportional_millionths(this_ptr: bigint): number {
31760 if(!isWasmInitialized) {
31761 throw new Error("initializeWasm() must be awaited first!");
31763 const nativeResponseValue = wasm.TS_RoutingFees_get_proportional_millionths(this_ptr);
31764 return nativeResponseValue;
31766 // void RoutingFees_set_proportional_millionths(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
31768 export function RoutingFees_set_proportional_millionths(this_ptr: bigint, val: number): void {
31769 if(!isWasmInitialized) {
31770 throw new Error("initializeWasm() must be awaited first!");
31772 const nativeResponseValue = wasm.TS_RoutingFees_set_proportional_millionths(this_ptr, val);
31773 // debug statements here
31775 // MUST_USE_RES struct LDKRoutingFees RoutingFees_new(uint32_t base_msat_arg, uint32_t proportional_millionths_arg);
31777 export function RoutingFees_new(base_msat_arg: number, proportional_millionths_arg: number): bigint {
31778 if(!isWasmInitialized) {
31779 throw new Error("initializeWasm() must be awaited first!");
31781 const nativeResponseValue = wasm.TS_RoutingFees_new(base_msat_arg, proportional_millionths_arg);
31782 return nativeResponseValue;
31784 // bool RoutingFees_eq(const struct LDKRoutingFees *NONNULL_PTR a, const struct LDKRoutingFees *NONNULL_PTR b);
31786 export function RoutingFees_eq(a: bigint, b: bigint): boolean {
31787 if(!isWasmInitialized) {
31788 throw new Error("initializeWasm() must be awaited first!");
31790 const nativeResponseValue = wasm.TS_RoutingFees_eq(a, b);
31791 return nativeResponseValue;
31793 // uint64_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg);
31795 export function RoutingFees_clone_ptr(arg: bigint): bigint {
31796 if(!isWasmInitialized) {
31797 throw new Error("initializeWasm() must be awaited first!");
31799 const nativeResponseValue = wasm.TS_RoutingFees_clone_ptr(arg);
31800 return nativeResponseValue;
31802 // struct LDKRoutingFees RoutingFees_clone(const struct LDKRoutingFees *NONNULL_PTR orig);
31804 export function RoutingFees_clone(orig: bigint): bigint {
31805 if(!isWasmInitialized) {
31806 throw new Error("initializeWasm() must be awaited first!");
31808 const nativeResponseValue = wasm.TS_RoutingFees_clone(orig);
31809 return nativeResponseValue;
31811 // uint64_t RoutingFees_hash(const struct LDKRoutingFees *NONNULL_PTR o);
31813 export function RoutingFees_hash(o: bigint): bigint {
31814 if(!isWasmInitialized) {
31815 throw new Error("initializeWasm() must be awaited first!");
31817 const nativeResponseValue = wasm.TS_RoutingFees_hash(o);
31818 return nativeResponseValue;
31820 // struct LDKCVec_u8Z RoutingFees_write(const struct LDKRoutingFees *NONNULL_PTR obj);
31822 export function RoutingFees_write(obj: bigint): number {
31823 if(!isWasmInitialized) {
31824 throw new Error("initializeWasm() must be awaited first!");
31826 const nativeResponseValue = wasm.TS_RoutingFees_write(obj);
31827 return nativeResponseValue;
31829 // struct LDKCResult_RoutingFeesDecodeErrorZ RoutingFees_read(struct LDKu8slice ser);
31831 export function RoutingFees_read(ser: number): bigint {
31832 if(!isWasmInitialized) {
31833 throw new Error("initializeWasm() must be awaited first!");
31835 const nativeResponseValue = wasm.TS_RoutingFees_read(ser);
31836 return nativeResponseValue;
31838 // void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_obj);
31840 export function NodeAnnouncementInfo_free(this_obj: bigint): void {
31841 if(!isWasmInitialized) {
31842 throw new Error("initializeWasm() must be awaited first!");
31844 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_free(this_obj);
31845 // debug statements here
31847 // struct LDKNodeFeatures NodeAnnouncementInfo_get_features(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
31849 export function NodeAnnouncementInfo_get_features(this_ptr: bigint): bigint {
31850 if(!isWasmInitialized) {
31851 throw new Error("initializeWasm() must be awaited first!");
31853 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_features(this_ptr);
31854 return nativeResponseValue;
31856 // void NodeAnnouncementInfo_set_features(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
31858 export function NodeAnnouncementInfo_set_features(this_ptr: bigint, val: bigint): void {
31859 if(!isWasmInitialized) {
31860 throw new Error("initializeWasm() must be awaited first!");
31862 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_features(this_ptr, val);
31863 // debug statements here
31865 // uint32_t NodeAnnouncementInfo_get_last_update(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
31867 export function NodeAnnouncementInfo_get_last_update(this_ptr: bigint): number {
31868 if(!isWasmInitialized) {
31869 throw new Error("initializeWasm() must be awaited first!");
31871 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_last_update(this_ptr);
31872 return nativeResponseValue;
31874 // void NodeAnnouncementInfo_set_last_update(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, uint32_t val);
31876 export function NodeAnnouncementInfo_set_last_update(this_ptr: bigint, val: number): void {
31877 if(!isWasmInitialized) {
31878 throw new Error("initializeWasm() must be awaited first!");
31880 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_last_update(this_ptr, val);
31881 // debug statements here
31883 // const uint8_t (*NodeAnnouncementInfo_get_rgb(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[3];
31885 export function NodeAnnouncementInfo_get_rgb(this_ptr: bigint): number {
31886 if(!isWasmInitialized) {
31887 throw new Error("initializeWasm() must be awaited first!");
31889 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_rgb(this_ptr);
31890 return nativeResponseValue;
31892 // void NodeAnnouncementInfo_set_rgb(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
31894 export function NodeAnnouncementInfo_set_rgb(this_ptr: bigint, val: number): void {
31895 if(!isWasmInitialized) {
31896 throw new Error("initializeWasm() must be awaited first!");
31898 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_rgb(this_ptr, val);
31899 // debug statements here
31901 // struct LDKNodeAlias NodeAnnouncementInfo_get_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
31903 export function NodeAnnouncementInfo_get_alias(this_ptr: bigint): bigint {
31904 if(!isWasmInitialized) {
31905 throw new Error("initializeWasm() must be awaited first!");
31907 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_alias(this_ptr);
31908 return nativeResponseValue;
31910 // void NodeAnnouncementInfo_set_alias(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAlias val);
31912 export function NodeAnnouncementInfo_set_alias(this_ptr: bigint, val: bigint): void {
31913 if(!isWasmInitialized) {
31914 throw new Error("initializeWasm() must be awaited first!");
31916 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_alias(this_ptr, val);
31917 // debug statements here
31919 // struct LDKCVec_NetAddressZ NodeAnnouncementInfo_get_addresses(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
31921 export function NodeAnnouncementInfo_get_addresses(this_ptr: bigint): number {
31922 if(!isWasmInitialized) {
31923 throw new Error("initializeWasm() must be awaited first!");
31925 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_addresses(this_ptr);
31926 return nativeResponseValue;
31928 // void NodeAnnouncementInfo_set_addresses(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
31930 export function NodeAnnouncementInfo_set_addresses(this_ptr: bigint, val: number): void {
31931 if(!isWasmInitialized) {
31932 throw new Error("initializeWasm() must be awaited first!");
31934 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_addresses(this_ptr, val);
31935 // debug statements here
31937 // struct LDKNodeAnnouncement NodeAnnouncementInfo_get_announcement_message(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
31939 export function NodeAnnouncementInfo_get_announcement_message(this_ptr: bigint): bigint {
31940 if(!isWasmInitialized) {
31941 throw new Error("initializeWasm() must be awaited first!");
31943 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_announcement_message(this_ptr);
31944 return nativeResponseValue;
31946 // void NodeAnnouncementInfo_set_announcement_message(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncement val);
31948 export function NodeAnnouncementInfo_set_announcement_message(this_ptr: bigint, val: bigint): void {
31949 if(!isWasmInitialized) {
31950 throw new Error("initializeWasm() must be awaited first!");
31952 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_announcement_message(this_ptr, val);
31953 // debug statements here
31955 // 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);
31957 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 {
31958 if(!isWasmInitialized) {
31959 throw new Error("initializeWasm() must be awaited first!");
31961 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_new(features_arg, last_update_arg, rgb_arg, alias_arg, addresses_arg, announcement_message_arg);
31962 return nativeResponseValue;
31964 // uint64_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg);
31966 export function NodeAnnouncementInfo_clone_ptr(arg: bigint): bigint {
31967 if(!isWasmInitialized) {
31968 throw new Error("initializeWasm() must be awaited first!");
31970 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone_ptr(arg);
31971 return nativeResponseValue;
31973 // struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
31975 export function NodeAnnouncementInfo_clone(orig: bigint): bigint {
31976 if(!isWasmInitialized) {
31977 throw new Error("initializeWasm() must be awaited first!");
31979 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone(orig);
31980 return nativeResponseValue;
31982 // bool NodeAnnouncementInfo_eq(const struct LDKNodeAnnouncementInfo *NONNULL_PTR a, const struct LDKNodeAnnouncementInfo *NONNULL_PTR b);
31984 export function NodeAnnouncementInfo_eq(a: bigint, b: bigint): boolean {
31985 if(!isWasmInitialized) {
31986 throw new Error("initializeWasm() must be awaited first!");
31988 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_eq(a, b);
31989 return nativeResponseValue;
31991 // struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementInfo *NONNULL_PTR obj);
31993 export function NodeAnnouncementInfo_write(obj: bigint): number {
31994 if(!isWasmInitialized) {
31995 throw new Error("initializeWasm() must be awaited first!");
31997 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_write(obj);
31998 return nativeResponseValue;
32000 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ NodeAnnouncementInfo_read(struct LDKu8slice ser);
32002 export function NodeAnnouncementInfo_read(ser: number): bigint {
32003 if(!isWasmInitialized) {
32004 throw new Error("initializeWasm() must be awaited first!");
32006 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_read(ser);
32007 return nativeResponseValue;
32009 // void NodeAlias_free(struct LDKNodeAlias this_obj);
32011 export function NodeAlias_free(this_obj: bigint): void {
32012 if(!isWasmInitialized) {
32013 throw new Error("initializeWasm() must be awaited first!");
32015 const nativeResponseValue = wasm.TS_NodeAlias_free(this_obj);
32016 // debug statements here
32018 // const uint8_t (*NodeAlias_get_a(const struct LDKNodeAlias *NONNULL_PTR this_ptr))[32];
32020 export function NodeAlias_get_a(this_ptr: bigint): number {
32021 if(!isWasmInitialized) {
32022 throw new Error("initializeWasm() must be awaited first!");
32024 const nativeResponseValue = wasm.TS_NodeAlias_get_a(this_ptr);
32025 return nativeResponseValue;
32027 // void NodeAlias_set_a(struct LDKNodeAlias *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32029 export function NodeAlias_set_a(this_ptr: bigint, val: number): void {
32030 if(!isWasmInitialized) {
32031 throw new Error("initializeWasm() must be awaited first!");
32033 const nativeResponseValue = wasm.TS_NodeAlias_set_a(this_ptr, val);
32034 // debug statements here
32036 // MUST_USE_RES struct LDKNodeAlias NodeAlias_new(struct LDKThirtyTwoBytes a_arg);
32038 export function NodeAlias_new(a_arg: number): bigint {
32039 if(!isWasmInitialized) {
32040 throw new Error("initializeWasm() must be awaited first!");
32042 const nativeResponseValue = wasm.TS_NodeAlias_new(a_arg);
32043 return nativeResponseValue;
32045 // uint64_t NodeAlias_clone_ptr(LDKNodeAlias *NONNULL_PTR arg);
32047 export function NodeAlias_clone_ptr(arg: bigint): bigint {
32048 if(!isWasmInitialized) {
32049 throw new Error("initializeWasm() must be awaited first!");
32051 const nativeResponseValue = wasm.TS_NodeAlias_clone_ptr(arg);
32052 return nativeResponseValue;
32054 // struct LDKNodeAlias NodeAlias_clone(const struct LDKNodeAlias *NONNULL_PTR orig);
32056 export function NodeAlias_clone(orig: bigint): bigint {
32057 if(!isWasmInitialized) {
32058 throw new Error("initializeWasm() must be awaited first!");
32060 const nativeResponseValue = wasm.TS_NodeAlias_clone(orig);
32061 return nativeResponseValue;
32063 // bool NodeAlias_eq(const struct LDKNodeAlias *NONNULL_PTR a, const struct LDKNodeAlias *NONNULL_PTR b);
32065 export function NodeAlias_eq(a: bigint, b: bigint): boolean {
32066 if(!isWasmInitialized) {
32067 throw new Error("initializeWasm() must be awaited first!");
32069 const nativeResponseValue = wasm.TS_NodeAlias_eq(a, b);
32070 return nativeResponseValue;
32072 // struct LDKCVec_u8Z NodeAlias_write(const struct LDKNodeAlias *NONNULL_PTR obj);
32074 export function NodeAlias_write(obj: bigint): number {
32075 if(!isWasmInitialized) {
32076 throw new Error("initializeWasm() must be awaited first!");
32078 const nativeResponseValue = wasm.TS_NodeAlias_write(obj);
32079 return nativeResponseValue;
32081 // struct LDKCResult_NodeAliasDecodeErrorZ NodeAlias_read(struct LDKu8slice ser);
32083 export function NodeAlias_read(ser: number): bigint {
32084 if(!isWasmInitialized) {
32085 throw new Error("initializeWasm() must be awaited first!");
32087 const nativeResponseValue = wasm.TS_NodeAlias_read(ser);
32088 return nativeResponseValue;
32090 // void NodeInfo_free(struct LDKNodeInfo this_obj);
32092 export function NodeInfo_free(this_obj: bigint): void {
32093 if(!isWasmInitialized) {
32094 throw new Error("initializeWasm() must be awaited first!");
32096 const nativeResponseValue = wasm.TS_NodeInfo_free(this_obj);
32097 // debug statements here
32099 // struct LDKCVec_u64Z NodeInfo_get_channels(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
32101 export function NodeInfo_get_channels(this_ptr: bigint): number {
32102 if(!isWasmInitialized) {
32103 throw new Error("initializeWasm() must be awaited first!");
32105 const nativeResponseValue = wasm.TS_NodeInfo_get_channels(this_ptr);
32106 return nativeResponseValue;
32108 // void NodeInfo_set_channels(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
32110 export function NodeInfo_set_channels(this_ptr: bigint, val: number): void {
32111 if(!isWasmInitialized) {
32112 throw new Error("initializeWasm() must be awaited first!");
32114 const nativeResponseValue = wasm.TS_NodeInfo_set_channels(this_ptr, val);
32115 // debug statements here
32117 // struct LDKRoutingFees NodeInfo_get_lowest_inbound_channel_fees(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
32119 export function NodeInfo_get_lowest_inbound_channel_fees(this_ptr: bigint): bigint {
32120 if(!isWasmInitialized) {
32121 throw new Error("initializeWasm() must be awaited first!");
32123 const nativeResponseValue = wasm.TS_NodeInfo_get_lowest_inbound_channel_fees(this_ptr);
32124 return nativeResponseValue;
32126 // void NodeInfo_set_lowest_inbound_channel_fees(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
32128 export function NodeInfo_set_lowest_inbound_channel_fees(this_ptr: bigint, val: bigint): void {
32129 if(!isWasmInitialized) {
32130 throw new Error("initializeWasm() must be awaited first!");
32132 const nativeResponseValue = wasm.TS_NodeInfo_set_lowest_inbound_channel_fees(this_ptr, val);
32133 // debug statements here
32135 // struct LDKNodeAnnouncementInfo NodeInfo_get_announcement_info(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
32137 export function NodeInfo_get_announcement_info(this_ptr: bigint): bigint {
32138 if(!isWasmInitialized) {
32139 throw new Error("initializeWasm() must be awaited first!");
32141 const nativeResponseValue = wasm.TS_NodeInfo_get_announcement_info(this_ptr);
32142 return nativeResponseValue;
32144 // void NodeInfo_set_announcement_info(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncementInfo val);
32146 export function NodeInfo_set_announcement_info(this_ptr: bigint, val: bigint): void {
32147 if(!isWasmInitialized) {
32148 throw new Error("initializeWasm() must be awaited first!");
32150 const nativeResponseValue = wasm.TS_NodeInfo_set_announcement_info(this_ptr, val);
32151 // debug statements here
32153 // MUST_USE_RES struct LDKNodeInfo NodeInfo_new(struct LDKCVec_u64Z channels_arg, struct LDKRoutingFees lowest_inbound_channel_fees_arg, struct LDKNodeAnnouncementInfo announcement_info_arg);
32155 export function NodeInfo_new(channels_arg: number, lowest_inbound_channel_fees_arg: bigint, announcement_info_arg: bigint): bigint {
32156 if(!isWasmInitialized) {
32157 throw new Error("initializeWasm() must be awaited first!");
32159 const nativeResponseValue = wasm.TS_NodeInfo_new(channels_arg, lowest_inbound_channel_fees_arg, announcement_info_arg);
32160 return nativeResponseValue;
32162 // uint64_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg);
32164 export function NodeInfo_clone_ptr(arg: bigint): bigint {
32165 if(!isWasmInitialized) {
32166 throw new Error("initializeWasm() must be awaited first!");
32168 const nativeResponseValue = wasm.TS_NodeInfo_clone_ptr(arg);
32169 return nativeResponseValue;
32171 // struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
32173 export function NodeInfo_clone(orig: bigint): bigint {
32174 if(!isWasmInitialized) {
32175 throw new Error("initializeWasm() must be awaited first!");
32177 const nativeResponseValue = wasm.TS_NodeInfo_clone(orig);
32178 return nativeResponseValue;
32180 // bool NodeInfo_eq(const struct LDKNodeInfo *NONNULL_PTR a, const struct LDKNodeInfo *NONNULL_PTR b);
32182 export function NodeInfo_eq(a: bigint, b: bigint): boolean {
32183 if(!isWasmInitialized) {
32184 throw new Error("initializeWasm() must be awaited first!");
32186 const nativeResponseValue = wasm.TS_NodeInfo_eq(a, b);
32187 return nativeResponseValue;
32189 // struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
32191 export function NodeInfo_write(obj: bigint): number {
32192 if(!isWasmInitialized) {
32193 throw new Error("initializeWasm() must be awaited first!");
32195 const nativeResponseValue = wasm.TS_NodeInfo_write(obj);
32196 return nativeResponseValue;
32198 // struct LDKCResult_NodeInfoDecodeErrorZ NodeInfo_read(struct LDKu8slice ser);
32200 export function NodeInfo_read(ser: number): bigint {
32201 if(!isWasmInitialized) {
32202 throw new Error("initializeWasm() must be awaited first!");
32204 const nativeResponseValue = wasm.TS_NodeInfo_read(ser);
32205 return nativeResponseValue;
32207 // struct LDKCVec_u8Z NetworkGraph_write(const struct LDKNetworkGraph *NONNULL_PTR obj);
32209 export function NetworkGraph_write(obj: bigint): number {
32210 if(!isWasmInitialized) {
32211 throw new Error("initializeWasm() must be awaited first!");
32213 const nativeResponseValue = wasm.TS_NetworkGraph_write(obj);
32214 return nativeResponseValue;
32216 // struct LDKCResult_NetworkGraphDecodeErrorZ NetworkGraph_read(struct LDKu8slice ser, struct LDKLogger arg);
32218 export function NetworkGraph_read(ser: number, arg: bigint): bigint {
32219 if(!isWasmInitialized) {
32220 throw new Error("initializeWasm() must be awaited first!");
32222 const nativeResponseValue = wasm.TS_NetworkGraph_read(ser, arg);
32223 return nativeResponseValue;
32225 // MUST_USE_RES struct LDKNetworkGraph NetworkGraph_new(struct LDKThirtyTwoBytes genesis_hash, struct LDKLogger logger);
32227 export function NetworkGraph_new(genesis_hash: number, logger: bigint): bigint {
32228 if(!isWasmInitialized) {
32229 throw new Error("initializeWasm() must be awaited first!");
32231 const nativeResponseValue = wasm.TS_NetworkGraph_new(genesis_hash, logger);
32232 return nativeResponseValue;
32234 // MUST_USE_RES struct LDKReadOnlyNetworkGraph NetworkGraph_read_only(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
32236 export function NetworkGraph_read_only(this_arg: bigint): bigint {
32237 if(!isWasmInitialized) {
32238 throw new Error("initializeWasm() must be awaited first!");
32240 const nativeResponseValue = wasm.TS_NetworkGraph_read_only(this_arg);
32241 return nativeResponseValue;
32243 // MUST_USE_RES struct LDKCOption_u32Z NetworkGraph_get_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
32245 export function NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg: bigint): bigint {
32246 if(!isWasmInitialized) {
32247 throw new Error("initializeWasm() must be awaited first!");
32249 const nativeResponseValue = wasm.TS_NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg);
32250 return nativeResponseValue;
32252 // void NetworkGraph_set_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint32_t last_rapid_gossip_sync_timestamp);
32254 export function NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg: bigint, last_rapid_gossip_sync_timestamp: number): void {
32255 if(!isWasmInitialized) {
32256 throw new Error("initializeWasm() must be awaited first!");
32258 const nativeResponseValue = wasm.TS_NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg, last_rapid_gossip_sync_timestamp);
32259 // debug statements here
32261 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
32263 export function NetworkGraph_update_node_from_announcement(this_arg: bigint, msg: bigint): bigint {
32264 if(!isWasmInitialized) {
32265 throw new Error("initializeWasm() must be awaited first!");
32267 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_announcement(this_arg, msg);
32268 return nativeResponseValue;
32270 // 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);
32272 export function NetworkGraph_update_node_from_unsigned_announcement(this_arg: bigint, msg: bigint): bigint {
32273 if(!isWasmInitialized) {
32274 throw new Error("initializeWasm() must be awaited first!");
32276 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_unsigned_announcement(this_arg, msg);
32277 return nativeResponseValue;
32279 // 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);
32281 export function NetworkGraph_update_channel_from_announcement(this_arg: bigint, msg: bigint, chain_access: bigint): bigint {
32282 if(!isWasmInitialized) {
32283 throw new Error("initializeWasm() must be awaited first!");
32285 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement(this_arg, msg, chain_access);
32286 return nativeResponseValue;
32288 // 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);
32290 export function NetworkGraph_update_channel_from_unsigned_announcement(this_arg: bigint, msg: bigint, chain_access: bigint): bigint {
32291 if(!isWasmInitialized) {
32292 throw new Error("initializeWasm() must be awaited first!");
32294 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_unsigned_announcement(this_arg, msg, chain_access);
32295 return nativeResponseValue;
32297 // 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);
32299 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 {
32300 if(!isWasmInitialized) {
32301 throw new Error("initializeWasm() must be awaited first!");
32303 const nativeResponseValue = wasm.TS_NetworkGraph_add_channel_from_partial_announcement(this_arg, short_channel_id, timestamp, features, node_id_1, node_id_2);
32304 return nativeResponseValue;
32306 // void NetworkGraph_channel_failed(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id, bool is_permanent);
32308 export function NetworkGraph_channel_failed(this_arg: bigint, short_channel_id: bigint, is_permanent: boolean): void {
32309 if(!isWasmInitialized) {
32310 throw new Error("initializeWasm() must be awaited first!");
32312 const nativeResponseValue = wasm.TS_NetworkGraph_channel_failed(this_arg, short_channel_id, is_permanent);
32313 // debug statements here
32315 // void NetworkGraph_node_failed_permanent(const struct LDKNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey node_id);
32317 export function NetworkGraph_node_failed_permanent(this_arg: bigint, node_id: number): void {
32318 if(!isWasmInitialized) {
32319 throw new Error("initializeWasm() must be awaited first!");
32321 const nativeResponseValue = wasm.TS_NetworkGraph_node_failed_permanent(this_arg, node_id);
32322 // debug statements here
32324 // void NetworkGraph_remove_stale_channels_and_tracking_with_time(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t current_time_unix);
32326 export function NetworkGraph_remove_stale_channels_and_tracking_with_time(this_arg: bigint, current_time_unix: bigint): void {
32327 if(!isWasmInitialized) {
32328 throw new Error("initializeWasm() must be awaited first!");
32330 const nativeResponseValue = wasm.TS_NetworkGraph_remove_stale_channels_and_tracking_with_time(this_arg, current_time_unix);
32331 // debug statements here
32333 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
32335 export function NetworkGraph_update_channel(this_arg: bigint, msg: bigint): bigint {
32336 if(!isWasmInitialized) {
32337 throw new Error("initializeWasm() must be awaited first!");
32339 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel(this_arg, msg);
32340 return nativeResponseValue;
32342 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_unsigned(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelUpdate *NONNULL_PTR msg);
32344 export function NetworkGraph_update_channel_unsigned(this_arg: bigint, msg: bigint): bigint {
32345 if(!isWasmInitialized) {
32346 throw new Error("initializeWasm() must be awaited first!");
32348 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_unsigned(this_arg, msg);
32349 return nativeResponseValue;
32351 // MUST_USE_RES struct LDKChannelInfo ReadOnlyNetworkGraph_channel(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id);
32353 export function ReadOnlyNetworkGraph_channel(this_arg: bigint, short_channel_id: bigint): bigint {
32354 if(!isWasmInitialized) {
32355 throw new Error("initializeWasm() must be awaited first!");
32357 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_channel(this_arg, short_channel_id);
32358 return nativeResponseValue;
32360 // MUST_USE_RES struct LDKCVec_u64Z ReadOnlyNetworkGraph_list_channels(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg);
32362 export function ReadOnlyNetworkGraph_list_channels(this_arg: bigint): number {
32363 if(!isWasmInitialized) {
32364 throw new Error("initializeWasm() must be awaited first!");
32366 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_list_channels(this_arg);
32367 return nativeResponseValue;
32369 // MUST_USE_RES struct LDKNodeInfo ReadOnlyNetworkGraph_node(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
32371 export function ReadOnlyNetworkGraph_node(this_arg: bigint, node_id: bigint): bigint {
32372 if(!isWasmInitialized) {
32373 throw new Error("initializeWasm() must be awaited first!");
32375 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_node(this_arg, node_id);
32376 return nativeResponseValue;
32378 // MUST_USE_RES struct LDKCVec_NodeIdZ ReadOnlyNetworkGraph_list_nodes(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg);
32380 export function ReadOnlyNetworkGraph_list_nodes(this_arg: bigint): number {
32381 if(!isWasmInitialized) {
32382 throw new Error("initializeWasm() must be awaited first!");
32384 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_list_nodes(this_arg);
32385 return nativeResponseValue;
32387 // MUST_USE_RES struct LDKCOption_CVec_NetAddressZZ ReadOnlyNetworkGraph_get_addresses(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey pubkey);
32389 export function ReadOnlyNetworkGraph_get_addresses(this_arg: bigint, pubkey: number): bigint {
32390 if(!isWasmInitialized) {
32391 throw new Error("initializeWasm() must be awaited first!");
32393 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_get_addresses(this_arg, pubkey);
32394 return nativeResponseValue;
32396 // void RouteHop_free(struct LDKRouteHop this_obj);
32398 export function RouteHop_free(this_obj: bigint): void {
32399 if(!isWasmInitialized) {
32400 throw new Error("initializeWasm() must be awaited first!");
32402 const nativeResponseValue = wasm.TS_RouteHop_free(this_obj);
32403 // debug statements here
32405 // struct LDKPublicKey RouteHop_get_pubkey(const struct LDKRouteHop *NONNULL_PTR this_ptr);
32407 export function RouteHop_get_pubkey(this_ptr: bigint): number {
32408 if(!isWasmInitialized) {
32409 throw new Error("initializeWasm() must be awaited first!");
32411 const nativeResponseValue = wasm.TS_RouteHop_get_pubkey(this_ptr);
32412 return nativeResponseValue;
32414 // void RouteHop_set_pubkey(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
32416 export function RouteHop_set_pubkey(this_ptr: bigint, val: number): void {
32417 if(!isWasmInitialized) {
32418 throw new Error("initializeWasm() must be awaited first!");
32420 const nativeResponseValue = wasm.TS_RouteHop_set_pubkey(this_ptr, val);
32421 // debug statements here
32423 // struct LDKNodeFeatures RouteHop_get_node_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
32425 export function RouteHop_get_node_features(this_ptr: bigint): bigint {
32426 if(!isWasmInitialized) {
32427 throw new Error("initializeWasm() must be awaited first!");
32429 const nativeResponseValue = wasm.TS_RouteHop_get_node_features(this_ptr);
32430 return nativeResponseValue;
32432 // void RouteHop_set_node_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
32434 export function RouteHop_set_node_features(this_ptr: bigint, val: bigint): void {
32435 if(!isWasmInitialized) {
32436 throw new Error("initializeWasm() must be awaited first!");
32438 const nativeResponseValue = wasm.TS_RouteHop_set_node_features(this_ptr, val);
32439 // debug statements here
32441 // uint64_t RouteHop_get_short_channel_id(const struct LDKRouteHop *NONNULL_PTR this_ptr);
32443 export function RouteHop_get_short_channel_id(this_ptr: bigint): bigint {
32444 if(!isWasmInitialized) {
32445 throw new Error("initializeWasm() must be awaited first!");
32447 const nativeResponseValue = wasm.TS_RouteHop_get_short_channel_id(this_ptr);
32448 return nativeResponseValue;
32450 // void RouteHop_set_short_channel_id(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
32452 export function RouteHop_set_short_channel_id(this_ptr: bigint, val: bigint): void {
32453 if(!isWasmInitialized) {
32454 throw new Error("initializeWasm() must be awaited first!");
32456 const nativeResponseValue = wasm.TS_RouteHop_set_short_channel_id(this_ptr, val);
32457 // debug statements here
32459 // struct LDKChannelFeatures RouteHop_get_channel_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
32461 export function RouteHop_get_channel_features(this_ptr: bigint): bigint {
32462 if(!isWasmInitialized) {
32463 throw new Error("initializeWasm() must be awaited first!");
32465 const nativeResponseValue = wasm.TS_RouteHop_get_channel_features(this_ptr);
32466 return nativeResponseValue;
32468 // void RouteHop_set_channel_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
32470 export function RouteHop_set_channel_features(this_ptr: bigint, val: bigint): void {
32471 if(!isWasmInitialized) {
32472 throw new Error("initializeWasm() must be awaited first!");
32474 const nativeResponseValue = wasm.TS_RouteHop_set_channel_features(this_ptr, val);
32475 // debug statements here
32477 // uint64_t RouteHop_get_fee_msat(const struct LDKRouteHop *NONNULL_PTR this_ptr);
32479 export function RouteHop_get_fee_msat(this_ptr: bigint): bigint {
32480 if(!isWasmInitialized) {
32481 throw new Error("initializeWasm() must be awaited first!");
32483 const nativeResponseValue = wasm.TS_RouteHop_get_fee_msat(this_ptr);
32484 return nativeResponseValue;
32486 // void RouteHop_set_fee_msat(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
32488 export function RouteHop_set_fee_msat(this_ptr: bigint, val: bigint): void {
32489 if(!isWasmInitialized) {
32490 throw new Error("initializeWasm() must be awaited first!");
32492 const nativeResponseValue = wasm.TS_RouteHop_set_fee_msat(this_ptr, val);
32493 // debug statements here
32495 // uint32_t RouteHop_get_cltv_expiry_delta(const struct LDKRouteHop *NONNULL_PTR this_ptr);
32497 export function RouteHop_get_cltv_expiry_delta(this_ptr: bigint): number {
32498 if(!isWasmInitialized) {
32499 throw new Error("initializeWasm() must be awaited first!");
32501 const nativeResponseValue = wasm.TS_RouteHop_get_cltv_expiry_delta(this_ptr);
32502 return nativeResponseValue;
32504 // void RouteHop_set_cltv_expiry_delta(struct LDKRouteHop *NONNULL_PTR this_ptr, uint32_t val);
32506 export function RouteHop_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
32507 if(!isWasmInitialized) {
32508 throw new Error("initializeWasm() must be awaited first!");
32510 const nativeResponseValue = wasm.TS_RouteHop_set_cltv_expiry_delta(this_ptr, val);
32511 // debug statements here
32513 // 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);
32515 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 {
32516 if(!isWasmInitialized) {
32517 throw new Error("initializeWasm() must be awaited first!");
32519 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);
32520 return nativeResponseValue;
32522 // uint64_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg);
32524 export function RouteHop_clone_ptr(arg: bigint): bigint {
32525 if(!isWasmInitialized) {
32526 throw new Error("initializeWasm() must be awaited first!");
32528 const nativeResponseValue = wasm.TS_RouteHop_clone_ptr(arg);
32529 return nativeResponseValue;
32531 // struct LDKRouteHop RouteHop_clone(const struct LDKRouteHop *NONNULL_PTR orig);
32533 export function RouteHop_clone(orig: bigint): bigint {
32534 if(!isWasmInitialized) {
32535 throw new Error("initializeWasm() must be awaited first!");
32537 const nativeResponseValue = wasm.TS_RouteHop_clone(orig);
32538 return nativeResponseValue;
32540 // uint64_t RouteHop_hash(const struct LDKRouteHop *NONNULL_PTR o);
32542 export function RouteHop_hash(o: bigint): bigint {
32543 if(!isWasmInitialized) {
32544 throw new Error("initializeWasm() must be awaited first!");
32546 const nativeResponseValue = wasm.TS_RouteHop_hash(o);
32547 return nativeResponseValue;
32549 // bool RouteHop_eq(const struct LDKRouteHop *NONNULL_PTR a, const struct LDKRouteHop *NONNULL_PTR b);
32551 export function RouteHop_eq(a: bigint, b: bigint): boolean {
32552 if(!isWasmInitialized) {
32553 throw new Error("initializeWasm() must be awaited first!");
32555 const nativeResponseValue = wasm.TS_RouteHop_eq(a, b);
32556 return nativeResponseValue;
32558 // struct LDKCVec_u8Z RouteHop_write(const struct LDKRouteHop *NONNULL_PTR obj);
32560 export function RouteHop_write(obj: bigint): number {
32561 if(!isWasmInitialized) {
32562 throw new Error("initializeWasm() must be awaited first!");
32564 const nativeResponseValue = wasm.TS_RouteHop_write(obj);
32565 return nativeResponseValue;
32567 // struct LDKCResult_RouteHopDecodeErrorZ RouteHop_read(struct LDKu8slice ser);
32569 export function RouteHop_read(ser: number): bigint {
32570 if(!isWasmInitialized) {
32571 throw new Error("initializeWasm() must be awaited first!");
32573 const nativeResponseValue = wasm.TS_RouteHop_read(ser);
32574 return nativeResponseValue;
32576 // void Route_free(struct LDKRoute this_obj);
32578 export function Route_free(this_obj: bigint): void {
32579 if(!isWasmInitialized) {
32580 throw new Error("initializeWasm() must be awaited first!");
32582 const nativeResponseValue = wasm.TS_Route_free(this_obj);
32583 // debug statements here
32585 // struct LDKCVec_CVec_RouteHopZZ Route_get_paths(const struct LDKRoute *NONNULL_PTR this_ptr);
32587 export function Route_get_paths(this_ptr: bigint): number {
32588 if(!isWasmInitialized) {
32589 throw new Error("initializeWasm() must be awaited first!");
32591 const nativeResponseValue = wasm.TS_Route_get_paths(this_ptr);
32592 return nativeResponseValue;
32594 // void Route_set_paths(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKCVec_CVec_RouteHopZZ val);
32596 export function Route_set_paths(this_ptr: bigint, val: number): void {
32597 if(!isWasmInitialized) {
32598 throw new Error("initializeWasm() must be awaited first!");
32600 const nativeResponseValue = wasm.TS_Route_set_paths(this_ptr, val);
32601 // debug statements here
32603 // struct LDKPaymentParameters Route_get_payment_params(const struct LDKRoute *NONNULL_PTR this_ptr);
32605 export function Route_get_payment_params(this_ptr: bigint): bigint {
32606 if(!isWasmInitialized) {
32607 throw new Error("initializeWasm() must be awaited first!");
32609 const nativeResponseValue = wasm.TS_Route_get_payment_params(this_ptr);
32610 return nativeResponseValue;
32612 // void Route_set_payment_params(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
32614 export function Route_set_payment_params(this_ptr: bigint, val: bigint): void {
32615 if(!isWasmInitialized) {
32616 throw new Error("initializeWasm() must be awaited first!");
32618 const nativeResponseValue = wasm.TS_Route_set_payment_params(this_ptr, val);
32619 // debug statements here
32621 // MUST_USE_RES struct LDKRoute Route_new(struct LDKCVec_CVec_RouteHopZZ paths_arg, struct LDKPaymentParameters payment_params_arg);
32623 export function Route_new(paths_arg: number, payment_params_arg: bigint): bigint {
32624 if(!isWasmInitialized) {
32625 throw new Error("initializeWasm() must be awaited first!");
32627 const nativeResponseValue = wasm.TS_Route_new(paths_arg, payment_params_arg);
32628 return nativeResponseValue;
32630 // uint64_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg);
32632 export function Route_clone_ptr(arg: bigint): bigint {
32633 if(!isWasmInitialized) {
32634 throw new Error("initializeWasm() must be awaited first!");
32636 const nativeResponseValue = wasm.TS_Route_clone_ptr(arg);
32637 return nativeResponseValue;
32639 // struct LDKRoute Route_clone(const struct LDKRoute *NONNULL_PTR orig);
32641 export function Route_clone(orig: bigint): bigint {
32642 if(!isWasmInitialized) {
32643 throw new Error("initializeWasm() must be awaited first!");
32645 const nativeResponseValue = wasm.TS_Route_clone(orig);
32646 return nativeResponseValue;
32648 // uint64_t Route_hash(const struct LDKRoute *NONNULL_PTR o);
32650 export function Route_hash(o: bigint): bigint {
32651 if(!isWasmInitialized) {
32652 throw new Error("initializeWasm() must be awaited first!");
32654 const nativeResponseValue = wasm.TS_Route_hash(o);
32655 return nativeResponseValue;
32657 // bool Route_eq(const struct LDKRoute *NONNULL_PTR a, const struct LDKRoute *NONNULL_PTR b);
32659 export function Route_eq(a: bigint, b: bigint): boolean {
32660 if(!isWasmInitialized) {
32661 throw new Error("initializeWasm() must be awaited first!");
32663 const nativeResponseValue = wasm.TS_Route_eq(a, b);
32664 return nativeResponseValue;
32666 // MUST_USE_RES uint64_t Route_get_total_fees(const struct LDKRoute *NONNULL_PTR this_arg);
32668 export function Route_get_total_fees(this_arg: bigint): bigint {
32669 if(!isWasmInitialized) {
32670 throw new Error("initializeWasm() must be awaited first!");
32672 const nativeResponseValue = wasm.TS_Route_get_total_fees(this_arg);
32673 return nativeResponseValue;
32675 // MUST_USE_RES uint64_t Route_get_total_amount(const struct LDKRoute *NONNULL_PTR this_arg);
32677 export function Route_get_total_amount(this_arg: bigint): bigint {
32678 if(!isWasmInitialized) {
32679 throw new Error("initializeWasm() must be awaited first!");
32681 const nativeResponseValue = wasm.TS_Route_get_total_amount(this_arg);
32682 return nativeResponseValue;
32684 // struct LDKCVec_u8Z Route_write(const struct LDKRoute *NONNULL_PTR obj);
32686 export function Route_write(obj: bigint): number {
32687 if(!isWasmInitialized) {
32688 throw new Error("initializeWasm() must be awaited first!");
32690 const nativeResponseValue = wasm.TS_Route_write(obj);
32691 return nativeResponseValue;
32693 // struct LDKCResult_RouteDecodeErrorZ Route_read(struct LDKu8slice ser);
32695 export function Route_read(ser: number): bigint {
32696 if(!isWasmInitialized) {
32697 throw new Error("initializeWasm() must be awaited first!");
32699 const nativeResponseValue = wasm.TS_Route_read(ser);
32700 return nativeResponseValue;
32702 // void RouteParameters_free(struct LDKRouteParameters this_obj);
32704 export function RouteParameters_free(this_obj: bigint): void {
32705 if(!isWasmInitialized) {
32706 throw new Error("initializeWasm() must be awaited first!");
32708 const nativeResponseValue = wasm.TS_RouteParameters_free(this_obj);
32709 // debug statements here
32711 // struct LDKPaymentParameters RouteParameters_get_payment_params(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
32713 export function RouteParameters_get_payment_params(this_ptr: bigint): bigint {
32714 if(!isWasmInitialized) {
32715 throw new Error("initializeWasm() must be awaited first!");
32717 const nativeResponseValue = wasm.TS_RouteParameters_get_payment_params(this_ptr);
32718 return nativeResponseValue;
32720 // void RouteParameters_set_payment_params(struct LDKRouteParameters *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
32722 export function RouteParameters_set_payment_params(this_ptr: bigint, val: bigint): void {
32723 if(!isWasmInitialized) {
32724 throw new Error("initializeWasm() must be awaited first!");
32726 const nativeResponseValue = wasm.TS_RouteParameters_set_payment_params(this_ptr, val);
32727 // debug statements here
32729 // uint64_t RouteParameters_get_final_value_msat(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
32731 export function RouteParameters_get_final_value_msat(this_ptr: bigint): bigint {
32732 if(!isWasmInitialized) {
32733 throw new Error("initializeWasm() must be awaited first!");
32735 const nativeResponseValue = wasm.TS_RouteParameters_get_final_value_msat(this_ptr);
32736 return nativeResponseValue;
32738 // void RouteParameters_set_final_value_msat(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint64_t val);
32740 export function RouteParameters_set_final_value_msat(this_ptr: bigint, val: bigint): void {
32741 if(!isWasmInitialized) {
32742 throw new Error("initializeWasm() must be awaited first!");
32744 const nativeResponseValue = wasm.TS_RouteParameters_set_final_value_msat(this_ptr, val);
32745 // debug statements here
32747 // uint32_t RouteParameters_get_final_cltv_expiry_delta(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
32749 export function RouteParameters_get_final_cltv_expiry_delta(this_ptr: bigint): number {
32750 if(!isWasmInitialized) {
32751 throw new Error("initializeWasm() must be awaited first!");
32753 const nativeResponseValue = wasm.TS_RouteParameters_get_final_cltv_expiry_delta(this_ptr);
32754 return nativeResponseValue;
32756 // void RouteParameters_set_final_cltv_expiry_delta(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint32_t val);
32758 export function RouteParameters_set_final_cltv_expiry_delta(this_ptr: bigint, val: number): void {
32759 if(!isWasmInitialized) {
32760 throw new Error("initializeWasm() must be awaited first!");
32762 const nativeResponseValue = wasm.TS_RouteParameters_set_final_cltv_expiry_delta(this_ptr, val);
32763 // debug statements here
32765 // 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);
32767 export function RouteParameters_new(payment_params_arg: bigint, final_value_msat_arg: bigint, final_cltv_expiry_delta_arg: number): bigint {
32768 if(!isWasmInitialized) {
32769 throw new Error("initializeWasm() must be awaited first!");
32771 const nativeResponseValue = wasm.TS_RouteParameters_new(payment_params_arg, final_value_msat_arg, final_cltv_expiry_delta_arg);
32772 return nativeResponseValue;
32774 // uint64_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg);
32776 export function RouteParameters_clone_ptr(arg: bigint): bigint {
32777 if(!isWasmInitialized) {
32778 throw new Error("initializeWasm() must be awaited first!");
32780 const nativeResponseValue = wasm.TS_RouteParameters_clone_ptr(arg);
32781 return nativeResponseValue;
32783 // struct LDKRouteParameters RouteParameters_clone(const struct LDKRouteParameters *NONNULL_PTR orig);
32785 export function RouteParameters_clone(orig: bigint): bigint {
32786 if(!isWasmInitialized) {
32787 throw new Error("initializeWasm() must be awaited first!");
32789 const nativeResponseValue = wasm.TS_RouteParameters_clone(orig);
32790 return nativeResponseValue;
32792 // struct LDKCVec_u8Z RouteParameters_write(const struct LDKRouteParameters *NONNULL_PTR obj);
32794 export function RouteParameters_write(obj: bigint): number {
32795 if(!isWasmInitialized) {
32796 throw new Error("initializeWasm() must be awaited first!");
32798 const nativeResponseValue = wasm.TS_RouteParameters_write(obj);
32799 return nativeResponseValue;
32801 // struct LDKCResult_RouteParametersDecodeErrorZ RouteParameters_read(struct LDKu8slice ser);
32803 export function RouteParameters_read(ser: number): bigint {
32804 if(!isWasmInitialized) {
32805 throw new Error("initializeWasm() must be awaited first!");
32807 const nativeResponseValue = wasm.TS_RouteParameters_read(ser);
32808 return nativeResponseValue;
32810 // void PaymentParameters_free(struct LDKPaymentParameters this_obj);
32812 export function PaymentParameters_free(this_obj: bigint): void {
32813 if(!isWasmInitialized) {
32814 throw new Error("initializeWasm() must be awaited first!");
32816 const nativeResponseValue = wasm.TS_PaymentParameters_free(this_obj);
32817 // debug statements here
32819 // struct LDKPublicKey PaymentParameters_get_payee_pubkey(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
32821 export function PaymentParameters_get_payee_pubkey(this_ptr: bigint): number {
32822 if(!isWasmInitialized) {
32823 throw new Error("initializeWasm() must be awaited first!");
32825 const nativeResponseValue = wasm.TS_PaymentParameters_get_payee_pubkey(this_ptr);
32826 return nativeResponseValue;
32828 // void PaymentParameters_set_payee_pubkey(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKPublicKey val);
32830 export function PaymentParameters_set_payee_pubkey(this_ptr: bigint, val: number): void {
32831 if(!isWasmInitialized) {
32832 throw new Error("initializeWasm() must be awaited first!");
32834 const nativeResponseValue = wasm.TS_PaymentParameters_set_payee_pubkey(this_ptr, val);
32835 // debug statements here
32837 // struct LDKInvoiceFeatures PaymentParameters_get_features(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
32839 export function PaymentParameters_get_features(this_ptr: bigint): bigint {
32840 if(!isWasmInitialized) {
32841 throw new Error("initializeWasm() must be awaited first!");
32843 const nativeResponseValue = wasm.TS_PaymentParameters_get_features(this_ptr);
32844 return nativeResponseValue;
32846 // void PaymentParameters_set_features(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKInvoiceFeatures val);
32848 export function PaymentParameters_set_features(this_ptr: bigint, val: bigint): void {
32849 if(!isWasmInitialized) {
32850 throw new Error("initializeWasm() must be awaited first!");
32852 const nativeResponseValue = wasm.TS_PaymentParameters_set_features(this_ptr, val);
32853 // debug statements here
32855 // struct LDKCVec_RouteHintZ PaymentParameters_get_route_hints(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
32857 export function PaymentParameters_get_route_hints(this_ptr: bigint): number {
32858 if(!isWasmInitialized) {
32859 throw new Error("initializeWasm() must be awaited first!");
32861 const nativeResponseValue = wasm.TS_PaymentParameters_get_route_hints(this_ptr);
32862 return nativeResponseValue;
32864 // void PaymentParameters_set_route_hints(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintZ val);
32866 export function PaymentParameters_set_route_hints(this_ptr: bigint, val: number): void {
32867 if(!isWasmInitialized) {
32868 throw new Error("initializeWasm() must be awaited first!");
32870 const nativeResponseValue = wasm.TS_PaymentParameters_set_route_hints(this_ptr, val);
32871 // debug statements here
32873 // struct LDKCOption_u64Z PaymentParameters_get_expiry_time(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
32875 export function PaymentParameters_get_expiry_time(this_ptr: bigint): bigint {
32876 if(!isWasmInitialized) {
32877 throw new Error("initializeWasm() must be awaited first!");
32879 const nativeResponseValue = wasm.TS_PaymentParameters_get_expiry_time(this_ptr);
32880 return nativeResponseValue;
32882 // void PaymentParameters_set_expiry_time(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
32884 export function PaymentParameters_set_expiry_time(this_ptr: bigint, val: bigint): void {
32885 if(!isWasmInitialized) {
32886 throw new Error("initializeWasm() must be awaited first!");
32888 const nativeResponseValue = wasm.TS_PaymentParameters_set_expiry_time(this_ptr, val);
32889 // debug statements here
32891 // uint32_t PaymentParameters_get_max_total_cltv_expiry_delta(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
32893 export function PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr: bigint): number {
32894 if(!isWasmInitialized) {
32895 throw new Error("initializeWasm() must be awaited first!");
32897 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr);
32898 return nativeResponseValue;
32900 // void PaymentParameters_set_max_total_cltv_expiry_delta(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint32_t val);
32902 export function PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr: bigint, val: number): void {
32903 if(!isWasmInitialized) {
32904 throw new Error("initializeWasm() must be awaited first!");
32906 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr, val);
32907 // debug statements here
32909 // uint8_t PaymentParameters_get_max_path_count(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
32911 export function PaymentParameters_get_max_path_count(this_ptr: bigint): number {
32912 if(!isWasmInitialized) {
32913 throw new Error("initializeWasm() must be awaited first!");
32915 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_path_count(this_ptr);
32916 return nativeResponseValue;
32918 // void PaymentParameters_set_max_path_count(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
32920 export function PaymentParameters_set_max_path_count(this_ptr: bigint, val: number): void {
32921 if(!isWasmInitialized) {
32922 throw new Error("initializeWasm() must be awaited first!");
32924 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_path_count(this_ptr, val);
32925 // debug statements here
32927 // uint8_t PaymentParameters_get_max_channel_saturation_power_of_half(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
32929 export function PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr: bigint): number {
32930 if(!isWasmInitialized) {
32931 throw new Error("initializeWasm() must be awaited first!");
32933 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr);
32934 return nativeResponseValue;
32936 // void PaymentParameters_set_max_channel_saturation_power_of_half(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
32938 export function PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr: bigint, val: number): void {
32939 if(!isWasmInitialized) {
32940 throw new Error("initializeWasm() must be awaited first!");
32942 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr, val);
32943 // debug statements here
32945 // struct LDKCVec_u64Z PaymentParameters_get_previously_failed_channels(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
32947 export function PaymentParameters_get_previously_failed_channels(this_ptr: bigint): number {
32948 if(!isWasmInitialized) {
32949 throw new Error("initializeWasm() must be awaited first!");
32951 const nativeResponseValue = wasm.TS_PaymentParameters_get_previously_failed_channels(this_ptr);
32952 return nativeResponseValue;
32954 // void PaymentParameters_set_previously_failed_channels(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
32956 export function PaymentParameters_set_previously_failed_channels(this_ptr: bigint, val: number): void {
32957 if(!isWasmInitialized) {
32958 throw new Error("initializeWasm() must be awaited first!");
32960 const nativeResponseValue = wasm.TS_PaymentParameters_set_previously_failed_channels(this_ptr, val);
32961 // debug statements here
32963 // 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);
32965 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 {
32966 if(!isWasmInitialized) {
32967 throw new Error("initializeWasm() must be awaited first!");
32969 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);
32970 return nativeResponseValue;
32972 // uint64_t PaymentParameters_clone_ptr(LDKPaymentParameters *NONNULL_PTR arg);
32974 export function PaymentParameters_clone_ptr(arg: bigint): bigint {
32975 if(!isWasmInitialized) {
32976 throw new Error("initializeWasm() must be awaited first!");
32978 const nativeResponseValue = wasm.TS_PaymentParameters_clone_ptr(arg);
32979 return nativeResponseValue;
32981 // struct LDKPaymentParameters PaymentParameters_clone(const struct LDKPaymentParameters *NONNULL_PTR orig);
32983 export function PaymentParameters_clone(orig: bigint): bigint {
32984 if(!isWasmInitialized) {
32985 throw new Error("initializeWasm() must be awaited first!");
32987 const nativeResponseValue = wasm.TS_PaymentParameters_clone(orig);
32988 return nativeResponseValue;
32990 // uint64_t PaymentParameters_hash(const struct LDKPaymentParameters *NONNULL_PTR o);
32992 export function PaymentParameters_hash(o: bigint): bigint {
32993 if(!isWasmInitialized) {
32994 throw new Error("initializeWasm() must be awaited first!");
32996 const nativeResponseValue = wasm.TS_PaymentParameters_hash(o);
32997 return nativeResponseValue;
32999 // bool PaymentParameters_eq(const struct LDKPaymentParameters *NONNULL_PTR a, const struct LDKPaymentParameters *NONNULL_PTR b);
33001 export function PaymentParameters_eq(a: bigint, b: bigint): boolean {
33002 if(!isWasmInitialized) {
33003 throw new Error("initializeWasm() must be awaited first!");
33005 const nativeResponseValue = wasm.TS_PaymentParameters_eq(a, b);
33006 return nativeResponseValue;
33008 // struct LDKCVec_u8Z PaymentParameters_write(const struct LDKPaymentParameters *NONNULL_PTR obj);
33010 export function PaymentParameters_write(obj: bigint): number {
33011 if(!isWasmInitialized) {
33012 throw new Error("initializeWasm() must be awaited first!");
33014 const nativeResponseValue = wasm.TS_PaymentParameters_write(obj);
33015 return nativeResponseValue;
33017 // struct LDKCResult_PaymentParametersDecodeErrorZ PaymentParameters_read(struct LDKu8slice ser);
33019 export function PaymentParameters_read(ser: number): bigint {
33020 if(!isWasmInitialized) {
33021 throw new Error("initializeWasm() must be awaited first!");
33023 const nativeResponseValue = wasm.TS_PaymentParameters_read(ser);
33024 return nativeResponseValue;
33026 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_from_node_id(struct LDKPublicKey payee_pubkey);
33028 export function PaymentParameters_from_node_id(payee_pubkey: number): bigint {
33029 if(!isWasmInitialized) {
33030 throw new Error("initializeWasm() must be awaited first!");
33032 const nativeResponseValue = wasm.TS_PaymentParameters_from_node_id(payee_pubkey);
33033 return nativeResponseValue;
33035 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_for_keysend(struct LDKPublicKey payee_pubkey);
33037 export function PaymentParameters_for_keysend(payee_pubkey: number): bigint {
33038 if(!isWasmInitialized) {
33039 throw new Error("initializeWasm() must be awaited first!");
33041 const nativeResponseValue = wasm.TS_PaymentParameters_for_keysend(payee_pubkey);
33042 return nativeResponseValue;
33044 // void RouteHint_free(struct LDKRouteHint this_obj);
33046 export function RouteHint_free(this_obj: bigint): void {
33047 if(!isWasmInitialized) {
33048 throw new Error("initializeWasm() must be awaited first!");
33050 const nativeResponseValue = wasm.TS_RouteHint_free(this_obj);
33051 // debug statements here
33053 // struct LDKCVec_RouteHintHopZ RouteHint_get_a(const struct LDKRouteHint *NONNULL_PTR this_ptr);
33055 export function RouteHint_get_a(this_ptr: bigint): number {
33056 if(!isWasmInitialized) {
33057 throw new Error("initializeWasm() must be awaited first!");
33059 const nativeResponseValue = wasm.TS_RouteHint_get_a(this_ptr);
33060 return nativeResponseValue;
33062 // void RouteHint_set_a(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintHopZ val);
33064 export function RouteHint_set_a(this_ptr: bigint, val: number): void {
33065 if(!isWasmInitialized) {
33066 throw new Error("initializeWasm() must be awaited first!");
33068 const nativeResponseValue = wasm.TS_RouteHint_set_a(this_ptr, val);
33069 // debug statements here
33071 // MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKCVec_RouteHintHopZ a_arg);
33073 export function RouteHint_new(a_arg: number): bigint {
33074 if(!isWasmInitialized) {
33075 throw new Error("initializeWasm() must be awaited first!");
33077 const nativeResponseValue = wasm.TS_RouteHint_new(a_arg);
33078 return nativeResponseValue;
33080 // uint64_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg);
33082 export function RouteHint_clone_ptr(arg: bigint): bigint {
33083 if(!isWasmInitialized) {
33084 throw new Error("initializeWasm() must be awaited first!");
33086 const nativeResponseValue = wasm.TS_RouteHint_clone_ptr(arg);
33087 return nativeResponseValue;
33089 // struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
33091 export function RouteHint_clone(orig: bigint): bigint {
33092 if(!isWasmInitialized) {
33093 throw new Error("initializeWasm() must be awaited first!");
33095 const nativeResponseValue = wasm.TS_RouteHint_clone(orig);
33096 return nativeResponseValue;
33098 // uint64_t RouteHint_hash(const struct LDKRouteHint *NONNULL_PTR o);
33100 export function RouteHint_hash(o: bigint): bigint {
33101 if(!isWasmInitialized) {
33102 throw new Error("initializeWasm() must be awaited first!");
33104 const nativeResponseValue = wasm.TS_RouteHint_hash(o);
33105 return nativeResponseValue;
33107 // bool RouteHint_eq(const struct LDKRouteHint *NONNULL_PTR a, const struct LDKRouteHint *NONNULL_PTR b);
33109 export function RouteHint_eq(a: bigint, b: bigint): boolean {
33110 if(!isWasmInitialized) {
33111 throw new Error("initializeWasm() must be awaited first!");
33113 const nativeResponseValue = wasm.TS_RouteHint_eq(a, b);
33114 return nativeResponseValue;
33116 // struct LDKCVec_u8Z RouteHint_write(const struct LDKRouteHint *NONNULL_PTR obj);
33118 export function RouteHint_write(obj: bigint): number {
33119 if(!isWasmInitialized) {
33120 throw new Error("initializeWasm() must be awaited first!");
33122 const nativeResponseValue = wasm.TS_RouteHint_write(obj);
33123 return nativeResponseValue;
33125 // struct LDKCResult_RouteHintDecodeErrorZ RouteHint_read(struct LDKu8slice ser);
33127 export function RouteHint_read(ser: number): bigint {
33128 if(!isWasmInitialized) {
33129 throw new Error("initializeWasm() must be awaited first!");
33131 const nativeResponseValue = wasm.TS_RouteHint_read(ser);
33132 return nativeResponseValue;
33134 // void RouteHintHop_free(struct LDKRouteHintHop this_obj);
33136 export function RouteHintHop_free(this_obj: bigint): void {
33137 if(!isWasmInitialized) {
33138 throw new Error("initializeWasm() must be awaited first!");
33140 const nativeResponseValue = wasm.TS_RouteHintHop_free(this_obj);
33141 // debug statements here
33143 // struct LDKPublicKey RouteHintHop_get_src_node_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
33145 export function RouteHintHop_get_src_node_id(this_ptr: bigint): number {
33146 if(!isWasmInitialized) {
33147 throw new Error("initializeWasm() must be awaited first!");
33149 const nativeResponseValue = wasm.TS_RouteHintHop_get_src_node_id(this_ptr);
33150 return nativeResponseValue;
33152 // void RouteHintHop_set_src_node_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
33154 export function RouteHintHop_set_src_node_id(this_ptr: bigint, val: number): void {
33155 if(!isWasmInitialized) {
33156 throw new Error("initializeWasm() must be awaited first!");
33158 const nativeResponseValue = wasm.TS_RouteHintHop_set_src_node_id(this_ptr, val);
33159 // debug statements here
33161 // uint64_t RouteHintHop_get_short_channel_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
33163 export function RouteHintHop_get_short_channel_id(this_ptr: bigint): bigint {
33164 if(!isWasmInitialized) {
33165 throw new Error("initializeWasm() must be awaited first!");
33167 const nativeResponseValue = wasm.TS_RouteHintHop_get_short_channel_id(this_ptr);
33168 return nativeResponseValue;
33170 // void RouteHintHop_set_short_channel_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint64_t val);
33172 export function RouteHintHop_set_short_channel_id(this_ptr: bigint, val: bigint): void {
33173 if(!isWasmInitialized) {
33174 throw new Error("initializeWasm() must be awaited first!");
33176 const nativeResponseValue = wasm.TS_RouteHintHop_set_short_channel_id(this_ptr, val);
33177 // debug statements here
33179 // struct LDKRoutingFees RouteHintHop_get_fees(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
33181 export function RouteHintHop_get_fees(this_ptr: bigint): bigint {
33182 if(!isWasmInitialized) {
33183 throw new Error("initializeWasm() must be awaited first!");
33185 const nativeResponseValue = wasm.TS_RouteHintHop_get_fees(this_ptr);
33186 return nativeResponseValue;
33188 // void RouteHintHop_set_fees(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
33190 export function RouteHintHop_set_fees(this_ptr: bigint, val: bigint): void {
33191 if(!isWasmInitialized) {
33192 throw new Error("initializeWasm() must be awaited first!");
33194 const nativeResponseValue = wasm.TS_RouteHintHop_set_fees(this_ptr, val);
33195 // debug statements here
33197 // uint16_t RouteHintHop_get_cltv_expiry_delta(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
33199 export function RouteHintHop_get_cltv_expiry_delta(this_ptr: bigint): number {
33200 if(!isWasmInitialized) {
33201 throw new Error("initializeWasm() must be awaited first!");
33203 const nativeResponseValue = wasm.TS_RouteHintHop_get_cltv_expiry_delta(this_ptr);
33204 return nativeResponseValue;
33206 // void RouteHintHop_set_cltv_expiry_delta(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint16_t val);
33208 export function RouteHintHop_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
33209 if(!isWasmInitialized) {
33210 throw new Error("initializeWasm() must be awaited first!");
33212 const nativeResponseValue = wasm.TS_RouteHintHop_set_cltv_expiry_delta(this_ptr, val);
33213 // debug statements here
33215 // struct LDKCOption_u64Z RouteHintHop_get_htlc_minimum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
33217 export function RouteHintHop_get_htlc_minimum_msat(this_ptr: bigint): bigint {
33218 if(!isWasmInitialized) {
33219 throw new Error("initializeWasm() must be awaited first!");
33221 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_minimum_msat(this_ptr);
33222 return nativeResponseValue;
33224 // void RouteHintHop_set_htlc_minimum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
33226 export function RouteHintHop_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
33227 if(!isWasmInitialized) {
33228 throw new Error("initializeWasm() must be awaited first!");
33230 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_minimum_msat(this_ptr, val);
33231 // debug statements here
33233 // struct LDKCOption_u64Z RouteHintHop_get_htlc_maximum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
33235 export function RouteHintHop_get_htlc_maximum_msat(this_ptr: bigint): bigint {
33236 if(!isWasmInitialized) {
33237 throw new Error("initializeWasm() must be awaited first!");
33239 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_maximum_msat(this_ptr);
33240 return nativeResponseValue;
33242 // void RouteHintHop_set_htlc_maximum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
33244 export function RouteHintHop_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
33245 if(!isWasmInitialized) {
33246 throw new Error("initializeWasm() must be awaited first!");
33248 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_maximum_msat(this_ptr, val);
33249 // debug statements here
33251 // 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);
33253 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 {
33254 if(!isWasmInitialized) {
33255 throw new Error("initializeWasm() must be awaited first!");
33257 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);
33258 return nativeResponseValue;
33260 // uint64_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg);
33262 export function RouteHintHop_clone_ptr(arg: bigint): bigint {
33263 if(!isWasmInitialized) {
33264 throw new Error("initializeWasm() must be awaited first!");
33266 const nativeResponseValue = wasm.TS_RouteHintHop_clone_ptr(arg);
33267 return nativeResponseValue;
33269 // struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
33271 export function RouteHintHop_clone(orig: bigint): bigint {
33272 if(!isWasmInitialized) {
33273 throw new Error("initializeWasm() must be awaited first!");
33275 const nativeResponseValue = wasm.TS_RouteHintHop_clone(orig);
33276 return nativeResponseValue;
33278 // uint64_t RouteHintHop_hash(const struct LDKRouteHintHop *NONNULL_PTR o);
33280 export function RouteHintHop_hash(o: bigint): bigint {
33281 if(!isWasmInitialized) {
33282 throw new Error("initializeWasm() must be awaited first!");
33284 const nativeResponseValue = wasm.TS_RouteHintHop_hash(o);
33285 return nativeResponseValue;
33287 // bool RouteHintHop_eq(const struct LDKRouteHintHop *NONNULL_PTR a, const struct LDKRouteHintHop *NONNULL_PTR b);
33289 export function RouteHintHop_eq(a: bigint, b: bigint): boolean {
33290 if(!isWasmInitialized) {
33291 throw new Error("initializeWasm() must be awaited first!");
33293 const nativeResponseValue = wasm.TS_RouteHintHop_eq(a, b);
33294 return nativeResponseValue;
33296 // struct LDKCVec_u8Z RouteHintHop_write(const struct LDKRouteHintHop *NONNULL_PTR obj);
33298 export function RouteHintHop_write(obj: bigint): number {
33299 if(!isWasmInitialized) {
33300 throw new Error("initializeWasm() must be awaited first!");
33302 const nativeResponseValue = wasm.TS_RouteHintHop_write(obj);
33303 return nativeResponseValue;
33305 // struct LDKCResult_RouteHintHopDecodeErrorZ RouteHintHop_read(struct LDKu8slice ser);
33307 export function RouteHintHop_read(ser: number): bigint {
33308 if(!isWasmInitialized) {
33309 throw new Error("initializeWasm() must be awaited first!");
33311 const nativeResponseValue = wasm.TS_RouteHintHop_read(ser);
33312 return nativeResponseValue;
33314 // 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]);
33316 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 {
33317 if(!isWasmInitialized) {
33318 throw new Error("initializeWasm() must be awaited first!");
33320 const nativeResponseValue = wasm.TS_find_route(our_node_pubkey, route_params, network_graph, first_hops, logger, scorer, random_seed_bytes);
33321 return nativeResponseValue;
33323 // 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]);
33325 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 {
33326 if(!isWasmInitialized) {
33327 throw new Error("initializeWasm() must be awaited first!");
33329 const nativeResponseValue = wasm.TS_build_route_from_hops(our_node_pubkey, hops, route_params, network_graph, logger, random_seed_bytes);
33330 return nativeResponseValue;
33332 // void Score_free(struct LDKScore this_ptr);
33334 export function Score_free(this_ptr: bigint): void {
33335 if(!isWasmInitialized) {
33336 throw new Error("initializeWasm() must be awaited first!");
33338 const nativeResponseValue = wasm.TS_Score_free(this_ptr);
33339 // debug statements here
33341 // void LockableScore_free(struct LDKLockableScore this_ptr);
33343 export function LockableScore_free(this_ptr: bigint): void {
33344 if(!isWasmInitialized) {
33345 throw new Error("initializeWasm() must be awaited first!");
33347 const nativeResponseValue = wasm.TS_LockableScore_free(this_ptr);
33348 // debug statements here
33350 // void WriteableScore_free(struct LDKWriteableScore this_ptr);
33352 export function WriteableScore_free(this_ptr: bigint): void {
33353 if(!isWasmInitialized) {
33354 throw new Error("initializeWasm() must be awaited first!");
33356 const nativeResponseValue = wasm.TS_WriteableScore_free(this_ptr);
33357 // debug statements here
33359 // void MultiThreadedLockableScore_free(struct LDKMultiThreadedLockableScore this_obj);
33361 export function MultiThreadedLockableScore_free(this_obj: bigint): void {
33362 if(!isWasmInitialized) {
33363 throw new Error("initializeWasm() must be awaited first!");
33365 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_free(this_obj);
33366 // debug statements here
33368 // void MultiThreadedScoreLock_free(struct LDKMultiThreadedScoreLock this_obj);
33370 export function MultiThreadedScoreLock_free(this_obj: bigint): void {
33371 if(!isWasmInitialized) {
33372 throw new Error("initializeWasm() must be awaited first!");
33374 const nativeResponseValue = wasm.TS_MultiThreadedScoreLock_free(this_obj);
33375 // debug statements here
33377 // struct LDKScore MultiThreadedScoreLock_as_Score(const struct LDKMultiThreadedScoreLock *NONNULL_PTR this_arg);
33379 export function MultiThreadedScoreLock_as_Score(this_arg: bigint): bigint {
33380 if(!isWasmInitialized) {
33381 throw new Error("initializeWasm() must be awaited first!");
33383 const nativeResponseValue = wasm.TS_MultiThreadedScoreLock_as_Score(this_arg);
33384 return nativeResponseValue;
33386 // struct LDKCVec_u8Z MultiThreadedScoreLock_write(const struct LDKMultiThreadedScoreLock *NONNULL_PTR obj);
33388 export function MultiThreadedScoreLock_write(obj: bigint): number {
33389 if(!isWasmInitialized) {
33390 throw new Error("initializeWasm() must be awaited first!");
33392 const nativeResponseValue = wasm.TS_MultiThreadedScoreLock_write(obj);
33393 return nativeResponseValue;
33395 // struct LDKLockableScore MultiThreadedLockableScore_as_LockableScore(const struct LDKMultiThreadedLockableScore *NONNULL_PTR this_arg);
33397 export function MultiThreadedLockableScore_as_LockableScore(this_arg: bigint): bigint {
33398 if(!isWasmInitialized) {
33399 throw new Error("initializeWasm() must be awaited first!");
33401 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_as_LockableScore(this_arg);
33402 return nativeResponseValue;
33404 // struct LDKCVec_u8Z MultiThreadedLockableScore_write(const struct LDKMultiThreadedLockableScore *NONNULL_PTR obj);
33406 export function MultiThreadedLockableScore_write(obj: bigint): number {
33407 if(!isWasmInitialized) {
33408 throw new Error("initializeWasm() must be awaited first!");
33410 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_write(obj);
33411 return nativeResponseValue;
33413 // struct LDKWriteableScore MultiThreadedLockableScore_as_WriteableScore(const struct LDKMultiThreadedLockableScore *NONNULL_PTR this_arg);
33415 export function MultiThreadedLockableScore_as_WriteableScore(this_arg: bigint): bigint {
33416 if(!isWasmInitialized) {
33417 throw new Error("initializeWasm() must be awaited first!");
33419 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_as_WriteableScore(this_arg);
33420 return nativeResponseValue;
33422 // MUST_USE_RES struct LDKMultiThreadedLockableScore MultiThreadedLockableScore_new(struct LDKScore score);
33424 export function MultiThreadedLockableScore_new(score: bigint): bigint {
33425 if(!isWasmInitialized) {
33426 throw new Error("initializeWasm() must be awaited first!");
33428 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_new(score);
33429 return nativeResponseValue;
33431 // void ChannelUsage_free(struct LDKChannelUsage this_obj);
33433 export function ChannelUsage_free(this_obj: bigint): void {
33434 if(!isWasmInitialized) {
33435 throw new Error("initializeWasm() must be awaited first!");
33437 const nativeResponseValue = wasm.TS_ChannelUsage_free(this_obj);
33438 // debug statements here
33440 // uint64_t ChannelUsage_get_amount_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
33442 export function ChannelUsage_get_amount_msat(this_ptr: bigint): bigint {
33443 if(!isWasmInitialized) {
33444 throw new Error("initializeWasm() must be awaited first!");
33446 const nativeResponseValue = wasm.TS_ChannelUsage_get_amount_msat(this_ptr);
33447 return nativeResponseValue;
33449 // void ChannelUsage_set_amount_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
33451 export function ChannelUsage_set_amount_msat(this_ptr: bigint, val: bigint): void {
33452 if(!isWasmInitialized) {
33453 throw new Error("initializeWasm() must be awaited first!");
33455 const nativeResponseValue = wasm.TS_ChannelUsage_set_amount_msat(this_ptr, val);
33456 // debug statements here
33458 // uint64_t ChannelUsage_get_inflight_htlc_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
33460 export function ChannelUsage_get_inflight_htlc_msat(this_ptr: bigint): bigint {
33461 if(!isWasmInitialized) {
33462 throw new Error("initializeWasm() must be awaited first!");
33464 const nativeResponseValue = wasm.TS_ChannelUsage_get_inflight_htlc_msat(this_ptr);
33465 return nativeResponseValue;
33467 // void ChannelUsage_set_inflight_htlc_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
33469 export function ChannelUsage_set_inflight_htlc_msat(this_ptr: bigint, val: bigint): void {
33470 if(!isWasmInitialized) {
33471 throw new Error("initializeWasm() must be awaited first!");
33473 const nativeResponseValue = wasm.TS_ChannelUsage_set_inflight_htlc_msat(this_ptr, val);
33474 // debug statements here
33476 // struct LDKEffectiveCapacity ChannelUsage_get_effective_capacity(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
33478 export function ChannelUsage_get_effective_capacity(this_ptr: bigint): bigint {
33479 if(!isWasmInitialized) {
33480 throw new Error("initializeWasm() must be awaited first!");
33482 const nativeResponseValue = wasm.TS_ChannelUsage_get_effective_capacity(this_ptr);
33483 return nativeResponseValue;
33485 // void ChannelUsage_set_effective_capacity(struct LDKChannelUsage *NONNULL_PTR this_ptr, struct LDKEffectiveCapacity val);
33487 export function ChannelUsage_set_effective_capacity(this_ptr: bigint, val: bigint): void {
33488 if(!isWasmInitialized) {
33489 throw new Error("initializeWasm() must be awaited first!");
33491 const nativeResponseValue = wasm.TS_ChannelUsage_set_effective_capacity(this_ptr, val);
33492 // debug statements here
33494 // MUST_USE_RES struct LDKChannelUsage ChannelUsage_new(uint64_t amount_msat_arg, uint64_t inflight_htlc_msat_arg, struct LDKEffectiveCapacity effective_capacity_arg);
33496 export function ChannelUsage_new(amount_msat_arg: bigint, inflight_htlc_msat_arg: bigint, effective_capacity_arg: bigint): bigint {
33497 if(!isWasmInitialized) {
33498 throw new Error("initializeWasm() must be awaited first!");
33500 const nativeResponseValue = wasm.TS_ChannelUsage_new(amount_msat_arg, inflight_htlc_msat_arg, effective_capacity_arg);
33501 return nativeResponseValue;
33503 // uint64_t ChannelUsage_clone_ptr(LDKChannelUsage *NONNULL_PTR arg);
33505 export function ChannelUsage_clone_ptr(arg: bigint): bigint {
33506 if(!isWasmInitialized) {
33507 throw new Error("initializeWasm() must be awaited first!");
33509 const nativeResponseValue = wasm.TS_ChannelUsage_clone_ptr(arg);
33510 return nativeResponseValue;
33512 // struct LDKChannelUsage ChannelUsage_clone(const struct LDKChannelUsage *NONNULL_PTR orig);
33514 export function ChannelUsage_clone(orig: bigint): bigint {
33515 if(!isWasmInitialized) {
33516 throw new Error("initializeWasm() must be awaited first!");
33518 const nativeResponseValue = wasm.TS_ChannelUsage_clone(orig);
33519 return nativeResponseValue;
33521 // void FixedPenaltyScorer_free(struct LDKFixedPenaltyScorer this_obj);
33523 export function FixedPenaltyScorer_free(this_obj: bigint): void {
33524 if(!isWasmInitialized) {
33525 throw new Error("initializeWasm() must be awaited first!");
33527 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_free(this_obj);
33528 // debug statements here
33530 // uint64_t FixedPenaltyScorer_clone_ptr(LDKFixedPenaltyScorer *NONNULL_PTR arg);
33532 export function FixedPenaltyScorer_clone_ptr(arg: bigint): bigint {
33533 if(!isWasmInitialized) {
33534 throw new Error("initializeWasm() must be awaited first!");
33536 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone_ptr(arg);
33537 return nativeResponseValue;
33539 // struct LDKFixedPenaltyScorer FixedPenaltyScorer_clone(const struct LDKFixedPenaltyScorer *NONNULL_PTR orig);
33541 export function FixedPenaltyScorer_clone(orig: bigint): bigint {
33542 if(!isWasmInitialized) {
33543 throw new Error("initializeWasm() must be awaited first!");
33545 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone(orig);
33546 return nativeResponseValue;
33548 // MUST_USE_RES struct LDKFixedPenaltyScorer FixedPenaltyScorer_with_penalty(uint64_t penalty_msat);
33550 export function FixedPenaltyScorer_with_penalty(penalty_msat: bigint): bigint {
33551 if(!isWasmInitialized) {
33552 throw new Error("initializeWasm() must be awaited first!");
33554 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_with_penalty(penalty_msat);
33555 return nativeResponseValue;
33557 // struct LDKScore FixedPenaltyScorer_as_Score(const struct LDKFixedPenaltyScorer *NONNULL_PTR this_arg);
33559 export function FixedPenaltyScorer_as_Score(this_arg: bigint): bigint {
33560 if(!isWasmInitialized) {
33561 throw new Error("initializeWasm() must be awaited first!");
33563 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_as_Score(this_arg);
33564 return nativeResponseValue;
33566 // struct LDKCVec_u8Z FixedPenaltyScorer_write(const struct LDKFixedPenaltyScorer *NONNULL_PTR obj);
33568 export function FixedPenaltyScorer_write(obj: bigint): number {
33569 if(!isWasmInitialized) {
33570 throw new Error("initializeWasm() must be awaited first!");
33572 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_write(obj);
33573 return nativeResponseValue;
33575 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ FixedPenaltyScorer_read(struct LDKu8slice ser, uint64_t arg);
33577 export function FixedPenaltyScorer_read(ser: number, arg: bigint): bigint {
33578 if(!isWasmInitialized) {
33579 throw new Error("initializeWasm() must be awaited first!");
33581 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_read(ser, arg);
33582 return nativeResponseValue;
33584 // void ProbabilisticScorer_free(struct LDKProbabilisticScorer this_obj);
33586 export function ProbabilisticScorer_free(this_obj: bigint): void {
33587 if(!isWasmInitialized) {
33588 throw new Error("initializeWasm() must be awaited first!");
33590 const nativeResponseValue = wasm.TS_ProbabilisticScorer_free(this_obj);
33591 // debug statements here
33593 // void ProbabilisticScoringParameters_free(struct LDKProbabilisticScoringParameters this_obj);
33595 export function ProbabilisticScoringParameters_free(this_obj: bigint): void {
33596 if(!isWasmInitialized) {
33597 throw new Error("initializeWasm() must be awaited first!");
33599 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_free(this_obj);
33600 // debug statements here
33602 // uint64_t ProbabilisticScoringParameters_get_base_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
33604 export function ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr: bigint): bigint {
33605 if(!isWasmInitialized) {
33606 throw new Error("initializeWasm() must be awaited first!");
33608 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr);
33609 return nativeResponseValue;
33611 // void ProbabilisticScoringParameters_set_base_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
33613 export function ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr: bigint, val: bigint): void {
33614 if(!isWasmInitialized) {
33615 throw new Error("initializeWasm() must be awaited first!");
33617 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr, val);
33618 // debug statements here
33620 // uint64_t ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
33622 export function ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
33623 if(!isWasmInitialized) {
33624 throw new Error("initializeWasm() must be awaited first!");
33626 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(this_ptr);
33627 return nativeResponseValue;
33629 // void ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
33631 export function ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
33632 if(!isWasmInitialized) {
33633 throw new Error("initializeWasm() must be awaited first!");
33635 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(this_ptr, val);
33636 // debug statements here
33638 // uint64_t ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
33640 export function ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr: bigint): bigint {
33641 if(!isWasmInitialized) {
33642 throw new Error("initializeWasm() must be awaited first!");
33644 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr);
33645 return nativeResponseValue;
33647 // void ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
33649 export function ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr: bigint, val: bigint): void {
33650 if(!isWasmInitialized) {
33651 throw new Error("initializeWasm() must be awaited first!");
33653 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr, val);
33654 // debug statements here
33656 // uint64_t ProbabilisticScoringParameters_get_liquidity_offset_half_life(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
33658 export function ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr: bigint): bigint {
33659 if(!isWasmInitialized) {
33660 throw new Error("initializeWasm() must be awaited first!");
33662 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr);
33663 return nativeResponseValue;
33665 // void ProbabilisticScoringParameters_set_liquidity_offset_half_life(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
33667 export function ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr: bigint, val: bigint): void {
33668 if(!isWasmInitialized) {
33669 throw new Error("initializeWasm() must be awaited first!");
33671 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr, val);
33672 // debug statements here
33674 // uint64_t ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
33676 export function ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
33677 if(!isWasmInitialized) {
33678 throw new Error("initializeWasm() must be awaited first!");
33680 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr);
33681 return nativeResponseValue;
33683 // void ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
33685 export function ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
33686 if(!isWasmInitialized) {
33687 throw new Error("initializeWasm() must be awaited first!");
33689 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr, val);
33690 // debug statements here
33692 // uint64_t ProbabilisticScoringParameters_get_historical_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
33694 export function ProbabilisticScoringParameters_get_historical_liquidity_penalty_multiplier_msat(this_ptr: bigint): bigint {
33695 if(!isWasmInitialized) {
33696 throw new Error("initializeWasm() must be awaited first!");
33698 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_historical_liquidity_penalty_multiplier_msat(this_ptr);
33699 return nativeResponseValue;
33701 // void ProbabilisticScoringParameters_set_historical_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
33703 export function ProbabilisticScoringParameters_set_historical_liquidity_penalty_multiplier_msat(this_ptr: bigint, val: bigint): void {
33704 if(!isWasmInitialized) {
33705 throw new Error("initializeWasm() must be awaited first!");
33707 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_historical_liquidity_penalty_multiplier_msat(this_ptr, val);
33708 // debug statements here
33710 // uint64_t ProbabilisticScoringParameters_get_historical_liquidity_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
33712 export function ProbabilisticScoringParameters_get_historical_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
33713 if(!isWasmInitialized) {
33714 throw new Error("initializeWasm() must be awaited first!");
33716 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_historical_liquidity_penalty_amount_multiplier_msat(this_ptr);
33717 return nativeResponseValue;
33719 // void ProbabilisticScoringParameters_set_historical_liquidity_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
33721 export function ProbabilisticScoringParameters_set_historical_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
33722 if(!isWasmInitialized) {
33723 throw new Error("initializeWasm() must be awaited first!");
33725 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_historical_liquidity_penalty_amount_multiplier_msat(this_ptr, val);
33726 // debug statements here
33728 // uint64_t ProbabilisticScoringParameters_get_historical_no_updates_half_life(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
33730 export function ProbabilisticScoringParameters_get_historical_no_updates_half_life(this_ptr: bigint): bigint {
33731 if(!isWasmInitialized) {
33732 throw new Error("initializeWasm() must be awaited first!");
33734 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_historical_no_updates_half_life(this_ptr);
33735 return nativeResponseValue;
33737 // void ProbabilisticScoringParameters_set_historical_no_updates_half_life(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
33739 export function ProbabilisticScoringParameters_set_historical_no_updates_half_life(this_ptr: bigint, val: bigint): void {
33740 if(!isWasmInitialized) {
33741 throw new Error("initializeWasm() must be awaited first!");
33743 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_historical_no_updates_half_life(this_ptr, val);
33744 // debug statements here
33746 // uint64_t ProbabilisticScoringParameters_get_anti_probing_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
33748 export function ProbabilisticScoringParameters_get_anti_probing_penalty_msat(this_ptr: bigint): bigint {
33749 if(!isWasmInitialized) {
33750 throw new Error("initializeWasm() must be awaited first!");
33752 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_anti_probing_penalty_msat(this_ptr);
33753 return nativeResponseValue;
33755 // void ProbabilisticScoringParameters_set_anti_probing_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
33757 export function ProbabilisticScoringParameters_set_anti_probing_penalty_msat(this_ptr: bigint, val: bigint): void {
33758 if(!isWasmInitialized) {
33759 throw new Error("initializeWasm() must be awaited first!");
33761 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_anti_probing_penalty_msat(this_ptr, val);
33762 // debug statements here
33764 // uint64_t ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
33766 export function ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(this_ptr: bigint): bigint {
33767 if(!isWasmInitialized) {
33768 throw new Error("initializeWasm() must be awaited first!");
33770 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(this_ptr);
33771 return nativeResponseValue;
33773 // void ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
33775 export function ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(this_ptr: bigint, val: bigint): void {
33776 if(!isWasmInitialized) {
33777 throw new Error("initializeWasm() must be awaited first!");
33779 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(this_ptr, val);
33780 // debug statements here
33782 // uint64_t ProbabilisticScoringParameters_clone_ptr(LDKProbabilisticScoringParameters *NONNULL_PTR arg);
33784 export function ProbabilisticScoringParameters_clone_ptr(arg: bigint): bigint {
33785 if(!isWasmInitialized) {
33786 throw new Error("initializeWasm() must be awaited first!");
33788 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone_ptr(arg);
33789 return nativeResponseValue;
33791 // struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_clone(const struct LDKProbabilisticScoringParameters *NONNULL_PTR orig);
33793 export function ProbabilisticScoringParameters_clone(orig: bigint): bigint {
33794 if(!isWasmInitialized) {
33795 throw new Error("initializeWasm() must be awaited first!");
33797 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone(orig);
33798 return nativeResponseValue;
33800 // MUST_USE_RES struct LDKProbabilisticScorer ProbabilisticScorer_new(struct LDKProbabilisticScoringParameters params, const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger);
33802 export function ProbabilisticScorer_new(params: bigint, network_graph: bigint, logger: bigint): bigint {
33803 if(!isWasmInitialized) {
33804 throw new Error("initializeWasm() must be awaited first!");
33806 const nativeResponseValue = wasm.TS_ProbabilisticScorer_new(params, network_graph, logger);
33807 return nativeResponseValue;
33809 // void ProbabilisticScorer_debug_log_liquidity_stats(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
33811 export function ProbabilisticScorer_debug_log_liquidity_stats(this_arg: bigint): void {
33812 if(!isWasmInitialized) {
33813 throw new Error("initializeWasm() must be awaited first!");
33815 const nativeResponseValue = wasm.TS_ProbabilisticScorer_debug_log_liquidity_stats(this_arg);
33816 // debug statements here
33818 // 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);
33820 export function ProbabilisticScorer_estimated_channel_liquidity_range(this_arg: bigint, scid: bigint, target: bigint): bigint {
33821 if(!isWasmInitialized) {
33822 throw new Error("initializeWasm() must be awaited first!");
33824 const nativeResponseValue = wasm.TS_ProbabilisticScorer_estimated_channel_liquidity_range(this_arg, scid, target);
33825 return nativeResponseValue;
33827 // void ProbabilisticScorer_add_banned(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
33829 export function ProbabilisticScorer_add_banned(this_arg: bigint, node_id: bigint): void {
33830 if(!isWasmInitialized) {
33831 throw new Error("initializeWasm() must be awaited first!");
33833 const nativeResponseValue = wasm.TS_ProbabilisticScorer_add_banned(this_arg, node_id);
33834 // debug statements here
33836 // void ProbabilisticScorer_remove_banned(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
33838 export function ProbabilisticScorer_remove_banned(this_arg: bigint, node_id: bigint): void {
33839 if(!isWasmInitialized) {
33840 throw new Error("initializeWasm() must be awaited first!");
33842 const nativeResponseValue = wasm.TS_ProbabilisticScorer_remove_banned(this_arg, node_id);
33843 // debug statements here
33845 // void ProbabilisticScorer_set_manual_penalty(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id, uint64_t penalty);
33847 export function ProbabilisticScorer_set_manual_penalty(this_arg: bigint, node_id: bigint, penalty: bigint): void {
33848 if(!isWasmInitialized) {
33849 throw new Error("initializeWasm() must be awaited first!");
33851 const nativeResponseValue = wasm.TS_ProbabilisticScorer_set_manual_penalty(this_arg, node_id, penalty);
33852 // debug statements here
33854 // void ProbabilisticScorer_remove_manual_penalty(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
33856 export function ProbabilisticScorer_remove_manual_penalty(this_arg: bigint, node_id: bigint): void {
33857 if(!isWasmInitialized) {
33858 throw new Error("initializeWasm() must be awaited first!");
33860 const nativeResponseValue = wasm.TS_ProbabilisticScorer_remove_manual_penalty(this_arg, node_id);
33861 // debug statements here
33863 // void ProbabilisticScorer_clear_manual_penalties(struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
33865 export function ProbabilisticScorer_clear_manual_penalties(this_arg: bigint): void {
33866 if(!isWasmInitialized) {
33867 throw new Error("initializeWasm() must be awaited first!");
33869 const nativeResponseValue = wasm.TS_ProbabilisticScorer_clear_manual_penalties(this_arg);
33870 // debug statements here
33872 // void ProbabilisticScoringParameters_add_banned_from_list(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_arg, struct LDKCVec_NodeIdZ node_ids);
33874 export function ProbabilisticScoringParameters_add_banned_from_list(this_arg: bigint, node_ids: number): void {
33875 if(!isWasmInitialized) {
33876 throw new Error("initializeWasm() must be awaited first!");
33878 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_add_banned_from_list(this_arg, node_ids);
33879 // debug statements here
33881 // MUST_USE_RES struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_default(void);
33883 export function ProbabilisticScoringParameters_default(): bigint {
33884 if(!isWasmInitialized) {
33885 throw new Error("initializeWasm() must be awaited first!");
33887 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_default();
33888 return nativeResponseValue;
33890 // struct LDKScore ProbabilisticScorer_as_Score(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
33892 export function ProbabilisticScorer_as_Score(this_arg: bigint): bigint {
33893 if(!isWasmInitialized) {
33894 throw new Error("initializeWasm() must be awaited first!");
33896 const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_Score(this_arg);
33897 return nativeResponseValue;
33899 // struct LDKCVec_u8Z ProbabilisticScorer_write(const struct LDKProbabilisticScorer *NONNULL_PTR obj);
33901 export function ProbabilisticScorer_write(obj: bigint): number {
33902 if(!isWasmInitialized) {
33903 throw new Error("initializeWasm() must be awaited first!");
33905 const nativeResponseValue = wasm.TS_ProbabilisticScorer_write(obj);
33906 return nativeResponseValue;
33908 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ ProbabilisticScorer_read(struct LDKu8slice ser, struct LDKProbabilisticScoringParameters arg_a, const struct LDKNetworkGraph *NONNULL_PTR arg_b, struct LDKLogger arg_c);
33910 export function ProbabilisticScorer_read(ser: number, arg_a: bigint, arg_b: bigint, arg_c: bigint): bigint {
33911 if(!isWasmInitialized) {
33912 throw new Error("initializeWasm() must be awaited first!");
33914 const nativeResponseValue = wasm.TS_ProbabilisticScorer_read(ser, arg_a, arg_b, arg_c);
33915 return nativeResponseValue;
33917 // void BlindedRoute_free(struct LDKBlindedRoute this_obj);
33919 export function BlindedRoute_free(this_obj: bigint): void {
33920 if(!isWasmInitialized) {
33921 throw new Error("initializeWasm() must be awaited first!");
33923 const nativeResponseValue = wasm.TS_BlindedRoute_free(this_obj);
33924 // debug statements here
33926 // void BlindedHop_free(struct LDKBlindedHop this_obj);
33928 export function BlindedHop_free(this_obj: bigint): void {
33929 if(!isWasmInitialized) {
33930 throw new Error("initializeWasm() must be awaited first!");
33932 const nativeResponseValue = wasm.TS_BlindedHop_free(this_obj);
33933 // debug statements here
33935 // MUST_USE_RES struct LDKCResult_BlindedRouteNoneZ BlindedRoute_new(struct LDKCVec_PublicKeyZ node_pks, const struct LDKKeysInterface *NONNULL_PTR keys_manager);
33937 export function BlindedRoute_new(node_pks: number, keys_manager: bigint): bigint {
33938 if(!isWasmInitialized) {
33939 throw new Error("initializeWasm() must be awaited first!");
33941 const nativeResponseValue = wasm.TS_BlindedRoute_new(node_pks, keys_manager);
33942 return nativeResponseValue;
33944 // struct LDKCVec_u8Z BlindedRoute_write(const struct LDKBlindedRoute *NONNULL_PTR obj);
33946 export function BlindedRoute_write(obj: bigint): number {
33947 if(!isWasmInitialized) {
33948 throw new Error("initializeWasm() must be awaited first!");
33950 const nativeResponseValue = wasm.TS_BlindedRoute_write(obj);
33951 return nativeResponseValue;
33953 // struct LDKCResult_BlindedRouteDecodeErrorZ BlindedRoute_read(struct LDKu8slice ser);
33955 export function BlindedRoute_read(ser: number): bigint {
33956 if(!isWasmInitialized) {
33957 throw new Error("initializeWasm() must be awaited first!");
33959 const nativeResponseValue = wasm.TS_BlindedRoute_read(ser);
33960 return nativeResponseValue;
33962 // struct LDKCVec_u8Z BlindedHop_write(const struct LDKBlindedHop *NONNULL_PTR obj);
33964 export function BlindedHop_write(obj: bigint): number {
33965 if(!isWasmInitialized) {
33966 throw new Error("initializeWasm() must be awaited first!");
33968 const nativeResponseValue = wasm.TS_BlindedHop_write(obj);
33969 return nativeResponseValue;
33971 // struct LDKCResult_BlindedHopDecodeErrorZ BlindedHop_read(struct LDKu8slice ser);
33973 export function BlindedHop_read(ser: number): bigint {
33974 if(!isWasmInitialized) {
33975 throw new Error("initializeWasm() must be awaited first!");
33977 const nativeResponseValue = wasm.TS_BlindedHop_read(ser);
33978 return nativeResponseValue;
33980 // void OnionMessenger_free(struct LDKOnionMessenger this_obj);
33982 export function OnionMessenger_free(this_obj: bigint): void {
33983 if(!isWasmInitialized) {
33984 throw new Error("initializeWasm() must be awaited first!");
33986 const nativeResponseValue = wasm.TS_OnionMessenger_free(this_obj);
33987 // debug statements here
33989 // void Destination_free(struct LDKDestination this_ptr);
33991 export function Destination_free(this_ptr: bigint): void {
33992 if(!isWasmInitialized) {
33993 throw new Error("initializeWasm() must be awaited first!");
33995 const nativeResponseValue = wasm.TS_Destination_free(this_ptr);
33996 // debug statements here
33998 // struct LDKDestination Destination_node(struct LDKPublicKey a);
34000 export function Destination_node(a: number): bigint {
34001 if(!isWasmInitialized) {
34002 throw new Error("initializeWasm() must be awaited first!");
34004 const nativeResponseValue = wasm.TS_Destination_node(a);
34005 return nativeResponseValue;
34007 // struct LDKDestination Destination_blinded_route(struct LDKBlindedRoute a);
34009 export function Destination_blinded_route(a: bigint): bigint {
34010 if(!isWasmInitialized) {
34011 throw new Error("initializeWasm() must be awaited first!");
34013 const nativeResponseValue = wasm.TS_Destination_blinded_route(a);
34014 return nativeResponseValue;
34016 // void SendError_free(struct LDKSendError this_ptr);
34018 export function SendError_free(this_ptr: bigint): void {
34019 if(!isWasmInitialized) {
34020 throw new Error("initializeWasm() must be awaited first!");
34022 const nativeResponseValue = wasm.TS_SendError_free(this_ptr);
34023 // debug statements here
34025 // uint64_t SendError_clone_ptr(LDKSendError *NONNULL_PTR arg);
34027 export function SendError_clone_ptr(arg: bigint): bigint {
34028 if(!isWasmInitialized) {
34029 throw new Error("initializeWasm() must be awaited first!");
34031 const nativeResponseValue = wasm.TS_SendError_clone_ptr(arg);
34032 return nativeResponseValue;
34034 // struct LDKSendError SendError_clone(const struct LDKSendError *NONNULL_PTR orig);
34036 export function SendError_clone(orig: bigint): bigint {
34037 if(!isWasmInitialized) {
34038 throw new Error("initializeWasm() must be awaited first!");
34040 const nativeResponseValue = wasm.TS_SendError_clone(orig);
34041 return nativeResponseValue;
34043 // struct LDKSendError SendError_secp256k1(enum LDKSecp256k1Error a);
34045 export function SendError_secp256k1(a: Secp256k1Error): bigint {
34046 if(!isWasmInitialized) {
34047 throw new Error("initializeWasm() must be awaited first!");
34049 const nativeResponseValue = wasm.TS_SendError_secp256k1(a);
34050 return nativeResponseValue;
34052 // struct LDKSendError SendError_too_big_packet(void);
34054 export function SendError_too_big_packet(): bigint {
34055 if(!isWasmInitialized) {
34056 throw new Error("initializeWasm() must be awaited first!");
34058 const nativeResponseValue = wasm.TS_SendError_too_big_packet();
34059 return nativeResponseValue;
34061 // struct LDKSendError SendError_too_few_blinded_hops(void);
34063 export function SendError_too_few_blinded_hops(): bigint {
34064 if(!isWasmInitialized) {
34065 throw new Error("initializeWasm() must be awaited first!");
34067 const nativeResponseValue = wasm.TS_SendError_too_few_blinded_hops();
34068 return nativeResponseValue;
34070 // struct LDKSendError SendError_invalid_first_hop(void);
34072 export function SendError_invalid_first_hop(): bigint {
34073 if(!isWasmInitialized) {
34074 throw new Error("initializeWasm() must be awaited first!");
34076 const nativeResponseValue = wasm.TS_SendError_invalid_first_hop();
34077 return nativeResponseValue;
34079 // struct LDKSendError SendError_invalid_message(void);
34081 export function SendError_invalid_message(): bigint {
34082 if(!isWasmInitialized) {
34083 throw new Error("initializeWasm() must be awaited first!");
34085 const nativeResponseValue = wasm.TS_SendError_invalid_message();
34086 return nativeResponseValue;
34088 // struct LDKSendError SendError_buffer_full(void);
34090 export function SendError_buffer_full(): bigint {
34091 if(!isWasmInitialized) {
34092 throw new Error("initializeWasm() must be awaited first!");
34094 const nativeResponseValue = wasm.TS_SendError_buffer_full();
34095 return nativeResponseValue;
34097 // bool SendError_eq(const struct LDKSendError *NONNULL_PTR a, const struct LDKSendError *NONNULL_PTR b);
34099 export function SendError_eq(a: bigint, b: bigint): boolean {
34100 if(!isWasmInitialized) {
34101 throw new Error("initializeWasm() must be awaited first!");
34103 const nativeResponseValue = wasm.TS_SendError_eq(a, b);
34104 return nativeResponseValue;
34106 // void CustomOnionMessageHandler_free(struct LDKCustomOnionMessageHandler this_ptr);
34108 export function CustomOnionMessageHandler_free(this_ptr: bigint): void {
34109 if(!isWasmInitialized) {
34110 throw new Error("initializeWasm() must be awaited first!");
34112 const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_free(this_ptr);
34113 // debug statements here
34115 // MUST_USE_RES struct LDKOnionMessenger OnionMessenger_new(struct LDKKeysInterface keys_manager, struct LDKLogger logger, struct LDKCustomOnionMessageHandler custom_handler);
34117 export function OnionMessenger_new(keys_manager: bigint, logger: bigint, custom_handler: bigint): bigint {
34118 if(!isWasmInitialized) {
34119 throw new Error("initializeWasm() must be awaited first!");
34121 const nativeResponseValue = wasm.TS_OnionMessenger_new(keys_manager, logger, custom_handler);
34122 return nativeResponseValue;
34124 // MUST_USE_RES struct LDKCResult_NoneSendErrorZ OnionMessenger_send_custom_onion_message(const struct LDKOnionMessenger *NONNULL_PTR this_arg, struct LDKCVec_PublicKeyZ intermediate_nodes, struct LDKDestination destination, struct LDKCustomOnionMessageContents msg, struct LDKBlindedRoute reply_path);
34126 export function OnionMessenger_send_custom_onion_message(this_arg: bigint, intermediate_nodes: number, destination: bigint, msg: bigint, reply_path: bigint): bigint {
34127 if(!isWasmInitialized) {
34128 throw new Error("initializeWasm() must be awaited first!");
34130 const nativeResponseValue = wasm.TS_OnionMessenger_send_custom_onion_message(this_arg, intermediate_nodes, destination, msg, reply_path);
34131 return nativeResponseValue;
34133 // struct LDKOnionMessageHandler OnionMessenger_as_OnionMessageHandler(const struct LDKOnionMessenger *NONNULL_PTR this_arg);
34135 export function OnionMessenger_as_OnionMessageHandler(this_arg: bigint): bigint {
34136 if(!isWasmInitialized) {
34137 throw new Error("initializeWasm() must be awaited first!");
34139 const nativeResponseValue = wasm.TS_OnionMessenger_as_OnionMessageHandler(this_arg);
34140 return nativeResponseValue;
34142 // struct LDKOnionMessageProvider OnionMessenger_as_OnionMessageProvider(const struct LDKOnionMessenger *NONNULL_PTR this_arg);
34144 export function OnionMessenger_as_OnionMessageProvider(this_arg: bigint): bigint {
34145 if(!isWasmInitialized) {
34146 throw new Error("initializeWasm() must be awaited first!");
34148 const nativeResponseValue = wasm.TS_OnionMessenger_as_OnionMessageProvider(this_arg);
34149 return nativeResponseValue;
34151 // uint64_t CustomOnionMessageContents_clone_ptr(LDKCustomOnionMessageContents *NONNULL_PTR arg);
34153 export function CustomOnionMessageContents_clone_ptr(arg: bigint): bigint {
34154 if(!isWasmInitialized) {
34155 throw new Error("initializeWasm() must be awaited first!");
34157 const nativeResponseValue = wasm.TS_CustomOnionMessageContents_clone_ptr(arg);
34158 return nativeResponseValue;
34160 // struct LDKCustomOnionMessageContents CustomOnionMessageContents_clone(const struct LDKCustomOnionMessageContents *NONNULL_PTR orig);
34162 export function CustomOnionMessageContents_clone(orig: bigint): bigint {
34163 if(!isWasmInitialized) {
34164 throw new Error("initializeWasm() must be awaited first!");
34166 const nativeResponseValue = wasm.TS_CustomOnionMessageContents_clone(orig);
34167 return nativeResponseValue;
34169 // void CustomOnionMessageContents_free(struct LDKCustomOnionMessageContents this_ptr);
34171 export function CustomOnionMessageContents_free(this_ptr: bigint): void {
34172 if(!isWasmInitialized) {
34173 throw new Error("initializeWasm() must be awaited first!");
34175 const nativeResponseValue = wasm.TS_CustomOnionMessageContents_free(this_ptr);
34176 // debug statements here
34178 // void RapidGossipSync_free(struct LDKRapidGossipSync this_obj);
34180 export function RapidGossipSync_free(this_obj: bigint): void {
34181 if(!isWasmInitialized) {
34182 throw new Error("initializeWasm() must be awaited first!");
34184 const nativeResponseValue = wasm.TS_RapidGossipSync_free(this_obj);
34185 // debug statements here
34187 // MUST_USE_RES struct LDKRapidGossipSync RapidGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph);
34189 export function RapidGossipSync_new(network_graph: bigint): bigint {
34190 if(!isWasmInitialized) {
34191 throw new Error("initializeWasm() must be awaited first!");
34193 const nativeResponseValue = wasm.TS_RapidGossipSync_new(network_graph);
34194 return nativeResponseValue;
34196 // MUST_USE_RES struct LDKCResult_u32GraphSyncErrorZ RapidGossipSync_update_network_graph(const struct LDKRapidGossipSync *NONNULL_PTR this_arg, struct LDKu8slice update_data);
34198 export function RapidGossipSync_update_network_graph(this_arg: bigint, update_data: number): bigint {
34199 if(!isWasmInitialized) {
34200 throw new Error("initializeWasm() must be awaited first!");
34202 const nativeResponseValue = wasm.TS_RapidGossipSync_update_network_graph(this_arg, update_data);
34203 return nativeResponseValue;
34205 // MUST_USE_RES bool RapidGossipSync_is_initial_sync_complete(const struct LDKRapidGossipSync *NONNULL_PTR this_arg);
34207 export function RapidGossipSync_is_initial_sync_complete(this_arg: bigint): boolean {
34208 if(!isWasmInitialized) {
34209 throw new Error("initializeWasm() must be awaited first!");
34211 const nativeResponseValue = wasm.TS_RapidGossipSync_is_initial_sync_complete(this_arg);
34212 return nativeResponseValue;
34214 // void GraphSyncError_free(struct LDKGraphSyncError this_ptr);
34216 export function GraphSyncError_free(this_ptr: bigint): void {
34217 if(!isWasmInitialized) {
34218 throw new Error("initializeWasm() must be awaited first!");
34220 const nativeResponseValue = wasm.TS_GraphSyncError_free(this_ptr);
34221 // debug statements here
34223 // uint64_t GraphSyncError_clone_ptr(LDKGraphSyncError *NONNULL_PTR arg);
34225 export function GraphSyncError_clone_ptr(arg: bigint): bigint {
34226 if(!isWasmInitialized) {
34227 throw new Error("initializeWasm() must be awaited first!");
34229 const nativeResponseValue = wasm.TS_GraphSyncError_clone_ptr(arg);
34230 return nativeResponseValue;
34232 // struct LDKGraphSyncError GraphSyncError_clone(const struct LDKGraphSyncError *NONNULL_PTR orig);
34234 export function GraphSyncError_clone(orig: bigint): bigint {
34235 if(!isWasmInitialized) {
34236 throw new Error("initializeWasm() must be awaited first!");
34238 const nativeResponseValue = wasm.TS_GraphSyncError_clone(orig);
34239 return nativeResponseValue;
34241 // struct LDKGraphSyncError GraphSyncError_decode_error(struct LDKDecodeError a);
34243 export function GraphSyncError_decode_error(a: bigint): bigint {
34244 if(!isWasmInitialized) {
34245 throw new Error("initializeWasm() must be awaited first!");
34247 const nativeResponseValue = wasm.TS_GraphSyncError_decode_error(a);
34248 return nativeResponseValue;
34250 // struct LDKGraphSyncError GraphSyncError_lightning_error(struct LDKLightningError a);
34252 export function GraphSyncError_lightning_error(a: bigint): bigint {
34253 if(!isWasmInitialized) {
34254 throw new Error("initializeWasm() must be awaited first!");
34256 const nativeResponseValue = wasm.TS_GraphSyncError_lightning_error(a);
34257 return nativeResponseValue;
34259 // void ParseError_free(struct LDKParseError this_ptr);
34261 export function ParseError_free(this_ptr: bigint): void {
34262 if(!isWasmInitialized) {
34263 throw new Error("initializeWasm() must be awaited first!");
34265 const nativeResponseValue = wasm.TS_ParseError_free(this_ptr);
34266 // debug statements here
34268 // uint64_t ParseError_clone_ptr(LDKParseError *NONNULL_PTR arg);
34270 export function ParseError_clone_ptr(arg: bigint): bigint {
34271 if(!isWasmInitialized) {
34272 throw new Error("initializeWasm() must be awaited first!");
34274 const nativeResponseValue = wasm.TS_ParseError_clone_ptr(arg);
34275 return nativeResponseValue;
34277 // struct LDKParseError ParseError_clone(const struct LDKParseError *NONNULL_PTR orig);
34279 export function ParseError_clone(orig: bigint): bigint {
34280 if(!isWasmInitialized) {
34281 throw new Error("initializeWasm() must be awaited first!");
34283 const nativeResponseValue = wasm.TS_ParseError_clone(orig);
34284 return nativeResponseValue;
34286 // struct LDKParseError ParseError_bech32_error(struct LDKBech32Error a);
34288 export function ParseError_bech32_error(a: bigint): bigint {
34289 if(!isWasmInitialized) {
34290 throw new Error("initializeWasm() must be awaited first!");
34292 const nativeResponseValue = wasm.TS_ParseError_bech32_error(a);
34293 return nativeResponseValue;
34295 // struct LDKParseError ParseError_parse_amount_error(struct LDKError a);
34297 export function ParseError_parse_amount_error(a: number): bigint {
34298 if(!isWasmInitialized) {
34299 throw new Error("initializeWasm() must be awaited first!");
34301 const nativeResponseValue = wasm.TS_ParseError_parse_amount_error(a);
34302 return nativeResponseValue;
34304 // struct LDKParseError ParseError_malformed_signature(enum LDKSecp256k1Error a);
34306 export function ParseError_malformed_signature(a: Secp256k1Error): bigint {
34307 if(!isWasmInitialized) {
34308 throw new Error("initializeWasm() must be awaited first!");
34310 const nativeResponseValue = wasm.TS_ParseError_malformed_signature(a);
34311 return nativeResponseValue;
34313 // struct LDKParseError ParseError_bad_prefix(void);
34315 export function ParseError_bad_prefix(): bigint {
34316 if(!isWasmInitialized) {
34317 throw new Error("initializeWasm() must be awaited first!");
34319 const nativeResponseValue = wasm.TS_ParseError_bad_prefix();
34320 return nativeResponseValue;
34322 // struct LDKParseError ParseError_unknown_currency(void);
34324 export function ParseError_unknown_currency(): bigint {
34325 if(!isWasmInitialized) {
34326 throw new Error("initializeWasm() must be awaited first!");
34328 const nativeResponseValue = wasm.TS_ParseError_unknown_currency();
34329 return nativeResponseValue;
34331 // struct LDKParseError ParseError_unknown_si_prefix(void);
34333 export function ParseError_unknown_si_prefix(): bigint {
34334 if(!isWasmInitialized) {
34335 throw new Error("initializeWasm() must be awaited first!");
34337 const nativeResponseValue = wasm.TS_ParseError_unknown_si_prefix();
34338 return nativeResponseValue;
34340 // struct LDKParseError ParseError_malformed_hrp(void);
34342 export function ParseError_malformed_hrp(): bigint {
34343 if(!isWasmInitialized) {
34344 throw new Error("initializeWasm() must be awaited first!");
34346 const nativeResponseValue = wasm.TS_ParseError_malformed_hrp();
34347 return nativeResponseValue;
34349 // struct LDKParseError ParseError_too_short_data_part(void);
34351 export function ParseError_too_short_data_part(): bigint {
34352 if(!isWasmInitialized) {
34353 throw new Error("initializeWasm() must be awaited first!");
34355 const nativeResponseValue = wasm.TS_ParseError_too_short_data_part();
34356 return nativeResponseValue;
34358 // struct LDKParseError ParseError_unexpected_end_of_tagged_fields(void);
34360 export function ParseError_unexpected_end_of_tagged_fields(): bigint {
34361 if(!isWasmInitialized) {
34362 throw new Error("initializeWasm() must be awaited first!");
34364 const nativeResponseValue = wasm.TS_ParseError_unexpected_end_of_tagged_fields();
34365 return nativeResponseValue;
34367 // struct LDKParseError ParseError_description_decode_error(struct LDKError a);
34369 export function ParseError_description_decode_error(a: number): bigint {
34370 if(!isWasmInitialized) {
34371 throw new Error("initializeWasm() must be awaited first!");
34373 const nativeResponseValue = wasm.TS_ParseError_description_decode_error(a);
34374 return nativeResponseValue;
34376 // struct LDKParseError ParseError_padding_error(void);
34378 export function ParseError_padding_error(): bigint {
34379 if(!isWasmInitialized) {
34380 throw new Error("initializeWasm() must be awaited first!");
34382 const nativeResponseValue = wasm.TS_ParseError_padding_error();
34383 return nativeResponseValue;
34385 // struct LDKParseError ParseError_integer_overflow_error(void);
34387 export function ParseError_integer_overflow_error(): bigint {
34388 if(!isWasmInitialized) {
34389 throw new Error("initializeWasm() must be awaited first!");
34391 const nativeResponseValue = wasm.TS_ParseError_integer_overflow_error();
34392 return nativeResponseValue;
34394 // struct LDKParseError ParseError_invalid_seg_wit_program_length(void);
34396 export function ParseError_invalid_seg_wit_program_length(): bigint {
34397 if(!isWasmInitialized) {
34398 throw new Error("initializeWasm() must be awaited first!");
34400 const nativeResponseValue = wasm.TS_ParseError_invalid_seg_wit_program_length();
34401 return nativeResponseValue;
34403 // struct LDKParseError ParseError_invalid_pub_key_hash_length(void);
34405 export function ParseError_invalid_pub_key_hash_length(): bigint {
34406 if(!isWasmInitialized) {
34407 throw new Error("initializeWasm() must be awaited first!");
34409 const nativeResponseValue = wasm.TS_ParseError_invalid_pub_key_hash_length();
34410 return nativeResponseValue;
34412 // struct LDKParseError ParseError_invalid_script_hash_length(void);
34414 export function ParseError_invalid_script_hash_length(): bigint {
34415 if(!isWasmInitialized) {
34416 throw new Error("initializeWasm() must be awaited first!");
34418 const nativeResponseValue = wasm.TS_ParseError_invalid_script_hash_length();
34419 return nativeResponseValue;
34421 // struct LDKParseError ParseError_invalid_recovery_id(void);
34423 export function ParseError_invalid_recovery_id(): bigint {
34424 if(!isWasmInitialized) {
34425 throw new Error("initializeWasm() must be awaited first!");
34427 const nativeResponseValue = wasm.TS_ParseError_invalid_recovery_id();
34428 return nativeResponseValue;
34430 // struct LDKParseError ParseError_invalid_slice_length(struct LDKStr a);
34432 export function ParseError_invalid_slice_length(a: number): bigint {
34433 if(!isWasmInitialized) {
34434 throw new Error("initializeWasm() must be awaited first!");
34436 const nativeResponseValue = wasm.TS_ParseError_invalid_slice_length(a);
34437 return nativeResponseValue;
34439 // struct LDKParseError ParseError_skip(void);
34441 export function ParseError_skip(): bigint {
34442 if(!isWasmInitialized) {
34443 throw new Error("initializeWasm() must be awaited first!");
34445 const nativeResponseValue = wasm.TS_ParseError_skip();
34446 return nativeResponseValue;
34448 // bool ParseError_eq(const struct LDKParseError *NONNULL_PTR a, const struct LDKParseError *NONNULL_PTR b);
34450 export function ParseError_eq(a: bigint, b: bigint): boolean {
34451 if(!isWasmInitialized) {
34452 throw new Error("initializeWasm() must be awaited first!");
34454 const nativeResponseValue = wasm.TS_ParseError_eq(a, b);
34455 return nativeResponseValue;
34457 // void ParseOrSemanticError_free(struct LDKParseOrSemanticError this_ptr);
34459 export function ParseOrSemanticError_free(this_ptr: bigint): void {
34460 if(!isWasmInitialized) {
34461 throw new Error("initializeWasm() must be awaited first!");
34463 const nativeResponseValue = wasm.TS_ParseOrSemanticError_free(this_ptr);
34464 // debug statements here
34466 // uint64_t ParseOrSemanticError_clone_ptr(LDKParseOrSemanticError *NONNULL_PTR arg);
34468 export function ParseOrSemanticError_clone_ptr(arg: bigint): bigint {
34469 if(!isWasmInitialized) {
34470 throw new Error("initializeWasm() must be awaited first!");
34472 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone_ptr(arg);
34473 return nativeResponseValue;
34475 // struct LDKParseOrSemanticError ParseOrSemanticError_clone(const struct LDKParseOrSemanticError *NONNULL_PTR orig);
34477 export function ParseOrSemanticError_clone(orig: bigint): bigint {
34478 if(!isWasmInitialized) {
34479 throw new Error("initializeWasm() must be awaited first!");
34481 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone(orig);
34482 return nativeResponseValue;
34484 // struct LDKParseOrSemanticError ParseOrSemanticError_parse_error(struct LDKParseError a);
34486 export function ParseOrSemanticError_parse_error(a: bigint): bigint {
34487 if(!isWasmInitialized) {
34488 throw new Error("initializeWasm() must be awaited first!");
34490 const nativeResponseValue = wasm.TS_ParseOrSemanticError_parse_error(a);
34491 return nativeResponseValue;
34493 // struct LDKParseOrSemanticError ParseOrSemanticError_semantic_error(enum LDKSemanticError a);
34495 export function ParseOrSemanticError_semantic_error(a: SemanticError): bigint {
34496 if(!isWasmInitialized) {
34497 throw new Error("initializeWasm() must be awaited first!");
34499 const nativeResponseValue = wasm.TS_ParseOrSemanticError_semantic_error(a);
34500 return nativeResponseValue;
34502 // bool ParseOrSemanticError_eq(const struct LDKParseOrSemanticError *NONNULL_PTR a, const struct LDKParseOrSemanticError *NONNULL_PTR b);
34504 export function ParseOrSemanticError_eq(a: bigint, b: bigint): boolean {
34505 if(!isWasmInitialized) {
34506 throw new Error("initializeWasm() must be awaited first!");
34508 const nativeResponseValue = wasm.TS_ParseOrSemanticError_eq(a, b);
34509 return nativeResponseValue;
34511 // void Invoice_free(struct LDKInvoice this_obj);
34513 export function Invoice_free(this_obj: bigint): void {
34514 if(!isWasmInitialized) {
34515 throw new Error("initializeWasm() must be awaited first!");
34517 const nativeResponseValue = wasm.TS_Invoice_free(this_obj);
34518 // debug statements here
34520 // bool Invoice_eq(const struct LDKInvoice *NONNULL_PTR a, const struct LDKInvoice *NONNULL_PTR b);
34522 export function Invoice_eq(a: bigint, b: bigint): boolean {
34523 if(!isWasmInitialized) {
34524 throw new Error("initializeWasm() must be awaited first!");
34526 const nativeResponseValue = wasm.TS_Invoice_eq(a, b);
34527 return nativeResponseValue;
34529 // uint64_t Invoice_clone_ptr(LDKInvoice *NONNULL_PTR arg);
34531 export function Invoice_clone_ptr(arg: bigint): bigint {
34532 if(!isWasmInitialized) {
34533 throw new Error("initializeWasm() must be awaited first!");
34535 const nativeResponseValue = wasm.TS_Invoice_clone_ptr(arg);
34536 return nativeResponseValue;
34538 // struct LDKInvoice Invoice_clone(const struct LDKInvoice *NONNULL_PTR orig);
34540 export function Invoice_clone(orig: bigint): bigint {
34541 if(!isWasmInitialized) {
34542 throw new Error("initializeWasm() must be awaited first!");
34544 const nativeResponseValue = wasm.TS_Invoice_clone(orig);
34545 return nativeResponseValue;
34547 // uint64_t Invoice_hash(const struct LDKInvoice *NONNULL_PTR o);
34549 export function Invoice_hash(o: bigint): bigint {
34550 if(!isWasmInitialized) {
34551 throw new Error("initializeWasm() must be awaited first!");
34553 const nativeResponseValue = wasm.TS_Invoice_hash(o);
34554 return nativeResponseValue;
34556 // void SignedRawInvoice_free(struct LDKSignedRawInvoice this_obj);
34558 export function SignedRawInvoice_free(this_obj: bigint): void {
34559 if(!isWasmInitialized) {
34560 throw new Error("initializeWasm() must be awaited first!");
34562 const nativeResponseValue = wasm.TS_SignedRawInvoice_free(this_obj);
34563 // debug statements here
34565 // bool SignedRawInvoice_eq(const struct LDKSignedRawInvoice *NONNULL_PTR a, const struct LDKSignedRawInvoice *NONNULL_PTR b);
34567 export function SignedRawInvoice_eq(a: bigint, b: bigint): boolean {
34568 if(!isWasmInitialized) {
34569 throw new Error("initializeWasm() must be awaited first!");
34571 const nativeResponseValue = wasm.TS_SignedRawInvoice_eq(a, b);
34572 return nativeResponseValue;
34574 // uint64_t SignedRawInvoice_clone_ptr(LDKSignedRawInvoice *NONNULL_PTR arg);
34576 export function SignedRawInvoice_clone_ptr(arg: bigint): bigint {
34577 if(!isWasmInitialized) {
34578 throw new Error("initializeWasm() must be awaited first!");
34580 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone_ptr(arg);
34581 return nativeResponseValue;
34583 // struct LDKSignedRawInvoice SignedRawInvoice_clone(const struct LDKSignedRawInvoice *NONNULL_PTR orig);
34585 export function SignedRawInvoice_clone(orig: bigint): bigint {
34586 if(!isWasmInitialized) {
34587 throw new Error("initializeWasm() must be awaited first!");
34589 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone(orig);
34590 return nativeResponseValue;
34592 // uint64_t SignedRawInvoice_hash(const struct LDKSignedRawInvoice *NONNULL_PTR o);
34594 export function SignedRawInvoice_hash(o: bigint): bigint {
34595 if(!isWasmInitialized) {
34596 throw new Error("initializeWasm() must be awaited first!");
34598 const nativeResponseValue = wasm.TS_SignedRawInvoice_hash(o);
34599 return nativeResponseValue;
34601 // void RawInvoice_free(struct LDKRawInvoice this_obj);
34603 export function RawInvoice_free(this_obj: bigint): void {
34604 if(!isWasmInitialized) {
34605 throw new Error("initializeWasm() must be awaited first!");
34607 const nativeResponseValue = wasm.TS_RawInvoice_free(this_obj);
34608 // debug statements here
34610 // struct LDKRawDataPart RawInvoice_get_data(const struct LDKRawInvoice *NONNULL_PTR this_ptr);
34612 export function RawInvoice_get_data(this_ptr: bigint): bigint {
34613 if(!isWasmInitialized) {
34614 throw new Error("initializeWasm() must be awaited first!");
34616 const nativeResponseValue = wasm.TS_RawInvoice_get_data(this_ptr);
34617 return nativeResponseValue;
34619 // void RawInvoice_set_data(struct LDKRawInvoice *NONNULL_PTR this_ptr, struct LDKRawDataPart val);
34621 export function RawInvoice_set_data(this_ptr: bigint, val: bigint): void {
34622 if(!isWasmInitialized) {
34623 throw new Error("initializeWasm() must be awaited first!");
34625 const nativeResponseValue = wasm.TS_RawInvoice_set_data(this_ptr, val);
34626 // debug statements here
34628 // bool RawInvoice_eq(const struct LDKRawInvoice *NONNULL_PTR a, const struct LDKRawInvoice *NONNULL_PTR b);
34630 export function RawInvoice_eq(a: bigint, b: bigint): boolean {
34631 if(!isWasmInitialized) {
34632 throw new Error("initializeWasm() must be awaited first!");
34634 const nativeResponseValue = wasm.TS_RawInvoice_eq(a, b);
34635 return nativeResponseValue;
34637 // uint64_t RawInvoice_clone_ptr(LDKRawInvoice *NONNULL_PTR arg);
34639 export function RawInvoice_clone_ptr(arg: bigint): bigint {
34640 if(!isWasmInitialized) {
34641 throw new Error("initializeWasm() must be awaited first!");
34643 const nativeResponseValue = wasm.TS_RawInvoice_clone_ptr(arg);
34644 return nativeResponseValue;
34646 // struct LDKRawInvoice RawInvoice_clone(const struct LDKRawInvoice *NONNULL_PTR orig);
34648 export function RawInvoice_clone(orig: bigint): bigint {
34649 if(!isWasmInitialized) {
34650 throw new Error("initializeWasm() must be awaited first!");
34652 const nativeResponseValue = wasm.TS_RawInvoice_clone(orig);
34653 return nativeResponseValue;
34655 // uint64_t RawInvoice_hash(const struct LDKRawInvoice *NONNULL_PTR o);
34657 export function RawInvoice_hash(o: bigint): bigint {
34658 if(!isWasmInitialized) {
34659 throw new Error("initializeWasm() must be awaited first!");
34661 const nativeResponseValue = wasm.TS_RawInvoice_hash(o);
34662 return nativeResponseValue;
34664 // void RawDataPart_free(struct LDKRawDataPart this_obj);
34666 export function RawDataPart_free(this_obj: bigint): void {
34667 if(!isWasmInitialized) {
34668 throw new Error("initializeWasm() must be awaited first!");
34670 const nativeResponseValue = wasm.TS_RawDataPart_free(this_obj);
34671 // debug statements here
34673 // struct LDKPositiveTimestamp RawDataPart_get_timestamp(const struct LDKRawDataPart *NONNULL_PTR this_ptr);
34675 export function RawDataPart_get_timestamp(this_ptr: bigint): bigint {
34676 if(!isWasmInitialized) {
34677 throw new Error("initializeWasm() must be awaited first!");
34679 const nativeResponseValue = wasm.TS_RawDataPart_get_timestamp(this_ptr);
34680 return nativeResponseValue;
34682 // void RawDataPart_set_timestamp(struct LDKRawDataPart *NONNULL_PTR this_ptr, struct LDKPositiveTimestamp val);
34684 export function RawDataPart_set_timestamp(this_ptr: bigint, val: bigint): void {
34685 if(!isWasmInitialized) {
34686 throw new Error("initializeWasm() must be awaited first!");
34688 const nativeResponseValue = wasm.TS_RawDataPart_set_timestamp(this_ptr, val);
34689 // debug statements here
34691 // bool RawDataPart_eq(const struct LDKRawDataPart *NONNULL_PTR a, const struct LDKRawDataPart *NONNULL_PTR b);
34693 export function RawDataPart_eq(a: bigint, b: bigint): boolean {
34694 if(!isWasmInitialized) {
34695 throw new Error("initializeWasm() must be awaited first!");
34697 const nativeResponseValue = wasm.TS_RawDataPart_eq(a, b);
34698 return nativeResponseValue;
34700 // uint64_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg);
34702 export function RawDataPart_clone_ptr(arg: bigint): bigint {
34703 if(!isWasmInitialized) {
34704 throw new Error("initializeWasm() must be awaited first!");
34706 const nativeResponseValue = wasm.TS_RawDataPart_clone_ptr(arg);
34707 return nativeResponseValue;
34709 // struct LDKRawDataPart RawDataPart_clone(const struct LDKRawDataPart *NONNULL_PTR orig);
34711 export function RawDataPart_clone(orig: bigint): bigint {
34712 if(!isWasmInitialized) {
34713 throw new Error("initializeWasm() must be awaited first!");
34715 const nativeResponseValue = wasm.TS_RawDataPart_clone(orig);
34716 return nativeResponseValue;
34718 // uint64_t RawDataPart_hash(const struct LDKRawDataPart *NONNULL_PTR o);
34720 export function RawDataPart_hash(o: bigint): bigint {
34721 if(!isWasmInitialized) {
34722 throw new Error("initializeWasm() must be awaited first!");
34724 const nativeResponseValue = wasm.TS_RawDataPart_hash(o);
34725 return nativeResponseValue;
34727 // void PositiveTimestamp_free(struct LDKPositiveTimestamp this_obj);
34729 export function PositiveTimestamp_free(this_obj: bigint): void {
34730 if(!isWasmInitialized) {
34731 throw new Error("initializeWasm() must be awaited first!");
34733 const nativeResponseValue = wasm.TS_PositiveTimestamp_free(this_obj);
34734 // debug statements here
34736 // bool PositiveTimestamp_eq(const struct LDKPositiveTimestamp *NONNULL_PTR a, const struct LDKPositiveTimestamp *NONNULL_PTR b);
34738 export function PositiveTimestamp_eq(a: bigint, b: bigint): boolean {
34739 if(!isWasmInitialized) {
34740 throw new Error("initializeWasm() must be awaited first!");
34742 const nativeResponseValue = wasm.TS_PositiveTimestamp_eq(a, b);
34743 return nativeResponseValue;
34745 // uint64_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg);
34747 export function PositiveTimestamp_clone_ptr(arg: bigint): bigint {
34748 if(!isWasmInitialized) {
34749 throw new Error("initializeWasm() must be awaited first!");
34751 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone_ptr(arg);
34752 return nativeResponseValue;
34754 // struct LDKPositiveTimestamp PositiveTimestamp_clone(const struct LDKPositiveTimestamp *NONNULL_PTR orig);
34756 export function PositiveTimestamp_clone(orig: bigint): bigint {
34757 if(!isWasmInitialized) {
34758 throw new Error("initializeWasm() must be awaited first!");
34760 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone(orig);
34761 return nativeResponseValue;
34763 // uint64_t PositiveTimestamp_hash(const struct LDKPositiveTimestamp *NONNULL_PTR o);
34765 export function PositiveTimestamp_hash(o: bigint): bigint {
34766 if(!isWasmInitialized) {
34767 throw new Error("initializeWasm() must be awaited first!");
34769 const nativeResponseValue = wasm.TS_PositiveTimestamp_hash(o);
34770 return nativeResponseValue;
34772 // enum LDKSiPrefix SiPrefix_clone(const enum LDKSiPrefix *NONNULL_PTR orig);
34774 export function SiPrefix_clone(orig: bigint): SiPrefix {
34775 if(!isWasmInitialized) {
34776 throw new Error("initializeWasm() must be awaited first!");
34778 const nativeResponseValue = wasm.TS_SiPrefix_clone(orig);
34779 return nativeResponseValue;
34781 // enum LDKSiPrefix SiPrefix_milli(void);
34783 export function SiPrefix_milli(): SiPrefix {
34784 if(!isWasmInitialized) {
34785 throw new Error("initializeWasm() must be awaited first!");
34787 const nativeResponseValue = wasm.TS_SiPrefix_milli();
34788 return nativeResponseValue;
34790 // enum LDKSiPrefix SiPrefix_micro(void);
34792 export function SiPrefix_micro(): SiPrefix {
34793 if(!isWasmInitialized) {
34794 throw new Error("initializeWasm() must be awaited first!");
34796 const nativeResponseValue = wasm.TS_SiPrefix_micro();
34797 return nativeResponseValue;
34799 // enum LDKSiPrefix SiPrefix_nano(void);
34801 export function SiPrefix_nano(): SiPrefix {
34802 if(!isWasmInitialized) {
34803 throw new Error("initializeWasm() must be awaited first!");
34805 const nativeResponseValue = wasm.TS_SiPrefix_nano();
34806 return nativeResponseValue;
34808 // enum LDKSiPrefix SiPrefix_pico(void);
34810 export function SiPrefix_pico(): SiPrefix {
34811 if(!isWasmInitialized) {
34812 throw new Error("initializeWasm() must be awaited first!");
34814 const nativeResponseValue = wasm.TS_SiPrefix_pico();
34815 return nativeResponseValue;
34817 // bool SiPrefix_eq(const enum LDKSiPrefix *NONNULL_PTR a, const enum LDKSiPrefix *NONNULL_PTR b);
34819 export function SiPrefix_eq(a: bigint, b: bigint): boolean {
34820 if(!isWasmInitialized) {
34821 throw new Error("initializeWasm() must be awaited first!");
34823 const nativeResponseValue = wasm.TS_SiPrefix_eq(a, b);
34824 return nativeResponseValue;
34826 // uint64_t SiPrefix_hash(const enum LDKSiPrefix *NONNULL_PTR o);
34828 export function SiPrefix_hash(o: bigint): bigint {
34829 if(!isWasmInitialized) {
34830 throw new Error("initializeWasm() must be awaited first!");
34832 const nativeResponseValue = wasm.TS_SiPrefix_hash(o);
34833 return nativeResponseValue;
34835 // MUST_USE_RES uint64_t SiPrefix_multiplier(const enum LDKSiPrefix *NONNULL_PTR this_arg);
34837 export function SiPrefix_multiplier(this_arg: bigint): bigint {
34838 if(!isWasmInitialized) {
34839 throw new Error("initializeWasm() must be awaited first!");
34841 const nativeResponseValue = wasm.TS_SiPrefix_multiplier(this_arg);
34842 return nativeResponseValue;
34844 // enum LDKCurrency Currency_clone(const enum LDKCurrency *NONNULL_PTR orig);
34846 export function Currency_clone(orig: bigint): Currency {
34847 if(!isWasmInitialized) {
34848 throw new Error("initializeWasm() must be awaited first!");
34850 const nativeResponseValue = wasm.TS_Currency_clone(orig);
34851 return nativeResponseValue;
34853 // enum LDKCurrency Currency_bitcoin(void);
34855 export function Currency_bitcoin(): Currency {
34856 if(!isWasmInitialized) {
34857 throw new Error("initializeWasm() must be awaited first!");
34859 const nativeResponseValue = wasm.TS_Currency_bitcoin();
34860 return nativeResponseValue;
34862 // enum LDKCurrency Currency_bitcoin_testnet(void);
34864 export function Currency_bitcoin_testnet(): Currency {
34865 if(!isWasmInitialized) {
34866 throw new Error("initializeWasm() must be awaited first!");
34868 const nativeResponseValue = wasm.TS_Currency_bitcoin_testnet();
34869 return nativeResponseValue;
34871 // enum LDKCurrency Currency_regtest(void);
34873 export function Currency_regtest(): Currency {
34874 if(!isWasmInitialized) {
34875 throw new Error("initializeWasm() must be awaited first!");
34877 const nativeResponseValue = wasm.TS_Currency_regtest();
34878 return nativeResponseValue;
34880 // enum LDKCurrency Currency_simnet(void);
34882 export function Currency_simnet(): Currency {
34883 if(!isWasmInitialized) {
34884 throw new Error("initializeWasm() must be awaited first!");
34886 const nativeResponseValue = wasm.TS_Currency_simnet();
34887 return nativeResponseValue;
34889 // enum LDKCurrency Currency_signet(void);
34891 export function Currency_signet(): Currency {
34892 if(!isWasmInitialized) {
34893 throw new Error("initializeWasm() must be awaited first!");
34895 const nativeResponseValue = wasm.TS_Currency_signet();
34896 return nativeResponseValue;
34898 // uint64_t Currency_hash(const enum LDKCurrency *NONNULL_PTR o);
34900 export function Currency_hash(o: bigint): bigint {
34901 if(!isWasmInitialized) {
34902 throw new Error("initializeWasm() must be awaited first!");
34904 const nativeResponseValue = wasm.TS_Currency_hash(o);
34905 return nativeResponseValue;
34907 // bool Currency_eq(const enum LDKCurrency *NONNULL_PTR a, const enum LDKCurrency *NONNULL_PTR b);
34909 export function Currency_eq(a: bigint, b: bigint): boolean {
34910 if(!isWasmInitialized) {
34911 throw new Error("initializeWasm() must be awaited first!");
34913 const nativeResponseValue = wasm.TS_Currency_eq(a, b);
34914 return nativeResponseValue;
34916 // void Sha256_free(struct LDKSha256 this_obj);
34918 export function Sha256_free(this_obj: bigint): void {
34919 if(!isWasmInitialized) {
34920 throw new Error("initializeWasm() must be awaited first!");
34922 const nativeResponseValue = wasm.TS_Sha256_free(this_obj);
34923 // debug statements here
34925 // uint64_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg);
34927 export function Sha256_clone_ptr(arg: bigint): bigint {
34928 if(!isWasmInitialized) {
34929 throw new Error("initializeWasm() must be awaited first!");
34931 const nativeResponseValue = wasm.TS_Sha256_clone_ptr(arg);
34932 return nativeResponseValue;
34934 // struct LDKSha256 Sha256_clone(const struct LDKSha256 *NONNULL_PTR orig);
34936 export function Sha256_clone(orig: bigint): bigint {
34937 if(!isWasmInitialized) {
34938 throw new Error("initializeWasm() must be awaited first!");
34940 const nativeResponseValue = wasm.TS_Sha256_clone(orig);
34941 return nativeResponseValue;
34943 // uint64_t Sha256_hash(const struct LDKSha256 *NONNULL_PTR o);
34945 export function Sha256_hash(o: bigint): bigint {
34946 if(!isWasmInitialized) {
34947 throw new Error("initializeWasm() must be awaited first!");
34949 const nativeResponseValue = wasm.TS_Sha256_hash(o);
34950 return nativeResponseValue;
34952 // bool Sha256_eq(const struct LDKSha256 *NONNULL_PTR a, const struct LDKSha256 *NONNULL_PTR b);
34954 export function Sha256_eq(a: bigint, b: bigint): boolean {
34955 if(!isWasmInitialized) {
34956 throw new Error("initializeWasm() must be awaited first!");
34958 const nativeResponseValue = wasm.TS_Sha256_eq(a, b);
34959 return nativeResponseValue;
34961 // void Description_free(struct LDKDescription this_obj);
34963 export function Description_free(this_obj: bigint): void {
34964 if(!isWasmInitialized) {
34965 throw new Error("initializeWasm() must be awaited first!");
34967 const nativeResponseValue = wasm.TS_Description_free(this_obj);
34968 // debug statements here
34970 // uint64_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg);
34972 export function Description_clone_ptr(arg: bigint): bigint {
34973 if(!isWasmInitialized) {
34974 throw new Error("initializeWasm() must be awaited first!");
34976 const nativeResponseValue = wasm.TS_Description_clone_ptr(arg);
34977 return nativeResponseValue;
34979 // struct LDKDescription Description_clone(const struct LDKDescription *NONNULL_PTR orig);
34981 export function Description_clone(orig: bigint): bigint {
34982 if(!isWasmInitialized) {
34983 throw new Error("initializeWasm() must be awaited first!");
34985 const nativeResponseValue = wasm.TS_Description_clone(orig);
34986 return nativeResponseValue;
34988 // uint64_t Description_hash(const struct LDKDescription *NONNULL_PTR o);
34990 export function Description_hash(o: bigint): bigint {
34991 if(!isWasmInitialized) {
34992 throw new Error("initializeWasm() must be awaited first!");
34994 const nativeResponseValue = wasm.TS_Description_hash(o);
34995 return nativeResponseValue;
34997 // bool Description_eq(const struct LDKDescription *NONNULL_PTR a, const struct LDKDescription *NONNULL_PTR b);
34999 export function Description_eq(a: bigint, b: bigint): boolean {
35000 if(!isWasmInitialized) {
35001 throw new Error("initializeWasm() must be awaited first!");
35003 const nativeResponseValue = wasm.TS_Description_eq(a, b);
35004 return nativeResponseValue;
35006 // void PayeePubKey_free(struct LDKPayeePubKey this_obj);
35008 export function PayeePubKey_free(this_obj: bigint): void {
35009 if(!isWasmInitialized) {
35010 throw new Error("initializeWasm() must be awaited first!");
35012 const nativeResponseValue = wasm.TS_PayeePubKey_free(this_obj);
35013 // debug statements here
35015 // struct LDKPublicKey PayeePubKey_get_a(const struct LDKPayeePubKey *NONNULL_PTR this_ptr);
35017 export function PayeePubKey_get_a(this_ptr: bigint): number {
35018 if(!isWasmInitialized) {
35019 throw new Error("initializeWasm() must be awaited first!");
35021 const nativeResponseValue = wasm.TS_PayeePubKey_get_a(this_ptr);
35022 return nativeResponseValue;
35024 // void PayeePubKey_set_a(struct LDKPayeePubKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
35026 export function PayeePubKey_set_a(this_ptr: bigint, val: number): void {
35027 if(!isWasmInitialized) {
35028 throw new Error("initializeWasm() must be awaited first!");
35030 const nativeResponseValue = wasm.TS_PayeePubKey_set_a(this_ptr, val);
35031 // debug statements here
35033 // MUST_USE_RES struct LDKPayeePubKey PayeePubKey_new(struct LDKPublicKey a_arg);
35035 export function PayeePubKey_new(a_arg: number): bigint {
35036 if(!isWasmInitialized) {
35037 throw new Error("initializeWasm() must be awaited first!");
35039 const nativeResponseValue = wasm.TS_PayeePubKey_new(a_arg);
35040 return nativeResponseValue;
35042 // uint64_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg);
35044 export function PayeePubKey_clone_ptr(arg: bigint): bigint {
35045 if(!isWasmInitialized) {
35046 throw new Error("initializeWasm() must be awaited first!");
35048 const nativeResponseValue = wasm.TS_PayeePubKey_clone_ptr(arg);
35049 return nativeResponseValue;
35051 // struct LDKPayeePubKey PayeePubKey_clone(const struct LDKPayeePubKey *NONNULL_PTR orig);
35053 export function PayeePubKey_clone(orig: bigint): bigint {
35054 if(!isWasmInitialized) {
35055 throw new Error("initializeWasm() must be awaited first!");
35057 const nativeResponseValue = wasm.TS_PayeePubKey_clone(orig);
35058 return nativeResponseValue;
35060 // uint64_t PayeePubKey_hash(const struct LDKPayeePubKey *NONNULL_PTR o);
35062 export function PayeePubKey_hash(o: bigint): bigint {
35063 if(!isWasmInitialized) {
35064 throw new Error("initializeWasm() must be awaited first!");
35066 const nativeResponseValue = wasm.TS_PayeePubKey_hash(o);
35067 return nativeResponseValue;
35069 // bool PayeePubKey_eq(const struct LDKPayeePubKey *NONNULL_PTR a, const struct LDKPayeePubKey *NONNULL_PTR b);
35071 export function PayeePubKey_eq(a: bigint, b: bigint): boolean {
35072 if(!isWasmInitialized) {
35073 throw new Error("initializeWasm() must be awaited first!");
35075 const nativeResponseValue = wasm.TS_PayeePubKey_eq(a, b);
35076 return nativeResponseValue;
35078 // void ExpiryTime_free(struct LDKExpiryTime this_obj);
35080 export function ExpiryTime_free(this_obj: bigint): void {
35081 if(!isWasmInitialized) {
35082 throw new Error("initializeWasm() must be awaited first!");
35084 const nativeResponseValue = wasm.TS_ExpiryTime_free(this_obj);
35085 // debug statements here
35087 // uint64_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg);
35089 export function ExpiryTime_clone_ptr(arg: bigint): bigint {
35090 if(!isWasmInitialized) {
35091 throw new Error("initializeWasm() must be awaited first!");
35093 const nativeResponseValue = wasm.TS_ExpiryTime_clone_ptr(arg);
35094 return nativeResponseValue;
35096 // struct LDKExpiryTime ExpiryTime_clone(const struct LDKExpiryTime *NONNULL_PTR orig);
35098 export function ExpiryTime_clone(orig: bigint): bigint {
35099 if(!isWasmInitialized) {
35100 throw new Error("initializeWasm() must be awaited first!");
35102 const nativeResponseValue = wasm.TS_ExpiryTime_clone(orig);
35103 return nativeResponseValue;
35105 // uint64_t ExpiryTime_hash(const struct LDKExpiryTime *NONNULL_PTR o);
35107 export function ExpiryTime_hash(o: bigint): bigint {
35108 if(!isWasmInitialized) {
35109 throw new Error("initializeWasm() must be awaited first!");
35111 const nativeResponseValue = wasm.TS_ExpiryTime_hash(o);
35112 return nativeResponseValue;
35114 // bool ExpiryTime_eq(const struct LDKExpiryTime *NONNULL_PTR a, const struct LDKExpiryTime *NONNULL_PTR b);
35116 export function ExpiryTime_eq(a: bigint, b: bigint): boolean {
35117 if(!isWasmInitialized) {
35118 throw new Error("initializeWasm() must be awaited first!");
35120 const nativeResponseValue = wasm.TS_ExpiryTime_eq(a, b);
35121 return nativeResponseValue;
35123 // void MinFinalCltvExpiry_free(struct LDKMinFinalCltvExpiry this_obj);
35125 export function MinFinalCltvExpiry_free(this_obj: bigint): void {
35126 if(!isWasmInitialized) {
35127 throw new Error("initializeWasm() must be awaited first!");
35129 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_free(this_obj);
35130 // debug statements here
35132 // uint64_t MinFinalCltvExpiry_get_a(const struct LDKMinFinalCltvExpiry *NONNULL_PTR this_ptr);
35134 export function MinFinalCltvExpiry_get_a(this_ptr: bigint): bigint {
35135 if(!isWasmInitialized) {
35136 throw new Error("initializeWasm() must be awaited first!");
35138 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_get_a(this_ptr);
35139 return nativeResponseValue;
35141 // void MinFinalCltvExpiry_set_a(struct LDKMinFinalCltvExpiry *NONNULL_PTR this_ptr, uint64_t val);
35143 export function MinFinalCltvExpiry_set_a(this_ptr: bigint, val: bigint): void {
35144 if(!isWasmInitialized) {
35145 throw new Error("initializeWasm() must be awaited first!");
35147 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_set_a(this_ptr, val);
35148 // debug statements here
35150 // MUST_USE_RES struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_new(uint64_t a_arg);
35152 export function MinFinalCltvExpiry_new(a_arg: bigint): bigint {
35153 if(!isWasmInitialized) {
35154 throw new Error("initializeWasm() must be awaited first!");
35156 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_new(a_arg);
35157 return nativeResponseValue;
35159 // uint64_t MinFinalCltvExpiry_clone_ptr(LDKMinFinalCltvExpiry *NONNULL_PTR arg);
35161 export function MinFinalCltvExpiry_clone_ptr(arg: bigint): bigint {
35162 if(!isWasmInitialized) {
35163 throw new Error("initializeWasm() must be awaited first!");
35165 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_clone_ptr(arg);
35166 return nativeResponseValue;
35168 // struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_clone(const struct LDKMinFinalCltvExpiry *NONNULL_PTR orig);
35170 export function MinFinalCltvExpiry_clone(orig: bigint): bigint {
35171 if(!isWasmInitialized) {
35172 throw new Error("initializeWasm() must be awaited first!");
35174 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_clone(orig);
35175 return nativeResponseValue;
35177 // uint64_t MinFinalCltvExpiry_hash(const struct LDKMinFinalCltvExpiry *NONNULL_PTR o);
35179 export function MinFinalCltvExpiry_hash(o: bigint): bigint {
35180 if(!isWasmInitialized) {
35181 throw new Error("initializeWasm() must be awaited first!");
35183 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_hash(o);
35184 return nativeResponseValue;
35186 // bool MinFinalCltvExpiry_eq(const struct LDKMinFinalCltvExpiry *NONNULL_PTR a, const struct LDKMinFinalCltvExpiry *NONNULL_PTR b);
35188 export function MinFinalCltvExpiry_eq(a: bigint, b: bigint): boolean {
35189 if(!isWasmInitialized) {
35190 throw new Error("initializeWasm() must be awaited first!");
35192 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_eq(a, b);
35193 return nativeResponseValue;
35195 // void Fallback_free(struct LDKFallback this_ptr);
35197 export function Fallback_free(this_ptr: bigint): void {
35198 if(!isWasmInitialized) {
35199 throw new Error("initializeWasm() must be awaited first!");
35201 const nativeResponseValue = wasm.TS_Fallback_free(this_ptr);
35202 // debug statements here
35204 // uint64_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg);
35206 export function Fallback_clone_ptr(arg: bigint): bigint {
35207 if(!isWasmInitialized) {
35208 throw new Error("initializeWasm() must be awaited first!");
35210 const nativeResponseValue = wasm.TS_Fallback_clone_ptr(arg);
35211 return nativeResponseValue;
35213 // struct LDKFallback Fallback_clone(const struct LDKFallback *NONNULL_PTR orig);
35215 export function Fallback_clone(orig: bigint): bigint {
35216 if(!isWasmInitialized) {
35217 throw new Error("initializeWasm() must be awaited first!");
35219 const nativeResponseValue = wasm.TS_Fallback_clone(orig);
35220 return nativeResponseValue;
35222 // struct LDKFallback Fallback_seg_wit_program(struct LDKu5 version, struct LDKCVec_u8Z program);
35224 export function Fallback_seg_wit_program(version: number, program: number): bigint {
35225 if(!isWasmInitialized) {
35226 throw new Error("initializeWasm() must be awaited first!");
35228 const nativeResponseValue = wasm.TS_Fallback_seg_wit_program(version, program);
35229 return nativeResponseValue;
35231 // struct LDKFallback Fallback_pub_key_hash(struct LDKTwentyBytes a);
35233 export function Fallback_pub_key_hash(a: number): bigint {
35234 if(!isWasmInitialized) {
35235 throw new Error("initializeWasm() must be awaited first!");
35237 const nativeResponseValue = wasm.TS_Fallback_pub_key_hash(a);
35238 return nativeResponseValue;
35240 // struct LDKFallback Fallback_script_hash(struct LDKTwentyBytes a);
35242 export function Fallback_script_hash(a: number): bigint {
35243 if(!isWasmInitialized) {
35244 throw new Error("initializeWasm() must be awaited first!");
35246 const nativeResponseValue = wasm.TS_Fallback_script_hash(a);
35247 return nativeResponseValue;
35249 // uint64_t Fallback_hash(const struct LDKFallback *NONNULL_PTR o);
35251 export function Fallback_hash(o: bigint): bigint {
35252 if(!isWasmInitialized) {
35253 throw new Error("initializeWasm() must be awaited first!");
35255 const nativeResponseValue = wasm.TS_Fallback_hash(o);
35256 return nativeResponseValue;
35258 // bool Fallback_eq(const struct LDKFallback *NONNULL_PTR a, const struct LDKFallback *NONNULL_PTR b);
35260 export function Fallback_eq(a: bigint, b: bigint): boolean {
35261 if(!isWasmInitialized) {
35262 throw new Error("initializeWasm() must be awaited first!");
35264 const nativeResponseValue = wasm.TS_Fallback_eq(a, b);
35265 return nativeResponseValue;
35267 // void InvoiceSignature_free(struct LDKInvoiceSignature this_obj);
35269 export function InvoiceSignature_free(this_obj: bigint): void {
35270 if(!isWasmInitialized) {
35271 throw new Error("initializeWasm() must be awaited first!");
35273 const nativeResponseValue = wasm.TS_InvoiceSignature_free(this_obj);
35274 // debug statements here
35276 // uint64_t InvoiceSignature_clone_ptr(LDKInvoiceSignature *NONNULL_PTR arg);
35278 export function InvoiceSignature_clone_ptr(arg: bigint): bigint {
35279 if(!isWasmInitialized) {
35280 throw new Error("initializeWasm() must be awaited first!");
35282 const nativeResponseValue = wasm.TS_InvoiceSignature_clone_ptr(arg);
35283 return nativeResponseValue;
35285 // struct LDKInvoiceSignature InvoiceSignature_clone(const struct LDKInvoiceSignature *NONNULL_PTR orig);
35287 export function InvoiceSignature_clone(orig: bigint): bigint {
35288 if(!isWasmInitialized) {
35289 throw new Error("initializeWasm() must be awaited first!");
35291 const nativeResponseValue = wasm.TS_InvoiceSignature_clone(orig);
35292 return nativeResponseValue;
35294 // uint64_t InvoiceSignature_hash(const struct LDKInvoiceSignature *NONNULL_PTR o);
35296 export function InvoiceSignature_hash(o: bigint): bigint {
35297 if(!isWasmInitialized) {
35298 throw new Error("initializeWasm() must be awaited first!");
35300 const nativeResponseValue = wasm.TS_InvoiceSignature_hash(o);
35301 return nativeResponseValue;
35303 // bool InvoiceSignature_eq(const struct LDKInvoiceSignature *NONNULL_PTR a, const struct LDKInvoiceSignature *NONNULL_PTR b);
35305 export function InvoiceSignature_eq(a: bigint, b: bigint): boolean {
35306 if(!isWasmInitialized) {
35307 throw new Error("initializeWasm() must be awaited first!");
35309 const nativeResponseValue = wasm.TS_InvoiceSignature_eq(a, b);
35310 return nativeResponseValue;
35312 // void PrivateRoute_free(struct LDKPrivateRoute this_obj);
35314 export function PrivateRoute_free(this_obj: bigint): void {
35315 if(!isWasmInitialized) {
35316 throw new Error("initializeWasm() must be awaited first!");
35318 const nativeResponseValue = wasm.TS_PrivateRoute_free(this_obj);
35319 // debug statements here
35321 // uint64_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg);
35323 export function PrivateRoute_clone_ptr(arg: bigint): bigint {
35324 if(!isWasmInitialized) {
35325 throw new Error("initializeWasm() must be awaited first!");
35327 const nativeResponseValue = wasm.TS_PrivateRoute_clone_ptr(arg);
35328 return nativeResponseValue;
35330 // struct LDKPrivateRoute PrivateRoute_clone(const struct LDKPrivateRoute *NONNULL_PTR orig);
35332 export function PrivateRoute_clone(orig: bigint): bigint {
35333 if(!isWasmInitialized) {
35334 throw new Error("initializeWasm() must be awaited first!");
35336 const nativeResponseValue = wasm.TS_PrivateRoute_clone(orig);
35337 return nativeResponseValue;
35339 // uint64_t PrivateRoute_hash(const struct LDKPrivateRoute *NONNULL_PTR o);
35341 export function PrivateRoute_hash(o: bigint): bigint {
35342 if(!isWasmInitialized) {
35343 throw new Error("initializeWasm() must be awaited first!");
35345 const nativeResponseValue = wasm.TS_PrivateRoute_hash(o);
35346 return nativeResponseValue;
35348 // bool PrivateRoute_eq(const struct LDKPrivateRoute *NONNULL_PTR a, const struct LDKPrivateRoute *NONNULL_PTR b);
35350 export function PrivateRoute_eq(a: bigint, b: bigint): boolean {
35351 if(!isWasmInitialized) {
35352 throw new Error("initializeWasm() must be awaited first!");
35354 const nativeResponseValue = wasm.TS_PrivateRoute_eq(a, b);
35355 return nativeResponseValue;
35357 // MUST_USE_RES struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ SignedRawInvoice_into_parts(struct LDKSignedRawInvoice this_arg);
35359 export function SignedRawInvoice_into_parts(this_arg: bigint): bigint {
35360 if(!isWasmInitialized) {
35361 throw new Error("initializeWasm() must be awaited first!");
35363 const nativeResponseValue = wasm.TS_SignedRawInvoice_into_parts(this_arg);
35364 return nativeResponseValue;
35366 // MUST_USE_RES struct LDKRawInvoice SignedRawInvoice_raw_invoice(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
35368 export function SignedRawInvoice_raw_invoice(this_arg: bigint): bigint {
35369 if(!isWasmInitialized) {
35370 throw new Error("initializeWasm() must be awaited first!");
35372 const nativeResponseValue = wasm.TS_SignedRawInvoice_raw_invoice(this_arg);
35373 return nativeResponseValue;
35375 // MUST_USE_RES const uint8_t (*SignedRawInvoice_signable_hash(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg))[32];
35377 export function SignedRawInvoice_signable_hash(this_arg: bigint): number {
35378 if(!isWasmInitialized) {
35379 throw new Error("initializeWasm() must be awaited first!");
35381 const nativeResponseValue = wasm.TS_SignedRawInvoice_signable_hash(this_arg);
35382 return nativeResponseValue;
35384 // MUST_USE_RES struct LDKInvoiceSignature SignedRawInvoice_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
35386 export function SignedRawInvoice_signature(this_arg: bigint): bigint {
35387 if(!isWasmInitialized) {
35388 throw new Error("initializeWasm() must be awaited first!");
35390 const nativeResponseValue = wasm.TS_SignedRawInvoice_signature(this_arg);
35391 return nativeResponseValue;
35393 // MUST_USE_RES struct LDKCResult_PayeePubKeyErrorZ SignedRawInvoice_recover_payee_pub_key(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
35395 export function SignedRawInvoice_recover_payee_pub_key(this_arg: bigint): bigint {
35396 if(!isWasmInitialized) {
35397 throw new Error("initializeWasm() must be awaited first!");
35399 const nativeResponseValue = wasm.TS_SignedRawInvoice_recover_payee_pub_key(this_arg);
35400 return nativeResponseValue;
35402 // MUST_USE_RES bool SignedRawInvoice_check_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
35404 export function SignedRawInvoice_check_signature(this_arg: bigint): boolean {
35405 if(!isWasmInitialized) {
35406 throw new Error("initializeWasm() must be awaited first!");
35408 const nativeResponseValue = wasm.TS_SignedRawInvoice_check_signature(this_arg);
35409 return nativeResponseValue;
35411 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_signable_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
35413 export function RawInvoice_signable_hash(this_arg: bigint): number {
35414 if(!isWasmInitialized) {
35415 throw new Error("initializeWasm() must be awaited first!");
35417 const nativeResponseValue = wasm.TS_RawInvoice_signable_hash(this_arg);
35418 return nativeResponseValue;
35420 // MUST_USE_RES struct LDKSha256 RawInvoice_payment_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
35422 export function RawInvoice_payment_hash(this_arg: bigint): bigint {
35423 if(!isWasmInitialized) {
35424 throw new Error("initializeWasm() must be awaited first!");
35426 const nativeResponseValue = wasm.TS_RawInvoice_payment_hash(this_arg);
35427 return nativeResponseValue;
35429 // MUST_USE_RES struct LDKDescription RawInvoice_description(const struct LDKRawInvoice *NONNULL_PTR this_arg);
35431 export function RawInvoice_description(this_arg: bigint): bigint {
35432 if(!isWasmInitialized) {
35433 throw new Error("initializeWasm() must be awaited first!");
35435 const nativeResponseValue = wasm.TS_RawInvoice_description(this_arg);
35436 return nativeResponseValue;
35438 // MUST_USE_RES struct LDKPayeePubKey RawInvoice_payee_pub_key(const struct LDKRawInvoice *NONNULL_PTR this_arg);
35440 export function RawInvoice_payee_pub_key(this_arg: bigint): bigint {
35441 if(!isWasmInitialized) {
35442 throw new Error("initializeWasm() must be awaited first!");
35444 const nativeResponseValue = wasm.TS_RawInvoice_payee_pub_key(this_arg);
35445 return nativeResponseValue;
35447 // MUST_USE_RES struct LDKSha256 RawInvoice_description_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
35449 export function RawInvoice_description_hash(this_arg: bigint): bigint {
35450 if(!isWasmInitialized) {
35451 throw new Error("initializeWasm() must be awaited first!");
35453 const nativeResponseValue = wasm.TS_RawInvoice_description_hash(this_arg);
35454 return nativeResponseValue;
35456 // MUST_USE_RES struct LDKExpiryTime RawInvoice_expiry_time(const struct LDKRawInvoice *NONNULL_PTR this_arg);
35458 export function RawInvoice_expiry_time(this_arg: bigint): bigint {
35459 if(!isWasmInitialized) {
35460 throw new Error("initializeWasm() must be awaited first!");
35462 const nativeResponseValue = wasm.TS_RawInvoice_expiry_time(this_arg);
35463 return nativeResponseValue;
35465 // MUST_USE_RES struct LDKMinFinalCltvExpiry RawInvoice_min_final_cltv_expiry(const struct LDKRawInvoice *NONNULL_PTR this_arg);
35467 export function RawInvoice_min_final_cltv_expiry(this_arg: bigint): bigint {
35468 if(!isWasmInitialized) {
35469 throw new Error("initializeWasm() must be awaited first!");
35471 const nativeResponseValue = wasm.TS_RawInvoice_min_final_cltv_expiry(this_arg);
35472 return nativeResponseValue;
35474 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_payment_secret(const struct LDKRawInvoice *NONNULL_PTR this_arg);
35476 export function RawInvoice_payment_secret(this_arg: bigint): number {
35477 if(!isWasmInitialized) {
35478 throw new Error("initializeWasm() must be awaited first!");
35480 const nativeResponseValue = wasm.TS_RawInvoice_payment_secret(this_arg);
35481 return nativeResponseValue;
35483 // MUST_USE_RES struct LDKInvoiceFeatures RawInvoice_features(const struct LDKRawInvoice *NONNULL_PTR this_arg);
35485 export function RawInvoice_features(this_arg: bigint): bigint {
35486 if(!isWasmInitialized) {
35487 throw new Error("initializeWasm() must be awaited first!");
35489 const nativeResponseValue = wasm.TS_RawInvoice_features(this_arg);
35490 return nativeResponseValue;
35492 // MUST_USE_RES struct LDKCVec_PrivateRouteZ RawInvoice_private_routes(const struct LDKRawInvoice *NONNULL_PTR this_arg);
35494 export function RawInvoice_private_routes(this_arg: bigint): number {
35495 if(!isWasmInitialized) {
35496 throw new Error("initializeWasm() must be awaited first!");
35498 const nativeResponseValue = wasm.TS_RawInvoice_private_routes(this_arg);
35499 return nativeResponseValue;
35501 // MUST_USE_RES struct LDKCOption_u64Z RawInvoice_amount_pico_btc(const struct LDKRawInvoice *NONNULL_PTR this_arg);
35503 export function RawInvoice_amount_pico_btc(this_arg: bigint): bigint {
35504 if(!isWasmInitialized) {
35505 throw new Error("initializeWasm() must be awaited first!");
35507 const nativeResponseValue = wasm.TS_RawInvoice_amount_pico_btc(this_arg);
35508 return nativeResponseValue;
35510 // MUST_USE_RES enum LDKCurrency RawInvoice_currency(const struct LDKRawInvoice *NONNULL_PTR this_arg);
35512 export function RawInvoice_currency(this_arg: bigint): Currency {
35513 if(!isWasmInitialized) {
35514 throw new Error("initializeWasm() must be awaited first!");
35516 const nativeResponseValue = wasm.TS_RawInvoice_currency(this_arg);
35517 return nativeResponseValue;
35519 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_unix_timestamp(uint64_t unix_seconds);
35521 export function PositiveTimestamp_from_unix_timestamp(unix_seconds: bigint): bigint {
35522 if(!isWasmInitialized) {
35523 throw new Error("initializeWasm() must be awaited first!");
35525 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_unix_timestamp(unix_seconds);
35526 return nativeResponseValue;
35528 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_duration_since_epoch(uint64_t duration);
35530 export function PositiveTimestamp_from_duration_since_epoch(duration: bigint): bigint {
35531 if(!isWasmInitialized) {
35532 throw new Error("initializeWasm() must be awaited first!");
35534 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_duration_since_epoch(duration);
35535 return nativeResponseValue;
35537 // MUST_USE_RES uint64_t PositiveTimestamp_as_unix_timestamp(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
35539 export function PositiveTimestamp_as_unix_timestamp(this_arg: bigint): bigint {
35540 if(!isWasmInitialized) {
35541 throw new Error("initializeWasm() must be awaited first!");
35543 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_unix_timestamp(this_arg);
35544 return nativeResponseValue;
35546 // MUST_USE_RES uint64_t PositiveTimestamp_as_duration_since_epoch(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
35548 export function PositiveTimestamp_as_duration_since_epoch(this_arg: bigint): bigint {
35549 if(!isWasmInitialized) {
35550 throw new Error("initializeWasm() must be awaited first!");
35552 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_duration_since_epoch(this_arg);
35553 return nativeResponseValue;
35555 // MUST_USE_RES struct LDKSignedRawInvoice Invoice_into_signed_raw(struct LDKInvoice this_arg);
35557 export function Invoice_into_signed_raw(this_arg: bigint): bigint {
35558 if(!isWasmInitialized) {
35559 throw new Error("initializeWasm() must be awaited first!");
35561 const nativeResponseValue = wasm.TS_Invoice_into_signed_raw(this_arg);
35562 return nativeResponseValue;
35564 // MUST_USE_RES struct LDKCResult_NoneSemanticErrorZ Invoice_check_signature(const struct LDKInvoice *NONNULL_PTR this_arg);
35566 export function Invoice_check_signature(this_arg: bigint): bigint {
35567 if(!isWasmInitialized) {
35568 throw new Error("initializeWasm() must be awaited first!");
35570 const nativeResponseValue = wasm.TS_Invoice_check_signature(this_arg);
35571 return nativeResponseValue;
35573 // MUST_USE_RES struct LDKCResult_InvoiceSemanticErrorZ Invoice_from_signed(struct LDKSignedRawInvoice signed_invoice);
35575 export function Invoice_from_signed(signed_invoice: bigint): bigint {
35576 if(!isWasmInitialized) {
35577 throw new Error("initializeWasm() must be awaited first!");
35579 const nativeResponseValue = wasm.TS_Invoice_from_signed(signed_invoice);
35580 return nativeResponseValue;
35582 // MUST_USE_RES uint64_t Invoice_duration_since_epoch(const struct LDKInvoice *NONNULL_PTR this_arg);
35584 export function Invoice_duration_since_epoch(this_arg: bigint): bigint {
35585 if(!isWasmInitialized) {
35586 throw new Error("initializeWasm() must be awaited first!");
35588 const nativeResponseValue = wasm.TS_Invoice_duration_since_epoch(this_arg);
35589 return nativeResponseValue;
35591 // MUST_USE_RES const uint8_t (*Invoice_payment_hash(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
35593 export function Invoice_payment_hash(this_arg: bigint): number {
35594 if(!isWasmInitialized) {
35595 throw new Error("initializeWasm() must be awaited first!");
35597 const nativeResponseValue = wasm.TS_Invoice_payment_hash(this_arg);
35598 return nativeResponseValue;
35600 // MUST_USE_RES struct LDKPublicKey Invoice_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
35602 export function Invoice_payee_pub_key(this_arg: bigint): number {
35603 if(!isWasmInitialized) {
35604 throw new Error("initializeWasm() must be awaited first!");
35606 const nativeResponseValue = wasm.TS_Invoice_payee_pub_key(this_arg);
35607 return nativeResponseValue;
35609 // MUST_USE_RES const uint8_t (*Invoice_payment_secret(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
35611 export function Invoice_payment_secret(this_arg: bigint): number {
35612 if(!isWasmInitialized) {
35613 throw new Error("initializeWasm() must be awaited first!");
35615 const nativeResponseValue = wasm.TS_Invoice_payment_secret(this_arg);
35616 return nativeResponseValue;
35618 // MUST_USE_RES struct LDKInvoiceFeatures Invoice_features(const struct LDKInvoice *NONNULL_PTR this_arg);
35620 export function Invoice_features(this_arg: bigint): bigint {
35621 if(!isWasmInitialized) {
35622 throw new Error("initializeWasm() must be awaited first!");
35624 const nativeResponseValue = wasm.TS_Invoice_features(this_arg);
35625 return nativeResponseValue;
35627 // MUST_USE_RES struct LDKPublicKey Invoice_recover_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
35629 export function Invoice_recover_payee_pub_key(this_arg: bigint): number {
35630 if(!isWasmInitialized) {
35631 throw new Error("initializeWasm() must be awaited first!");
35633 const nativeResponseValue = wasm.TS_Invoice_recover_payee_pub_key(this_arg);
35634 return nativeResponseValue;
35636 // MUST_USE_RES uint64_t Invoice_expiry_time(const struct LDKInvoice *NONNULL_PTR this_arg);
35638 export function Invoice_expiry_time(this_arg: bigint): bigint {
35639 if(!isWasmInitialized) {
35640 throw new Error("initializeWasm() must be awaited first!");
35642 const nativeResponseValue = wasm.TS_Invoice_expiry_time(this_arg);
35643 return nativeResponseValue;
35645 // MUST_USE_RES bool Invoice_would_expire(const struct LDKInvoice *NONNULL_PTR this_arg, uint64_t at_time);
35647 export function Invoice_would_expire(this_arg: bigint, at_time: bigint): boolean {
35648 if(!isWasmInitialized) {
35649 throw new Error("initializeWasm() must be awaited first!");
35651 const nativeResponseValue = wasm.TS_Invoice_would_expire(this_arg, at_time);
35652 return nativeResponseValue;
35654 // MUST_USE_RES uint64_t Invoice_min_final_cltv_expiry(const struct LDKInvoice *NONNULL_PTR this_arg);
35656 export function Invoice_min_final_cltv_expiry(this_arg: bigint): bigint {
35657 if(!isWasmInitialized) {
35658 throw new Error("initializeWasm() must be awaited first!");
35660 const nativeResponseValue = wasm.TS_Invoice_min_final_cltv_expiry(this_arg);
35661 return nativeResponseValue;
35663 // MUST_USE_RES struct LDKCVec_PrivateRouteZ Invoice_private_routes(const struct LDKInvoice *NONNULL_PTR this_arg);
35665 export function Invoice_private_routes(this_arg: bigint): number {
35666 if(!isWasmInitialized) {
35667 throw new Error("initializeWasm() must be awaited first!");
35669 const nativeResponseValue = wasm.TS_Invoice_private_routes(this_arg);
35670 return nativeResponseValue;
35672 // MUST_USE_RES struct LDKCVec_RouteHintZ Invoice_route_hints(const struct LDKInvoice *NONNULL_PTR this_arg);
35674 export function Invoice_route_hints(this_arg: bigint): number {
35675 if(!isWasmInitialized) {
35676 throw new Error("initializeWasm() must be awaited first!");
35678 const nativeResponseValue = wasm.TS_Invoice_route_hints(this_arg);
35679 return nativeResponseValue;
35681 // MUST_USE_RES enum LDKCurrency Invoice_currency(const struct LDKInvoice *NONNULL_PTR this_arg);
35683 export function Invoice_currency(this_arg: bigint): Currency {
35684 if(!isWasmInitialized) {
35685 throw new Error("initializeWasm() must be awaited first!");
35687 const nativeResponseValue = wasm.TS_Invoice_currency(this_arg);
35688 return nativeResponseValue;
35690 // MUST_USE_RES struct LDKCOption_u64Z Invoice_amount_milli_satoshis(const struct LDKInvoice *NONNULL_PTR this_arg);
35692 export function Invoice_amount_milli_satoshis(this_arg: bigint): bigint {
35693 if(!isWasmInitialized) {
35694 throw new Error("initializeWasm() must be awaited first!");
35696 const nativeResponseValue = wasm.TS_Invoice_amount_milli_satoshis(this_arg);
35697 return nativeResponseValue;
35699 // MUST_USE_RES struct LDKCResult_DescriptionCreationErrorZ Description_new(struct LDKStr description);
35701 export function Description_new(description: number): bigint {
35702 if(!isWasmInitialized) {
35703 throw new Error("initializeWasm() must be awaited first!");
35705 const nativeResponseValue = wasm.TS_Description_new(description);
35706 return nativeResponseValue;
35708 // MUST_USE_RES struct LDKStr Description_into_inner(struct LDKDescription this_arg);
35710 export function Description_into_inner(this_arg: bigint): number {
35711 if(!isWasmInitialized) {
35712 throw new Error("initializeWasm() must be awaited first!");
35714 const nativeResponseValue = wasm.TS_Description_into_inner(this_arg);
35715 return nativeResponseValue;
35717 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_seconds(uint64_t seconds);
35719 export function ExpiryTime_from_seconds(seconds: bigint): bigint {
35720 if(!isWasmInitialized) {
35721 throw new Error("initializeWasm() must be awaited first!");
35723 const nativeResponseValue = wasm.TS_ExpiryTime_from_seconds(seconds);
35724 return nativeResponseValue;
35726 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_duration(uint64_t duration);
35728 export function ExpiryTime_from_duration(duration: bigint): bigint {
35729 if(!isWasmInitialized) {
35730 throw new Error("initializeWasm() must be awaited first!");
35732 const nativeResponseValue = wasm.TS_ExpiryTime_from_duration(duration);
35733 return nativeResponseValue;
35735 // MUST_USE_RES uint64_t ExpiryTime_as_seconds(const struct LDKExpiryTime *NONNULL_PTR this_arg);
35737 export function ExpiryTime_as_seconds(this_arg: bigint): bigint {
35738 if(!isWasmInitialized) {
35739 throw new Error("initializeWasm() must be awaited first!");
35741 const nativeResponseValue = wasm.TS_ExpiryTime_as_seconds(this_arg);
35742 return nativeResponseValue;
35744 // MUST_USE_RES uint64_t ExpiryTime_as_duration(const struct LDKExpiryTime *NONNULL_PTR this_arg);
35746 export function ExpiryTime_as_duration(this_arg: bigint): bigint {
35747 if(!isWasmInitialized) {
35748 throw new Error("initializeWasm() must be awaited first!");
35750 const nativeResponseValue = wasm.TS_ExpiryTime_as_duration(this_arg);
35751 return nativeResponseValue;
35753 // MUST_USE_RES struct LDKCResult_PrivateRouteCreationErrorZ PrivateRoute_new(struct LDKRouteHint hops);
35755 export function PrivateRoute_new(hops: bigint): bigint {
35756 if(!isWasmInitialized) {
35757 throw new Error("initializeWasm() must be awaited first!");
35759 const nativeResponseValue = wasm.TS_PrivateRoute_new(hops);
35760 return nativeResponseValue;
35762 // MUST_USE_RES struct LDKRouteHint PrivateRoute_into_inner(struct LDKPrivateRoute this_arg);
35764 export function PrivateRoute_into_inner(this_arg: bigint): bigint {
35765 if(!isWasmInitialized) {
35766 throw new Error("initializeWasm() must be awaited first!");
35768 const nativeResponseValue = wasm.TS_PrivateRoute_into_inner(this_arg);
35769 return nativeResponseValue;
35771 // enum LDKCreationError CreationError_clone(const enum LDKCreationError *NONNULL_PTR orig);
35773 export function CreationError_clone(orig: bigint): CreationError {
35774 if(!isWasmInitialized) {
35775 throw new Error("initializeWasm() must be awaited first!");
35777 const nativeResponseValue = wasm.TS_CreationError_clone(orig);
35778 return nativeResponseValue;
35780 // enum LDKCreationError CreationError_description_too_long(void);
35782 export function CreationError_description_too_long(): CreationError {
35783 if(!isWasmInitialized) {
35784 throw new Error("initializeWasm() must be awaited first!");
35786 const nativeResponseValue = wasm.TS_CreationError_description_too_long();
35787 return nativeResponseValue;
35789 // enum LDKCreationError CreationError_route_too_long(void);
35791 export function CreationError_route_too_long(): CreationError {
35792 if(!isWasmInitialized) {
35793 throw new Error("initializeWasm() must be awaited first!");
35795 const nativeResponseValue = wasm.TS_CreationError_route_too_long();
35796 return nativeResponseValue;
35798 // enum LDKCreationError CreationError_timestamp_out_of_bounds(void);
35800 export function CreationError_timestamp_out_of_bounds(): CreationError {
35801 if(!isWasmInitialized) {
35802 throw new Error("initializeWasm() must be awaited first!");
35804 const nativeResponseValue = wasm.TS_CreationError_timestamp_out_of_bounds();
35805 return nativeResponseValue;
35807 // enum LDKCreationError CreationError_invalid_amount(void);
35809 export function CreationError_invalid_amount(): CreationError {
35810 if(!isWasmInitialized) {
35811 throw new Error("initializeWasm() must be awaited first!");
35813 const nativeResponseValue = wasm.TS_CreationError_invalid_amount();
35814 return nativeResponseValue;
35816 // enum LDKCreationError CreationError_missing_route_hints(void);
35818 export function CreationError_missing_route_hints(): CreationError {
35819 if(!isWasmInitialized) {
35820 throw new Error("initializeWasm() must be awaited first!");
35822 const nativeResponseValue = wasm.TS_CreationError_missing_route_hints();
35823 return nativeResponseValue;
35825 // bool CreationError_eq(const enum LDKCreationError *NONNULL_PTR a, const enum LDKCreationError *NONNULL_PTR b);
35827 export function CreationError_eq(a: bigint, b: bigint): boolean {
35828 if(!isWasmInitialized) {
35829 throw new Error("initializeWasm() must be awaited first!");
35831 const nativeResponseValue = wasm.TS_CreationError_eq(a, b);
35832 return nativeResponseValue;
35834 // struct LDKStr CreationError_to_str(const enum LDKCreationError *NONNULL_PTR o);
35836 export function CreationError_to_str(o: bigint): number {
35837 if(!isWasmInitialized) {
35838 throw new Error("initializeWasm() must be awaited first!");
35840 const nativeResponseValue = wasm.TS_CreationError_to_str(o);
35841 return nativeResponseValue;
35843 // enum LDKSemanticError SemanticError_clone(const enum LDKSemanticError *NONNULL_PTR orig);
35845 export function SemanticError_clone(orig: bigint): SemanticError {
35846 if(!isWasmInitialized) {
35847 throw new Error("initializeWasm() must be awaited first!");
35849 const nativeResponseValue = wasm.TS_SemanticError_clone(orig);
35850 return nativeResponseValue;
35852 // enum LDKSemanticError SemanticError_no_payment_hash(void);
35854 export function SemanticError_no_payment_hash(): SemanticError {
35855 if(!isWasmInitialized) {
35856 throw new Error("initializeWasm() must be awaited first!");
35858 const nativeResponseValue = wasm.TS_SemanticError_no_payment_hash();
35859 return nativeResponseValue;
35861 // enum LDKSemanticError SemanticError_multiple_payment_hashes(void);
35863 export function SemanticError_multiple_payment_hashes(): SemanticError {
35864 if(!isWasmInitialized) {
35865 throw new Error("initializeWasm() must be awaited first!");
35867 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_hashes();
35868 return nativeResponseValue;
35870 // enum LDKSemanticError SemanticError_no_description(void);
35872 export function SemanticError_no_description(): SemanticError {
35873 if(!isWasmInitialized) {
35874 throw new Error("initializeWasm() must be awaited first!");
35876 const nativeResponseValue = wasm.TS_SemanticError_no_description();
35877 return nativeResponseValue;
35879 // enum LDKSemanticError SemanticError_multiple_descriptions(void);
35881 export function SemanticError_multiple_descriptions(): SemanticError {
35882 if(!isWasmInitialized) {
35883 throw new Error("initializeWasm() must be awaited first!");
35885 const nativeResponseValue = wasm.TS_SemanticError_multiple_descriptions();
35886 return nativeResponseValue;
35888 // enum LDKSemanticError SemanticError_no_payment_secret(void);
35890 export function SemanticError_no_payment_secret(): SemanticError {
35891 if(!isWasmInitialized) {
35892 throw new Error("initializeWasm() must be awaited first!");
35894 const nativeResponseValue = wasm.TS_SemanticError_no_payment_secret();
35895 return nativeResponseValue;
35897 // enum LDKSemanticError SemanticError_multiple_payment_secrets(void);
35899 export function SemanticError_multiple_payment_secrets(): SemanticError {
35900 if(!isWasmInitialized) {
35901 throw new Error("initializeWasm() must be awaited first!");
35903 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_secrets();
35904 return nativeResponseValue;
35906 // enum LDKSemanticError SemanticError_invalid_features(void);
35908 export function SemanticError_invalid_features(): SemanticError {
35909 if(!isWasmInitialized) {
35910 throw new Error("initializeWasm() must be awaited first!");
35912 const nativeResponseValue = wasm.TS_SemanticError_invalid_features();
35913 return nativeResponseValue;
35915 // enum LDKSemanticError SemanticError_invalid_recovery_id(void);
35917 export function SemanticError_invalid_recovery_id(): SemanticError {
35918 if(!isWasmInitialized) {
35919 throw new Error("initializeWasm() must be awaited first!");
35921 const nativeResponseValue = wasm.TS_SemanticError_invalid_recovery_id();
35922 return nativeResponseValue;
35924 // enum LDKSemanticError SemanticError_invalid_signature(void);
35926 export function SemanticError_invalid_signature(): SemanticError {
35927 if(!isWasmInitialized) {
35928 throw new Error("initializeWasm() must be awaited first!");
35930 const nativeResponseValue = wasm.TS_SemanticError_invalid_signature();
35931 return nativeResponseValue;
35933 // enum LDKSemanticError SemanticError_imprecise_amount(void);
35935 export function SemanticError_imprecise_amount(): SemanticError {
35936 if(!isWasmInitialized) {
35937 throw new Error("initializeWasm() must be awaited first!");
35939 const nativeResponseValue = wasm.TS_SemanticError_imprecise_amount();
35940 return nativeResponseValue;
35942 // bool SemanticError_eq(const enum LDKSemanticError *NONNULL_PTR a, const enum LDKSemanticError *NONNULL_PTR b);
35944 export function SemanticError_eq(a: bigint, b: bigint): boolean {
35945 if(!isWasmInitialized) {
35946 throw new Error("initializeWasm() must be awaited first!");
35948 const nativeResponseValue = wasm.TS_SemanticError_eq(a, b);
35949 return nativeResponseValue;
35951 // struct LDKStr SemanticError_to_str(const enum LDKSemanticError *NONNULL_PTR o);
35953 export function SemanticError_to_str(o: bigint): number {
35954 if(!isWasmInitialized) {
35955 throw new Error("initializeWasm() must be awaited first!");
35957 const nativeResponseValue = wasm.TS_SemanticError_to_str(o);
35958 return nativeResponseValue;
35960 // void SignOrCreationError_free(struct LDKSignOrCreationError this_ptr);
35962 export function SignOrCreationError_free(this_ptr: bigint): void {
35963 if(!isWasmInitialized) {
35964 throw new Error("initializeWasm() must be awaited first!");
35966 const nativeResponseValue = wasm.TS_SignOrCreationError_free(this_ptr);
35967 // debug statements here
35969 // uint64_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg);
35971 export function SignOrCreationError_clone_ptr(arg: bigint): bigint {
35972 if(!isWasmInitialized) {
35973 throw new Error("initializeWasm() must be awaited first!");
35975 const nativeResponseValue = wasm.TS_SignOrCreationError_clone_ptr(arg);
35976 return nativeResponseValue;
35978 // struct LDKSignOrCreationError SignOrCreationError_clone(const struct LDKSignOrCreationError *NONNULL_PTR orig);
35980 export function SignOrCreationError_clone(orig: bigint): bigint {
35981 if(!isWasmInitialized) {
35982 throw new Error("initializeWasm() must be awaited first!");
35984 const nativeResponseValue = wasm.TS_SignOrCreationError_clone(orig);
35985 return nativeResponseValue;
35987 // struct LDKSignOrCreationError SignOrCreationError_sign_error(void);
35989 export function SignOrCreationError_sign_error(): bigint {
35990 if(!isWasmInitialized) {
35991 throw new Error("initializeWasm() must be awaited first!");
35993 const nativeResponseValue = wasm.TS_SignOrCreationError_sign_error();
35994 return nativeResponseValue;
35996 // struct LDKSignOrCreationError SignOrCreationError_creation_error(enum LDKCreationError a);
35998 export function SignOrCreationError_creation_error(a: CreationError): bigint {
35999 if(!isWasmInitialized) {
36000 throw new Error("initializeWasm() must be awaited first!");
36002 const nativeResponseValue = wasm.TS_SignOrCreationError_creation_error(a);
36003 return nativeResponseValue;
36005 // bool SignOrCreationError_eq(const struct LDKSignOrCreationError *NONNULL_PTR a, const struct LDKSignOrCreationError *NONNULL_PTR b);
36007 export function SignOrCreationError_eq(a: bigint, b: bigint): boolean {
36008 if(!isWasmInitialized) {
36009 throw new Error("initializeWasm() must be awaited first!");
36011 const nativeResponseValue = wasm.TS_SignOrCreationError_eq(a, b);
36012 return nativeResponseValue;
36014 // struct LDKStr SignOrCreationError_to_str(const struct LDKSignOrCreationError *NONNULL_PTR o);
36016 export function SignOrCreationError_to_str(o: bigint): number {
36017 if(!isWasmInitialized) {
36018 throw new Error("initializeWasm() must be awaited first!");
36020 const nativeResponseValue = wasm.TS_SignOrCreationError_to_str(o);
36021 return nativeResponseValue;
36023 // void InvoicePayer_free(struct LDKInvoicePayer this_obj);
36025 export function InvoicePayer_free(this_obj: bigint): void {
36026 if(!isWasmInitialized) {
36027 throw new Error("initializeWasm() must be awaited first!");
36029 const nativeResponseValue = wasm.TS_InvoicePayer_free(this_obj);
36030 // debug statements here
36032 // void Payer_free(struct LDKPayer this_ptr);
36034 export function Payer_free(this_ptr: bigint): void {
36035 if(!isWasmInitialized) {
36036 throw new Error("initializeWasm() must be awaited first!");
36038 const nativeResponseValue = wasm.TS_Payer_free(this_ptr);
36039 // debug statements here
36041 // void Router_free(struct LDKRouter this_ptr);
36043 export function Router_free(this_ptr: bigint): void {
36044 if(!isWasmInitialized) {
36045 throw new Error("initializeWasm() must be awaited first!");
36047 const nativeResponseValue = wasm.TS_Router_free(this_ptr);
36048 // debug statements here
36050 // void Retry_free(struct LDKRetry this_ptr);
36052 export function Retry_free(this_ptr: bigint): void {
36053 if(!isWasmInitialized) {
36054 throw new Error("initializeWasm() must be awaited first!");
36056 const nativeResponseValue = wasm.TS_Retry_free(this_ptr);
36057 // debug statements here
36059 // uint64_t Retry_clone_ptr(LDKRetry *NONNULL_PTR arg);
36061 export function Retry_clone_ptr(arg: bigint): bigint {
36062 if(!isWasmInitialized) {
36063 throw new Error("initializeWasm() must be awaited first!");
36065 const nativeResponseValue = wasm.TS_Retry_clone_ptr(arg);
36066 return nativeResponseValue;
36068 // struct LDKRetry Retry_clone(const struct LDKRetry *NONNULL_PTR orig);
36070 export function Retry_clone(orig: bigint): bigint {
36071 if(!isWasmInitialized) {
36072 throw new Error("initializeWasm() must be awaited first!");
36074 const nativeResponseValue = wasm.TS_Retry_clone(orig);
36075 return nativeResponseValue;
36077 // struct LDKRetry Retry_attempts(uintptr_t a);
36079 export function Retry_attempts(a: number): bigint {
36080 if(!isWasmInitialized) {
36081 throw new Error("initializeWasm() must be awaited first!");
36083 const nativeResponseValue = wasm.TS_Retry_attempts(a);
36084 return nativeResponseValue;
36086 // bool Retry_eq(const struct LDKRetry *NONNULL_PTR a, const struct LDKRetry *NONNULL_PTR b);
36088 export function Retry_eq(a: bigint, b: bigint): boolean {
36089 if(!isWasmInitialized) {
36090 throw new Error("initializeWasm() must be awaited first!");
36092 const nativeResponseValue = wasm.TS_Retry_eq(a, b);
36093 return nativeResponseValue;
36095 // uint64_t Retry_hash(const struct LDKRetry *NONNULL_PTR o);
36097 export function Retry_hash(o: bigint): bigint {
36098 if(!isWasmInitialized) {
36099 throw new Error("initializeWasm() must be awaited first!");
36101 const nativeResponseValue = wasm.TS_Retry_hash(o);
36102 return nativeResponseValue;
36104 // void PaymentError_free(struct LDKPaymentError this_ptr);
36106 export function PaymentError_free(this_ptr: bigint): void {
36107 if(!isWasmInitialized) {
36108 throw new Error("initializeWasm() must be awaited first!");
36110 const nativeResponseValue = wasm.TS_PaymentError_free(this_ptr);
36111 // debug statements here
36113 // uint64_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg);
36115 export function PaymentError_clone_ptr(arg: bigint): bigint {
36116 if(!isWasmInitialized) {
36117 throw new Error("initializeWasm() must be awaited first!");
36119 const nativeResponseValue = wasm.TS_PaymentError_clone_ptr(arg);
36120 return nativeResponseValue;
36122 // struct LDKPaymentError PaymentError_clone(const struct LDKPaymentError *NONNULL_PTR orig);
36124 export function PaymentError_clone(orig: bigint): bigint {
36125 if(!isWasmInitialized) {
36126 throw new Error("initializeWasm() must be awaited first!");
36128 const nativeResponseValue = wasm.TS_PaymentError_clone(orig);
36129 return nativeResponseValue;
36131 // struct LDKPaymentError PaymentError_invoice(struct LDKStr a);
36133 export function PaymentError_invoice(a: number): bigint {
36134 if(!isWasmInitialized) {
36135 throw new Error("initializeWasm() must be awaited first!");
36137 const nativeResponseValue = wasm.TS_PaymentError_invoice(a);
36138 return nativeResponseValue;
36140 // struct LDKPaymentError PaymentError_routing(struct LDKLightningError a);
36142 export function PaymentError_routing(a: bigint): bigint {
36143 if(!isWasmInitialized) {
36144 throw new Error("initializeWasm() must be awaited first!");
36146 const nativeResponseValue = wasm.TS_PaymentError_routing(a);
36147 return nativeResponseValue;
36149 // struct LDKPaymentError PaymentError_sending(struct LDKPaymentSendFailure a);
36151 export function PaymentError_sending(a: bigint): bigint {
36152 if(!isWasmInitialized) {
36153 throw new Error("initializeWasm() must be awaited first!");
36155 const nativeResponseValue = wasm.TS_PaymentError_sending(a);
36156 return nativeResponseValue;
36158 // MUST_USE_RES struct LDKInvoicePayer InvoicePayer_new(struct LDKPayer payer, struct LDKRouter router, struct LDKLogger logger, struct LDKEventHandler event_handler, struct LDKRetry retry);
36160 export function InvoicePayer_new(payer: bigint, router: bigint, logger: bigint, event_handler: bigint, retry: bigint): bigint {
36161 if(!isWasmInitialized) {
36162 throw new Error("initializeWasm() must be awaited first!");
36164 const nativeResponseValue = wasm.TS_InvoicePayer_new(payer, router, logger, event_handler, retry);
36165 return nativeResponseValue;
36167 // MUST_USE_RES struct LDKCResult_PaymentIdPaymentErrorZ InvoicePayer_pay_invoice(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const struct LDKInvoice *NONNULL_PTR invoice);
36169 export function InvoicePayer_pay_invoice(this_arg: bigint, invoice: bigint): bigint {
36170 if(!isWasmInitialized) {
36171 throw new Error("initializeWasm() must be awaited first!");
36173 const nativeResponseValue = wasm.TS_InvoicePayer_pay_invoice(this_arg, invoice);
36174 return nativeResponseValue;
36176 // 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);
36178 export function InvoicePayer_pay_zero_value_invoice(this_arg: bigint, invoice: bigint, amount_msats: bigint): bigint {
36179 if(!isWasmInitialized) {
36180 throw new Error("initializeWasm() must be awaited first!");
36182 const nativeResponseValue = wasm.TS_InvoicePayer_pay_zero_value_invoice(this_arg, invoice, amount_msats);
36183 return nativeResponseValue;
36185 // 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);
36187 export function InvoicePayer_pay_pubkey(this_arg: bigint, pubkey: number, payment_preimage: number, amount_msats: bigint, final_cltv_expiry_delta: number): bigint {
36188 if(!isWasmInitialized) {
36189 throw new Error("initializeWasm() must be awaited first!");
36191 const nativeResponseValue = wasm.TS_InvoicePayer_pay_pubkey(this_arg, pubkey, payment_preimage, amount_msats, final_cltv_expiry_delta);
36192 return nativeResponseValue;
36194 // void InvoicePayer_remove_cached_payment(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
36196 export function InvoicePayer_remove_cached_payment(this_arg: bigint, payment_hash: number): void {
36197 if(!isWasmInitialized) {
36198 throw new Error("initializeWasm() must be awaited first!");
36200 const nativeResponseValue = wasm.TS_InvoicePayer_remove_cached_payment(this_arg, payment_hash);
36201 // debug statements here
36203 // struct LDKEventHandler InvoicePayer_as_EventHandler(const struct LDKInvoicePayer *NONNULL_PTR this_arg);
36205 export function InvoicePayer_as_EventHandler(this_arg: bigint): bigint {
36206 if(!isWasmInitialized) {
36207 throw new Error("initializeWasm() must be awaited first!");
36209 const nativeResponseValue = wasm.TS_InvoicePayer_as_EventHandler(this_arg);
36210 return nativeResponseValue;
36212 // void InFlightHtlcs_free(struct LDKInFlightHtlcs this_obj);
36214 export function InFlightHtlcs_free(this_obj: bigint): void {
36215 if(!isWasmInitialized) {
36216 throw new Error("initializeWasm() must be awaited first!");
36218 const nativeResponseValue = wasm.TS_InFlightHtlcs_free(this_obj);
36219 // debug statements here
36221 // 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);
36223 export function InFlightHtlcs_used_liquidity_msat(this_arg: bigint, source: bigint, target: bigint, channel_scid: bigint): bigint {
36224 if(!isWasmInitialized) {
36225 throw new Error("initializeWasm() must be awaited first!");
36227 const nativeResponseValue = wasm.TS_InFlightHtlcs_used_liquidity_msat(this_arg, source, target, channel_scid);
36228 return nativeResponseValue;
36230 // struct LDKCVec_u8Z InFlightHtlcs_write(const struct LDKInFlightHtlcs *NONNULL_PTR obj);
36232 export function InFlightHtlcs_write(obj: bigint): number {
36233 if(!isWasmInitialized) {
36234 throw new Error("initializeWasm() must be awaited first!");
36236 const nativeResponseValue = wasm.TS_InFlightHtlcs_write(obj);
36237 return nativeResponseValue;
36239 // struct LDKCResult_InFlightHtlcsDecodeErrorZ InFlightHtlcs_read(struct LDKu8slice ser);
36241 export function InFlightHtlcs_read(ser: number): bigint {
36242 if(!isWasmInitialized) {
36243 throw new Error("initializeWasm() must be awaited first!");
36245 const nativeResponseValue = wasm.TS_InFlightHtlcs_read(ser);
36246 return nativeResponseValue;
36248 // struct LDKCResult_InvoiceSignOrCreationErrorZ create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(const struct LDKChannelManager *NONNULL_PTR channelmanager, struct LDKKeysInterface keys_manager, struct LDKLogger logger, enum LDKCurrency network, struct LDKCOption_u64Z amt_msat, struct LDKSha256 description_hash, uint64_t duration_since_epoch, uint32_t invoice_expiry_delta_secs);
36250 export function create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(channelmanager: bigint, keys_manager: bigint, logger: bigint, network: Currency, amt_msat: bigint, description_hash: bigint, duration_since_epoch: bigint, invoice_expiry_delta_secs: number): bigint {
36251 if(!isWasmInitialized) {
36252 throw new Error("initializeWasm() must be awaited first!");
36254 const nativeResponseValue = wasm.TS_create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(channelmanager, keys_manager, logger, network, amt_msat, description_hash, duration_since_epoch, invoice_expiry_delta_secs);
36255 return nativeResponseValue;
36257 // struct LDKCResult_InvoiceSignOrCreationErrorZ create_invoice_from_channelmanager_and_duration_since_epoch(const struct LDKChannelManager *NONNULL_PTR channelmanager, struct LDKKeysInterface keys_manager, struct LDKLogger logger, enum LDKCurrency network, struct LDKCOption_u64Z amt_msat, struct LDKStr description, uint64_t duration_since_epoch, uint32_t invoice_expiry_delta_secs);
36259 export function create_invoice_from_channelmanager_and_duration_since_epoch(channelmanager: bigint, keys_manager: bigint, logger: bigint, network: Currency, amt_msat: bigint, description: number, duration_since_epoch: bigint, invoice_expiry_delta_secs: number): bigint {
36260 if(!isWasmInitialized) {
36261 throw new Error("initializeWasm() must be awaited first!");
36263 const nativeResponseValue = wasm.TS_create_invoice_from_channelmanager_and_duration_since_epoch(channelmanager, keys_manager, logger, network, amt_msat, description, duration_since_epoch, invoice_expiry_delta_secs);
36264 return nativeResponseValue;
36266 // void DefaultRouter_free(struct LDKDefaultRouter this_obj);
36268 export function DefaultRouter_free(this_obj: bigint): void {
36269 if(!isWasmInitialized) {
36270 throw new Error("initializeWasm() must be awaited first!");
36272 const nativeResponseValue = wasm.TS_DefaultRouter_free(this_obj);
36273 // debug statements here
36275 // 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);
36277 export function DefaultRouter_new(network_graph: bigint, logger: bigint, random_seed_bytes: number, scorer: bigint): bigint {
36278 if(!isWasmInitialized) {
36279 throw new Error("initializeWasm() must be awaited first!");
36281 const nativeResponseValue = wasm.TS_DefaultRouter_new(network_graph, logger, random_seed_bytes, scorer);
36282 return nativeResponseValue;
36284 // struct LDKRouter DefaultRouter_as_Router(const struct LDKDefaultRouter *NONNULL_PTR this_arg);
36286 export function DefaultRouter_as_Router(this_arg: bigint): bigint {
36287 if(!isWasmInitialized) {
36288 throw new Error("initializeWasm() must be awaited first!");
36290 const nativeResponseValue = wasm.TS_DefaultRouter_as_Router(this_arg);
36291 return nativeResponseValue;
36293 // struct LDKPayer ChannelManager_as_Payer(const struct LDKChannelManager *NONNULL_PTR this_arg);
36295 export function ChannelManager_as_Payer(this_arg: bigint): bigint {
36296 if(!isWasmInitialized) {
36297 throw new Error("initializeWasm() must be awaited first!");
36299 const nativeResponseValue = wasm.TS_ChannelManager_as_Payer(this_arg);
36300 return nativeResponseValue;
36302 // struct LDKCResult_SiPrefixParseErrorZ SiPrefix_from_str(struct LDKStr s);
36304 export function SiPrefix_from_str(s: number): bigint {
36305 if(!isWasmInitialized) {
36306 throw new Error("initializeWasm() must be awaited first!");
36308 const nativeResponseValue = wasm.TS_SiPrefix_from_str(s);
36309 return nativeResponseValue;
36311 // struct LDKCResult_InvoiceParseOrSemanticErrorZ Invoice_from_str(struct LDKStr s);
36313 export function Invoice_from_str(s: number): bigint {
36314 if(!isWasmInitialized) {
36315 throw new Error("initializeWasm() must be awaited first!");
36317 const nativeResponseValue = wasm.TS_Invoice_from_str(s);
36318 return nativeResponseValue;
36320 // struct LDKCResult_SignedRawInvoiceParseErrorZ SignedRawInvoice_from_str(struct LDKStr s);
36322 export function SignedRawInvoice_from_str(s: number): bigint {
36323 if(!isWasmInitialized) {
36324 throw new Error("initializeWasm() must be awaited first!");
36326 const nativeResponseValue = wasm.TS_SignedRawInvoice_from_str(s);
36327 return nativeResponseValue;
36329 // struct LDKStr ParseError_to_str(const struct LDKParseError *NONNULL_PTR o);
36331 export function ParseError_to_str(o: bigint): number {
36332 if(!isWasmInitialized) {
36333 throw new Error("initializeWasm() must be awaited first!");
36335 const nativeResponseValue = wasm.TS_ParseError_to_str(o);
36336 return nativeResponseValue;
36338 // struct LDKStr ParseOrSemanticError_to_str(const struct LDKParseOrSemanticError *NONNULL_PTR o);
36340 export function ParseOrSemanticError_to_str(o: bigint): number {
36341 if(!isWasmInitialized) {
36342 throw new Error("initializeWasm() must be awaited first!");
36344 const nativeResponseValue = wasm.TS_ParseOrSemanticError_to_str(o);
36345 return nativeResponseValue;
36347 // struct LDKStr Invoice_to_str(const struct LDKInvoice *NONNULL_PTR o);
36349 export function Invoice_to_str(o: bigint): number {
36350 if(!isWasmInitialized) {
36351 throw new Error("initializeWasm() must be awaited first!");
36353 const nativeResponseValue = wasm.TS_Invoice_to_str(o);
36354 return nativeResponseValue;
36356 // struct LDKStr SignedRawInvoice_to_str(const struct LDKSignedRawInvoice *NONNULL_PTR o);
36358 export function SignedRawInvoice_to_str(o: bigint): number {
36359 if(!isWasmInitialized) {
36360 throw new Error("initializeWasm() must be awaited first!");
36362 const nativeResponseValue = wasm.TS_SignedRawInvoice_to_str(o);
36363 return nativeResponseValue;
36365 // struct LDKStr Currency_to_str(const enum LDKCurrency *NONNULL_PTR o);
36367 export function Currency_to_str(o: bigint): number {
36368 if(!isWasmInitialized) {
36369 throw new Error("initializeWasm() must be awaited first!");
36371 const nativeResponseValue = wasm.TS_Currency_to_str(o);
36372 return nativeResponseValue;
36374 // struct LDKStr SiPrefix_to_str(const enum LDKSiPrefix *NONNULL_PTR o);
36376 export function SiPrefix_to_str(o: bigint): number {
36377 if(!isWasmInitialized) {
36378 throw new Error("initializeWasm() must be awaited first!");
36380 const nativeResponseValue = wasm.TS_SiPrefix_to_str(o);
36381 return nativeResponseValue;
36385 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) {
36386 const weak: WeakRef<object>|undefined = js_objs[obj_ptr];
36387 if (weak == null || weak == undefined) {
36388 console.error("Got function call on unknown/free'd JS object!");
36389 throw new Error("Got function call on unknown/free'd JS object!");
36391 const obj = weak.deref();
36392 if (obj == null || obj == undefined) {
36393 console.error("Got function call on GC'd JS object!");
36394 throw new Error("Got function call on GC'd JS object!");
36398 case 0: fn = Object.getOwnPropertyDescriptor(obj, "log"); break;
36399 case 1: fn = Object.getOwnPropertyDescriptor(obj, "get_utxo"); break;
36400 case 2: fn = Object.getOwnPropertyDescriptor(obj, "get_per_commitment_point"); break;
36401 case 3: fn = Object.getOwnPropertyDescriptor(obj, "release_commitment_secret"); break;
36402 case 4: fn = Object.getOwnPropertyDescriptor(obj, "validate_holder_commitment"); break;
36403 case 5: fn = Object.getOwnPropertyDescriptor(obj, "channel_keys_id"); break;
36404 case 6: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_commitment"); break;
36405 case 7: fn = Object.getOwnPropertyDescriptor(obj, "validate_counterparty_revocation"); break;
36406 case 8: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_commitment_and_htlcs"); break;
36407 case 9: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_output"); break;
36408 case 10: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_htlc"); break;
36409 case 11: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_htlc_transaction"); break;
36410 case 12: fn = Object.getOwnPropertyDescriptor(obj, "sign_closing_transaction"); break;
36411 case 13: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_anchor_input"); break;
36412 case 14: fn = Object.getOwnPropertyDescriptor(obj, "sign_channel_announcement"); break;
36413 case 15: fn = Object.getOwnPropertyDescriptor(obj, "ready_channel"); break;
36414 case 16: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
36415 case 17: fn = Object.getOwnPropertyDescriptor(obj, "watch_channel"); break;
36416 case 18: fn = Object.getOwnPropertyDescriptor(obj, "update_channel"); break;
36417 case 19: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_monitor_events"); break;
36418 case 20: fn = Object.getOwnPropertyDescriptor(obj, "broadcast_transaction"); break;
36419 case 21: fn = Object.getOwnPropertyDescriptor(obj, "get_node_secret"); break;
36420 case 22: fn = Object.getOwnPropertyDescriptor(obj, "get_node_id"); break;
36421 case 23: fn = Object.getOwnPropertyDescriptor(obj, "ecdh"); break;
36422 case 24: fn = Object.getOwnPropertyDescriptor(obj, "get_destination_script"); break;
36423 case 25: fn = Object.getOwnPropertyDescriptor(obj, "get_shutdown_scriptpubkey"); break;
36424 case 26: fn = Object.getOwnPropertyDescriptor(obj, "get_channel_signer"); break;
36425 case 27: fn = Object.getOwnPropertyDescriptor(obj, "get_secure_random_bytes"); break;
36426 case 28: fn = Object.getOwnPropertyDescriptor(obj, "read_chan_signer"); break;
36427 case 29: fn = Object.getOwnPropertyDescriptor(obj, "sign_invoice"); break;
36428 case 30: fn = Object.getOwnPropertyDescriptor(obj, "get_inbound_payment_key_material"); break;
36429 case 31: fn = Object.getOwnPropertyDescriptor(obj, "get_est_sat_per_1000_weight"); break;
36430 case 32: fn = Object.getOwnPropertyDescriptor(obj, "type_id"); break;
36431 case 33: fn = Object.getOwnPropertyDescriptor(obj, "debug_str"); break;
36432 case 34: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
36433 case 35: fn = Object.getOwnPropertyDescriptor(obj, "tlv_type"); break;
36434 case 36: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
36435 case 37: fn = Object.getOwnPropertyDescriptor(obj, "register_tx"); break;
36436 case 38: fn = Object.getOwnPropertyDescriptor(obj, "register_output"); break;
36437 case 39: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg_events"); break;
36438 case 40: fn = Object.getOwnPropertyDescriptor(obj, "next_onion_message_for_peer"); break;
36439 case 41: fn = Object.getOwnPropertyDescriptor(obj, "handle_event"); break;
36440 case 42: fn = Object.getOwnPropertyDescriptor(obj, "process_pending_events"); break;
36441 case 43: fn = Object.getOwnPropertyDescriptor(obj, "channel_penalty_msat"); break;
36442 case 44: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_failed"); break;
36443 case 45: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_successful"); break;
36444 case 46: fn = Object.getOwnPropertyDescriptor(obj, "probe_failed"); break;
36445 case 47: fn = Object.getOwnPropertyDescriptor(obj, "probe_successful"); break;
36446 case 48: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
36447 case 49: fn = Object.getOwnPropertyDescriptor(obj, "lock"); break;
36448 case 50: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
36449 case 51: fn = Object.getOwnPropertyDescriptor(obj, "persist_manager"); break;
36450 case 52: fn = Object.getOwnPropertyDescriptor(obj, "persist_graph"); break;
36451 case 53: fn = Object.getOwnPropertyDescriptor(obj, "persist_scorer"); break;
36452 case 54: fn = Object.getOwnPropertyDescriptor(obj, "call"); break;
36453 case 55: fn = Object.getOwnPropertyDescriptor(obj, "filtered_block_connected"); break;
36454 case 56: fn = Object.getOwnPropertyDescriptor(obj, "block_connected"); break;
36455 case 57: fn = Object.getOwnPropertyDescriptor(obj, "block_disconnected"); break;
36456 case 58: fn = Object.getOwnPropertyDescriptor(obj, "transactions_confirmed"); break;
36457 case 59: fn = Object.getOwnPropertyDescriptor(obj, "transaction_unconfirmed"); break;
36458 case 60: fn = Object.getOwnPropertyDescriptor(obj, "best_block_updated"); break;
36459 case 61: fn = Object.getOwnPropertyDescriptor(obj, "get_relevant_txids"); break;
36460 case 62: fn = Object.getOwnPropertyDescriptor(obj, "persist_new_channel"); break;
36461 case 63: fn = Object.getOwnPropertyDescriptor(obj, "update_persisted_channel"); break;
36462 case 64: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel"); break;
36463 case 65: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel"); break;
36464 case 66: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_created"); break;
36465 case 67: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_signed"); break;
36466 case 68: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_ready"); break;
36467 case 69: fn = Object.getOwnPropertyDescriptor(obj, "handle_shutdown"); break;
36468 case 70: fn = Object.getOwnPropertyDescriptor(obj, "handle_closing_signed"); break;
36469 case 71: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_add_htlc"); break;
36470 case 72: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fulfill_htlc"); break;
36471 case 73: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_htlc"); break;
36472 case 74: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_malformed_htlc"); break;
36473 case 75: fn = Object.getOwnPropertyDescriptor(obj, "handle_commitment_signed"); break;
36474 case 76: fn = Object.getOwnPropertyDescriptor(obj, "handle_revoke_and_ack"); break;
36475 case 77: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fee"); break;
36476 case 78: fn = Object.getOwnPropertyDescriptor(obj, "handle_announcement_signatures"); break;
36477 case 79: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
36478 case 80: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
36479 case 81: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_reestablish"); break;
36480 case 82: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
36481 case 83: fn = Object.getOwnPropertyDescriptor(obj, "handle_error"); break;
36482 case 84: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
36483 case 85: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
36484 case 86: fn = Object.getOwnPropertyDescriptor(obj, "handle_node_announcement"); break;
36485 case 87: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_announcement"); break;
36486 case 88: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
36487 case 89: fn = Object.getOwnPropertyDescriptor(obj, "get_next_channel_announcement"); break;
36488 case 90: fn = Object.getOwnPropertyDescriptor(obj, "get_next_node_announcement"); break;
36489 case 91: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
36490 case 92: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_channel_range"); break;
36491 case 93: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_short_channel_ids_end"); break;
36492 case 94: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_channel_range"); break;
36493 case 95: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_short_channel_ids"); break;
36494 case 96: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
36495 case 97: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
36496 case 98: fn = Object.getOwnPropertyDescriptor(obj, "handle_onion_message"); break;
36497 case 99: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
36498 case 100: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
36499 case 101: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
36500 case 102: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
36501 case 103: fn = Object.getOwnPropertyDescriptor(obj, "read"); break;
36502 case 104: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
36503 case 105: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg"); break;
36504 case 106: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
36505 case 107: fn = Object.getOwnPropertyDescriptor(obj, "read_custom_message"); break;
36506 case 108: fn = Object.getOwnPropertyDescriptor(obj, "send_data"); break;
36507 case 109: fn = Object.getOwnPropertyDescriptor(obj, "disconnect_socket"); break;
36508 case 110: fn = Object.getOwnPropertyDescriptor(obj, "eq"); break;
36509 case 111: fn = Object.getOwnPropertyDescriptor(obj, "hash"); break;
36510 case 112: fn = Object.getOwnPropertyDescriptor(obj, "node_id"); break;
36511 case 113: fn = Object.getOwnPropertyDescriptor(obj, "first_hops"); break;
36512 case 114: fn = Object.getOwnPropertyDescriptor(obj, "send_payment"); break;
36513 case 115: fn = Object.getOwnPropertyDescriptor(obj, "send_spontaneous_payment"); break;
36514 case 116: fn = Object.getOwnPropertyDescriptor(obj, "retry_payment"); break;
36515 case 117: fn = Object.getOwnPropertyDescriptor(obj, "abandon_payment"); break;
36516 case 118: fn = Object.getOwnPropertyDescriptor(obj, "find_route"); break;
36517 case 119: fn = Object.getOwnPropertyDescriptor(obj, "notify_payment_path_failed"); break;
36518 case 120: fn = Object.getOwnPropertyDescriptor(obj, "notify_payment_path_successful"); break;
36519 case 121: fn = Object.getOwnPropertyDescriptor(obj, "notify_payment_probe_successful"); break;
36520 case 122: fn = Object.getOwnPropertyDescriptor(obj, "notify_payment_probe_failed"); break;
36522 console.error("Got unknown function call from C!");
36523 throw new Error("Got unknown function call from C!");
36525 if (fn == null || fn == undefined) {
36526 console.error("Got function call on incorrect JS object!");
36527 throw new Error("Got function call on incorrect JS object!");
36529 const ret = fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
36530 if (ret === undefined || ret === null) return BigInt(0);
36531 return BigInt(ret);