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", "ububuu"];
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 encodeUint128 (inputVal: bigint): number {
133 if (inputVal >= 0x10000000000000000000000000000000n) throw "U128s cannot exceed 128 bits";
134 const cArrayPointer = wasm.TS_malloc(16 + 8);
135 const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
136 arrayLengthView[0] = BigInt(16);
137 const arrayMemoryView = new Uint8Array(wasm.memory.buffer, cArrayPointer + 8, 16);
138 for (var i = 0; i < 16; i++) arrayMemoryView[i] = Number((inputVal >> BigInt(i)*8n) & 0xffn);
139 return cArrayPointer;
142 export function encodeUint8Array (inputArray: Uint8Array|null): number {
143 if (inputArray == null) return 0;
144 const cArrayPointer = wasm.TS_malloc(inputArray.length + 8);
145 const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
146 arrayLengthView[0] = BigInt(inputArray.length);
147 const arrayMemoryView = new Uint8Array(wasm.memory.buffer, cArrayPointer + 8, inputArray.length);
148 arrayMemoryView.set(inputArray);
149 return cArrayPointer;
152 export function encodeUint16Array (inputArray: Uint16Array|Array<number>|null): number {
153 if (inputArray == null) return 0;
154 const cArrayPointer = wasm.TS_malloc((inputArray.length + 4) * 2);
155 const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
156 arrayLengthView[0] = BigInt(inputArray.length);
157 const arrayMemoryView = new Uint16Array(wasm.memory.buffer, cArrayPointer + 8, inputArray.length);
158 arrayMemoryView.set(inputArray);
159 return cArrayPointer;
162 export function encodeUint32Array (inputArray: Uint32Array|Array<number>|null): number {
163 if (inputArray == null) return 0;
164 const cArrayPointer = wasm.TS_malloc((inputArray.length + 2) * 4);
165 const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
166 arrayLengthView[0] = BigInt(inputArray.length);
167 const arrayMemoryView = new Uint32Array(wasm.memory.buffer, cArrayPointer + 8, inputArray.length);
168 arrayMemoryView.set(inputArray);
169 return cArrayPointer;
172 export function encodeUint64Array (inputArray: BigUint64Array|Array<bigint>|null): number {
173 if (inputArray == null) return 0;
174 const cArrayPointer = wasm.TS_malloc((inputArray.length + 1) * 8);
175 const arrayMemoryView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, inputArray.length + 1);
176 arrayMemoryView[0] = BigInt(inputArray.length);
177 arrayMemoryView.set(inputArray, 1);
178 return cArrayPointer;
182 export function check_arr_len(arr: Uint8Array|null, len: number): Uint8Array|null {
183 if (arr !== null && arr.length != len) { throw new Error("Expected array of length " + len + " got " + arr.length); }
188 export function check_16_arr_len(arr: Uint16Array|null, len: number): Uint16Array|null {
189 if (arr !== null && arr.length != len) { throw new Error("Expected array of length " + len + " got " + arr.length); }
194 export function getArrayLength(arrayPointer: number): number {
195 const arraySizeViewer = new BigUint64Array(wasm.memory.buffer, arrayPointer, 1);
196 const len = arraySizeViewer[0]!;
197 if (len >= (2n ** 32n)) throw new Error("Bogus Array Size");
198 return Number(len % (2n ** 32n));
201 export function decodeUint128 (arrayPointer: number, free = true): bigint {
202 const arraySize = getArrayLength(arrayPointer);
203 if (arraySize != 16) throw "Need 16 bytes for a uint128";
204 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 8, arraySize);
206 for (var i = 0; i < 16; i++) {
208 val |= BigInt(actualArrayViewer[i]!);
211 wasm.TS_free(arrayPointer);
216 export function decodeUint8Array (arrayPointer: number, free = true): Uint8Array {
217 const arraySize = getArrayLength(arrayPointer);
218 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 8, arraySize);
219 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
220 // will free the underlying memory when it becomes unreachable instead of copying here.
221 // Note that doing so may have edge-case interactions with memory resizing (invalidating the buffer).
222 const actualArray = actualArrayViewer.slice(0, arraySize);
224 wasm.TS_free(arrayPointer);
229 export function decodeUint16Array (arrayPointer: number, free = true): Uint16Array {
230 const arraySize = getArrayLength(arrayPointer);
231 const actualArrayViewer = new Uint16Array(wasm.memory.buffer, arrayPointer + 8, arraySize);
232 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
233 // will free the underlying memory when it becomes unreachable instead of copying here.
234 // Note that doing so may have edge-case interactions with memory resizing (invalidating the buffer).
235 const actualArray = actualArrayViewer.slice(0, arraySize);
237 wasm.TS_free(arrayPointer);
242 export function decodeUint64Array (arrayPointer: number, free = true): bigint[] {
243 const arraySize = getArrayLength(arrayPointer);
244 const actualArrayViewer = new BigUint64Array(
245 wasm.memory.buffer, // value
246 arrayPointer + 8, // offset (ignoring length bytes)
247 arraySize // uint32 count
249 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
250 // will free the underlying memory when it becomes unreachable instead of copying here.
251 const actualArray = new Array(arraySize);
252 for (var i = 0; i < arraySize; i++) actualArray[i] = actualArrayViewer[i];
254 wasm.TS_free(arrayPointer);
259 export function freeWasmMemory(pointer: number) { wasm.TS_free(pointer); }
262 export function getU64ArrayElem(arrayPointer: number, idx: number): bigint {
263 const actualArrayViewer = new BigUint64Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
264 return actualArrayViewer[idx]!;
268 export function getU32ArrayElem(arrayPointer: number, idx: number): number {
269 const actualArrayViewer = new Uint32Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
270 return actualArrayViewer[idx]!;
274 export function getU8ArrayElem(arrayPointer: number, idx: number): number {
275 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
276 return actualArrayViewer[idx]!;
281 export function encodeString(str: string): number {
282 const charArray = new TextEncoder().encode(str);
283 return encodeUint8Array(charArray);
287 export function decodeString(stringPointer: number, free = true): string {
288 const arraySize = getArrayLength(stringPointer);
289 const memoryView = new Uint8Array(wasm.memory.buffer, stringPointer + 8, arraySize);
290 const result = new TextDecoder("utf-8").decode(memoryView);
293 wasm.TS_free(stringPointer);
299 /* @internal */ export function getRemainingAllocationCount(): number { return 0; }
300 /* @internal */ export function debugPrintRemainingAllocs() { }
303 * An enum which can either contain a or not
305 export enum COption_NoneZ {
307 * When we're in this state, this COption_NoneZ contains a
309 LDKCOption_NoneZ_Some,
311 * When we're in this state, this COption_NoneZ contains nothing
313 LDKCOption_NoneZ_None,
318 * An enum representing the status of a channel monitor update persistence.
320 export enum ChannelMonitorUpdateStatus {
322 * The update has been durably persisted and all copies of the relevant [`ChannelMonitor`]
325 This includes performing any `fsync()` calls required to ensure the update is guaranteed to
326 be available on restart even if the application crashes.
328 LDKChannelMonitorUpdateStatus_Completed,
330 * Used to indicate a temporary failure (eg connection to a watchtower or remote backup of
331 our state failed, but is expected to succeed at some point in the future).
333 Such a failure will \"freeze\" a channel, preventing us from revoking old states or
334 submitting new commitment transactions to the counterparty. Once the update(s) which failed
335 have been successfully applied, a [`MonitorEvent::Completed`] can be used to restore the
336 channel to an operational state.
338 Note that a given [`ChannelManager`] will *never* re-generate a [`ChannelMonitorUpdate`].
339 If you return this error you must ensure that it is written to disk safely before writing
340 the latest [`ChannelManager`] state, or you should return [`PermanentFailure`] instead.
342 Even when a channel has been \"frozen\", updates to the [`ChannelMonitor`] can continue to
343 occur (e.g. if an inbound HTLC which we forwarded was claimed upstream, resulting in us
344 attempting to claim it on this channel) and those updates must still be persisted.
346 No updates to the channel will be made which could invalidate other [`ChannelMonitor`]s
347 until a [`MonitorEvent::Completed`] is provided, even if you return no error on a later
348 monitor update for the same channel.
350 For deployments where a copy of ChannelMonitors and other local state are backed up in a
351 remote location (with local copies persisted immediately), it is anticipated that all
352 updates will return [`InProgress`] until the remote copies could be updated.
354 [`PermanentFailure`]: ChannelMonitorUpdateStatus::PermanentFailure
355 [`InProgress`]: ChannelMonitorUpdateStatus::InProgress
356 [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
358 LDKChannelMonitorUpdateStatus_InProgress,
360 * Used to indicate no further channel monitor updates will be allowed (likely a disk failure
361 or a remote copy of this [`ChannelMonitor`] is no longer reachable and thus not updatable).
363 When this is returned, [`ChannelManager`] will force-close the channel but *not* broadcast
364 our current commitment transaction. This avoids a dangerous case where a local disk failure
365 (e.g. the Linux-default remounting of the disk as read-only) causes [`PermanentFailure`]s
366 for all monitor updates. If we were to broadcast our latest commitment transaction and then
367 restart, we could end up reading a previous [`ChannelMonitor`] and [`ChannelManager`],
368 revoking our now-broadcasted state before seeing it confirm and losing all our funds.
370 Note that this is somewhat of a tradeoff - if the disk is really gone and we may have lost
371 the data permanently, we really should broadcast immediately. If the data can be recovered
372 with manual intervention, we'd rather close the channel, rejecting future updates to it,
373 and broadcast the latest state only if we have HTLCs to claim which are timing out (which
374 we do as long as blocks are connected).
376 In order to broadcast the latest local commitment transaction, you'll need to call
377 [`ChannelMonitor::get_latest_holder_commitment_txn`] and broadcast the resulting
378 transactions once you've safely ensured no further channel updates can be generated by your
381 Note that at least one final [`ChannelMonitorUpdate`] may still be provided, which must
382 still be processed by a running [`ChannelMonitor`]. This final update will mark the
383 [`ChannelMonitor`] as finalized, ensuring no further updates (e.g. revocation of the latest
384 commitment transaction) are allowed.
386 Note that even if you return a [`PermanentFailure`] due to unavailability of secondary
387 [`ChannelMonitor`] copies, you should still make an attempt to store the update where
388 possible to ensure you can claim HTLC outputs on the latest commitment transaction
391 In case of distributed watchtowers deployment, the new version must be written to disk, as
392 state may have been stored but rejected due to a block forcing a commitment broadcast. This
393 storage is used to claim outputs of rejected state confirmed onchain by another watchtower,
394 lagging behind on block processing.
396 [`PermanentFailure`]: ChannelMonitorUpdateStatus::PermanentFailure
397 [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
399 LDKChannelMonitorUpdateStatus_PermanentFailure,
404 * An enum that represents the speed at which we want a transaction to confirm used for feerate
407 export enum ConfirmationTarget {
409 * We are happy with this transaction confirming slowly when feerate drops some.
411 LDKConfirmationTarget_Background,
413 * We'd like this transaction to confirm without major delay, but 12-18 blocks is fine.
415 LDKConfirmationTarget_Normal,
417 * We'd like this transaction to confirm in the next few blocks.
419 LDKConfirmationTarget_HighPriority,
424 * Errors that may occur when constructing a new `RawInvoice` or `Invoice`
426 export enum CreationError {
428 * The supplied description string was longer than 639 __bytes__ (see [`Description::new(...)`](./struct.Description.html#method.new))
430 LDKCreationError_DescriptionTooLong,
432 * The specified route has too many hops and can't be encoded
434 LDKCreationError_RouteTooLong,
436 * The Unix timestamp of the supplied date is less than zero or greater than 35-bits
438 LDKCreationError_TimestampOutOfBounds,
440 * The supplied millisatoshi amount was greater than the total bitcoin supply.
442 LDKCreationError_InvalidAmount,
444 * Route hints were required for this invoice and were missing. Applies to
447 [phantom invoices]: crate::utils::create_phantom_invoice
449 LDKCreationError_MissingRouteHints,
451 * The provided `min_final_cltv_expiry_delta` was less than [`MIN_FINAL_CLTV_EXPIRY_DELTA`].
453 [`MIN_FINAL_CLTV_EXPIRY_DELTA`]: lightning::ln::channelmanager::MIN_FINAL_CLTV_EXPIRY_DELTA
455 LDKCreationError_MinFinalCltvExpiryDeltaTooShort,
460 * Enum representing the crypto currencies (or networks) supported by this library
462 export enum Currency {
470 LDKCurrency_BitcoinTestnet,
487 * This enum is used to specify which error data to send to peers when failing back an HTLC
488 * using [`ChannelManager::fail_htlc_backwards_with_reason`].
490 * For more info on failure codes, see <https://github.com/lightning/bolts/blob/master/04-onion-routing.md#failure-messages>.
492 export enum FailureCode {
494 * We had a temporary error processing the payment. Useful if no other error codes fit
495 and you want to indicate that the payer may want to retry.
497 LDKFailureCode_TemporaryNodeFailure,
499 * We have a required feature which was not in this onion. For example, you may require
500 some additional metadata that was not provided with this payment.
502 LDKFailureCode_RequiredNodeFeatureMissing,
504 * You may wish to use this when a `payment_preimage` is unknown, or the CLTV expiry of
505 the HTLC is too close to the current block height for safe handling.
506 Using this failure code in [`ChannelManager::fail_htlc_backwards_with_reason`] is
507 equivalent to calling [`ChannelManager::fail_htlc_backwards`].
509 LDKFailureCode_IncorrectOrUnknownPaymentDetails,
514 * Describes the type of HTLC claim as determined by analyzing the witness.
516 export enum HTLCClaim {
518 * Claims an offered output on a commitment transaction through the timeout path.
520 LDKHTLCClaim_OfferedTimeout,
522 * Claims an offered output on a commitment transaction through the success path.
524 LDKHTLCClaim_OfferedPreimage,
526 * Claims an accepted output on a commitment transaction through the timeout path.
528 LDKHTLCClaim_AcceptedTimeout,
530 * Claims an accepted output on a commitment transaction through the success path.
532 LDKHTLCClaim_AcceptedPreimage,
534 * Claims an offered/accepted output on a commitment transaction through the revocation path.
536 LDKHTLCClaim_Revocation,
541 * Represents an IO Error. Note that some information is lost in the conversion from Rust.
543 export enum IOError {
545 LDKIOError_PermissionDenied,
546 LDKIOError_ConnectionRefused,
547 LDKIOError_ConnectionReset,
548 LDKIOError_ConnectionAborted,
549 LDKIOError_NotConnected,
550 LDKIOError_AddrInUse,
551 LDKIOError_AddrNotAvailable,
552 LDKIOError_BrokenPipe,
553 LDKIOError_AlreadyExists,
554 LDKIOError_WouldBlock,
555 LDKIOError_InvalidInput,
556 LDKIOError_InvalidData,
558 LDKIOError_WriteZero,
559 LDKIOError_Interrupted,
561 LDKIOError_UnexpectedEof,
566 * An enum representing the available verbosity levels of the logger.
570 * Designates extremely verbose information, including gossip-induced messages
574 * Designates very low priority, often extremely verbose, information
578 * Designates lower priority information
582 * Designates useful information
586 * Designates hazardous situations
590 * Designates very serious errors
597 * An enum representing the possible Bitcoin or test networks which we can run on
599 export enum Network {
601 * The main Bitcoin blockchain.
605 * The testnet3 blockchain.
609 * A local test blockchain.
613 * A blockchain on which blocks are signed instead of mined.
620 * Specifies the recipient of an invoice.
622 * This indicates to [`NodeSigner::sign_invoice`] what node secret key should be used to sign
625 export enum Recipient {
627 * The invoice should be signed with the local node secret key.
631 * The invoice should be signed with the phantom node secret key. This secret key must be the
632 same for all nodes participating in the [phantom node payment].
634 [phantom node payment]: PhantomKeysManager
636 LDKRecipient_PhantomNode,
641 * Indicates an immediate error on [`ChannelManager::send_payment_with_retry`]. Further errors
642 * may be surfaced later via [`Event::PaymentPathFailed`] and [`Event::PaymentFailed`].
644 * [`ChannelManager::send_payment_with_retry`]: crate::ln::channelmanager::ChannelManager::send_payment_with_retry
645 * [`Event::PaymentPathFailed`]: crate::util::events::Event::PaymentPathFailed
646 * [`Event::PaymentFailed`]: crate::util::events::Event::PaymentFailed
648 export enum RetryableSendFailure {
650 * The provided [`PaymentParameters::expiry_time`] indicated that the payment has expired. Note
651 that this error is *not* caused by [`Retry::Timeout`].
653 [`PaymentParameters::expiry_time`]: crate::routing::router::PaymentParameters::expiry_time
655 LDKRetryableSendFailure_PaymentExpired,
657 * We were unable to find a route to the destination.
659 LDKRetryableSendFailure_RouteNotFound,
661 * Indicates that a payment for the provided [`PaymentId`] is already in-flight and has not
662 yet completed (i.e. generated an [`Event::PaymentSent`] or [`Event::PaymentFailed`]).
664 [`PaymentId`]: crate::ln::channelmanager::PaymentId
665 [`Event::PaymentSent`]: crate::util::events::Event::PaymentSent
666 [`Event::PaymentFailed`]: crate::util::events::Event::PaymentFailed
668 LDKRetryableSendFailure_DuplicatePayment,
673 * Represents an error returned from libsecp256k1 during validation of some secp256k1 data
675 export enum Secp256k1Error {
677 * Signature failed verification
679 LDKSecp256k1Error_IncorrectSignature,
681 * Badly sized message ("messages" are actually fixed-sized digests; see the MESSAGE_SIZE constant)
683 LDKSecp256k1Error_InvalidMessage,
687 LDKSecp256k1Error_InvalidPublicKey,
691 LDKSecp256k1Error_InvalidSignature,
695 LDKSecp256k1Error_InvalidSecretKey,
699 LDKSecp256k1Error_InvalidSharedSecret,
703 LDKSecp256k1Error_InvalidRecoveryId,
705 * Invalid tweak for add_assign or mul_assign
707 LDKSecp256k1Error_InvalidTweak,
709 * Didn't pass enough memory to context creation with preallocated memory
711 LDKSecp256k1Error_NotEnoughMemory,
713 * Bad set of public keys.
715 LDKSecp256k1Error_InvalidPublicKeySum,
717 * The only valid parity values are 0 or 1.
719 LDKSecp256k1Error_InvalidParityValue,
724 * Errors that may occur when converting a `RawInvoice` to an `Invoice`. They relate to the
725 * requirements sections in BOLT #11
727 export enum SemanticError {
729 * The invoice is missing the mandatory payment hash
731 LDKSemanticError_NoPaymentHash,
733 * The invoice has multiple payment hashes which isn't allowed
735 LDKSemanticError_MultiplePaymentHashes,
737 * No description or description hash are part of the invoice
739 LDKSemanticError_NoDescription,
741 * The invoice contains multiple descriptions and/or description hashes which isn't allowed
743 LDKSemanticError_MultipleDescriptions,
745 * The invoice is missing the mandatory payment secret, which all modern lightning nodes
748 LDKSemanticError_NoPaymentSecret,
750 * The invoice contains multiple payment secrets
752 LDKSemanticError_MultiplePaymentSecrets,
754 * The invoice's features are invalid
756 LDKSemanticError_InvalidFeatures,
758 * The recovery id doesn't fit the signature/pub key
760 LDKSemanticError_InvalidRecoveryId,
762 * The invoice's signature is invalid
764 LDKSemanticError_InvalidSignature,
766 * The invoice's amount was not a whole number of millisatoshis
768 LDKSemanticError_ImpreciseAmount,
773 * SI prefixes for the human readable part
775 export enum SiPrefix {
796 * An error when accessing the chain via [`UtxoLookup`].
798 export enum UtxoLookupError {
800 * The requested chain is unknown.
802 LDKUtxoLookupError_UnknownChain,
804 * The requested transaction doesn't exist or hasn't confirmed.
806 LDKUtxoLookupError_UnknownTx,
809 // struct LDKThirtyTwoBytes BigEndianScalar_get_bytes (struct LDKBigEndianScalar* thing)
811 export function BigEndianScalar_get_bytes(thing: bigint): number {
812 if(!isWasmInitialized) {
813 throw new Error("initializeWasm() must be awaited first!");
815 const nativeResponseValue = wasm.TS_BigEndianScalar_get_bytes(thing);
816 return nativeResponseValue;
818 // static void BigEndianScalar_free (struct LDKBigEndianScalar thing)
820 export function BigEndianScalar_free(thing: bigint): void {
821 if(!isWasmInitialized) {
822 throw new Error("initializeWasm() must be awaited first!");
824 const nativeResponseValue = wasm.TS_BigEndianScalar_free(thing);
825 // debug statements here
828 export class LDKBech32Error {
829 protected constructor() {}
832 export function LDKBech32Error_ty_from_ptr(ptr: bigint): number {
833 if(!isWasmInitialized) {
834 throw new Error("initializeWasm() must be awaited first!");
836 const nativeResponseValue = wasm.TS_LDKBech32Error_ty_from_ptr(ptr);
837 return nativeResponseValue;
840 export function LDKBech32Error_InvalidChar_get_invalid_char(ptr: bigint): number {
841 if(!isWasmInitialized) {
842 throw new Error("initializeWasm() must be awaited first!");
844 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidChar_get_invalid_char(ptr);
845 return nativeResponseValue;
848 export function LDKBech32Error_InvalidData_get_invalid_data(ptr: bigint): number {
849 if(!isWasmInitialized) {
850 throw new Error("initializeWasm() must be awaited first!");
852 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidData_get_invalid_data(ptr);
853 return nativeResponseValue;
855 // struct LDKCVec_u8Z TxOut_get_script_pubkey (struct LDKTxOut* thing)
857 export function TxOut_get_script_pubkey(thing: bigint): number {
858 if(!isWasmInitialized) {
859 throw new Error("initializeWasm() must be awaited first!");
861 const nativeResponseValue = wasm.TS_TxOut_get_script_pubkey(thing);
862 return nativeResponseValue;
864 // uint64_t TxOut_get_value (struct LDKTxOut* thing)
866 export function TxOut_get_value(thing: bigint): bigint {
867 if(!isWasmInitialized) {
868 throw new Error("initializeWasm() must be awaited first!");
870 const nativeResponseValue = wasm.TS_TxOut_get_value(thing);
871 return nativeResponseValue;
874 export class LDKAPIError {
875 protected constructor() {}
878 export function LDKAPIError_ty_from_ptr(ptr: bigint): number {
879 if(!isWasmInitialized) {
880 throw new Error("initializeWasm() must be awaited first!");
882 const nativeResponseValue = wasm.TS_LDKAPIError_ty_from_ptr(ptr);
883 return nativeResponseValue;
886 export function LDKAPIError_APIMisuseError_get_err(ptr: bigint): number {
887 if(!isWasmInitialized) {
888 throw new Error("initializeWasm() must be awaited first!");
890 const nativeResponseValue = wasm.TS_LDKAPIError_APIMisuseError_get_err(ptr);
891 return nativeResponseValue;
894 export function LDKAPIError_FeeRateTooHigh_get_err(ptr: bigint): number {
895 if(!isWasmInitialized) {
896 throw new Error("initializeWasm() must be awaited first!");
898 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_err(ptr);
899 return nativeResponseValue;
902 export function LDKAPIError_FeeRateTooHigh_get_feerate(ptr: bigint): number {
903 if(!isWasmInitialized) {
904 throw new Error("initializeWasm() must be awaited first!");
906 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_feerate(ptr);
907 return nativeResponseValue;
910 export function LDKAPIError_InvalidRoute_get_err(ptr: bigint): number {
911 if(!isWasmInitialized) {
912 throw new Error("initializeWasm() must be awaited first!");
914 const nativeResponseValue = wasm.TS_LDKAPIError_InvalidRoute_get_err(ptr);
915 return nativeResponseValue;
918 export function LDKAPIError_ChannelUnavailable_get_err(ptr: bigint): number {
919 if(!isWasmInitialized) {
920 throw new Error("initializeWasm() must be awaited first!");
922 const nativeResponseValue = wasm.TS_LDKAPIError_ChannelUnavailable_get_err(ptr);
923 return nativeResponseValue;
926 export function LDKAPIError_IncompatibleShutdownScript_get_script(ptr: bigint): bigint {
927 if(!isWasmInitialized) {
928 throw new Error("initializeWasm() must be awaited first!");
930 const nativeResponseValue = wasm.TS_LDKAPIError_IncompatibleShutdownScript_get_script(ptr);
931 return nativeResponseValue;
933 // void CResult_NoneAPIErrorZ_get_ok(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
935 export function CResult_NoneAPIErrorZ_get_ok(owner: bigint): void {
936 if(!isWasmInitialized) {
937 throw new Error("initializeWasm() must be awaited first!");
939 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_ok(owner);
940 // debug statements here
942 // struct LDKAPIError CResult_NoneAPIErrorZ_get_err(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
944 export function CResult_NoneAPIErrorZ_get_err(owner: bigint): bigint {
945 if(!isWasmInitialized) {
946 throw new Error("initializeWasm() must be awaited first!");
948 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_err(owner);
949 return nativeResponseValue;
952 export class LDKCOption_HTLCClaimZ {
953 protected constructor() {}
956 export function LDKCOption_HTLCClaimZ_ty_from_ptr(ptr: bigint): number {
957 if(!isWasmInitialized) {
958 throw new Error("initializeWasm() must be awaited first!");
960 const nativeResponseValue = wasm.TS_LDKCOption_HTLCClaimZ_ty_from_ptr(ptr);
961 return nativeResponseValue;
964 export function LDKCOption_HTLCClaimZ_Some_get_some(ptr: bigint): HTLCClaim {
965 if(!isWasmInitialized) {
966 throw new Error("initializeWasm() must be awaited first!");
968 const nativeResponseValue = wasm.TS_LDKCOption_HTLCClaimZ_Some_get_some(ptr);
969 return nativeResponseValue;
971 // void CResult_NoneNoneZ_get_ok(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
973 export function CResult_NoneNoneZ_get_ok(owner: bigint): void {
974 if(!isWasmInitialized) {
975 throw new Error("initializeWasm() must be awaited first!");
977 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_ok(owner);
978 // debug statements here
980 // void CResult_NoneNoneZ_get_err(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
982 export function CResult_NoneNoneZ_get_err(owner: bigint): void {
983 if(!isWasmInitialized) {
984 throw new Error("initializeWasm() must be awaited first!");
986 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_err(owner);
987 // debug statements here
990 export class LDKDecodeError {
991 protected constructor() {}
994 export function LDKDecodeError_ty_from_ptr(ptr: bigint): number {
995 if(!isWasmInitialized) {
996 throw new Error("initializeWasm() must be awaited first!");
998 const nativeResponseValue = wasm.TS_LDKDecodeError_ty_from_ptr(ptr);
999 return nativeResponseValue;
1002 export function LDKDecodeError_Io_get_io(ptr: bigint): IOError {
1003 if(!isWasmInitialized) {
1004 throw new Error("initializeWasm() must be awaited first!");
1006 const nativeResponseValue = wasm.TS_LDKDecodeError_Io_get_io(ptr);
1007 return nativeResponseValue;
1009 // struct LDKCounterpartyCommitmentSecrets CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
1011 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner: bigint): bigint {
1012 if(!isWasmInitialized) {
1013 throw new Error("initializeWasm() must be awaited first!");
1015 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner);
1016 return nativeResponseValue;
1018 // struct LDKDecodeError CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
1020 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner: bigint): bigint {
1021 if(!isWasmInitialized) {
1022 throw new Error("initializeWasm() must be awaited first!");
1024 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner);
1025 return nativeResponseValue;
1027 // struct LDKTxCreationKeys CResult_TxCreationKeysDecodeErrorZ_get_ok(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
1029 export function CResult_TxCreationKeysDecodeErrorZ_get_ok(owner: bigint): bigint {
1030 if(!isWasmInitialized) {
1031 throw new Error("initializeWasm() must be awaited first!");
1033 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_ok(owner);
1034 return nativeResponseValue;
1036 // struct LDKDecodeError CResult_TxCreationKeysDecodeErrorZ_get_err(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
1038 export function CResult_TxCreationKeysDecodeErrorZ_get_err(owner: bigint): bigint {
1039 if(!isWasmInitialized) {
1040 throw new Error("initializeWasm() must be awaited first!");
1042 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_err(owner);
1043 return nativeResponseValue;
1045 // struct LDKChannelPublicKeys CResult_ChannelPublicKeysDecodeErrorZ_get_ok(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
1047 export function CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner: bigint): bigint {
1048 if(!isWasmInitialized) {
1049 throw new Error("initializeWasm() must be awaited first!");
1051 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner);
1052 return nativeResponseValue;
1054 // struct LDKDecodeError CResult_ChannelPublicKeysDecodeErrorZ_get_err(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
1056 export function CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner: bigint): bigint {
1057 if(!isWasmInitialized) {
1058 throw new Error("initializeWasm() must be awaited first!");
1060 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner);
1061 return nativeResponseValue;
1064 export class LDKCOption_u32Z {
1065 protected constructor() {}
1068 export function LDKCOption_u32Z_ty_from_ptr(ptr: bigint): number {
1069 if(!isWasmInitialized) {
1070 throw new Error("initializeWasm() must be awaited first!");
1072 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_ty_from_ptr(ptr);
1073 return nativeResponseValue;
1076 export function LDKCOption_u32Z_Some_get_some(ptr: bigint): number {
1077 if(!isWasmInitialized) {
1078 throw new Error("initializeWasm() must be awaited first!");
1080 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_Some_get_some(ptr);
1081 return nativeResponseValue;
1083 // struct LDKHTLCOutputInCommitment CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
1085 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner: bigint): bigint {
1086 if(!isWasmInitialized) {
1087 throw new Error("initializeWasm() must be awaited first!");
1089 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner);
1090 return nativeResponseValue;
1092 // struct LDKDecodeError CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
1094 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner: bigint): bigint {
1095 if(!isWasmInitialized) {
1096 throw new Error("initializeWasm() must be awaited first!");
1098 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner);
1099 return nativeResponseValue;
1101 // struct LDKCounterpartyChannelTransactionParameters CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
1103 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
1104 if(!isWasmInitialized) {
1105 throw new Error("initializeWasm() must be awaited first!");
1107 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner);
1108 return nativeResponseValue;
1110 // struct LDKDecodeError CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
1112 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner: bigint): bigint {
1113 if(!isWasmInitialized) {
1114 throw new Error("initializeWasm() must be awaited first!");
1116 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner);
1117 return nativeResponseValue;
1119 // struct LDKChannelTransactionParameters CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
1121 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
1122 if(!isWasmInitialized) {
1123 throw new Error("initializeWasm() must be awaited first!");
1125 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner);
1126 return nativeResponseValue;
1128 // struct LDKDecodeError CResult_ChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
1130 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner: bigint): bigint {
1131 if(!isWasmInitialized) {
1132 throw new Error("initializeWasm() must be awaited first!");
1134 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner);
1135 return nativeResponseValue;
1137 // struct LDKHolderCommitmentTransaction CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
1139 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
1140 if(!isWasmInitialized) {
1141 throw new Error("initializeWasm() must be awaited first!");
1143 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner);
1144 return nativeResponseValue;
1146 // struct LDKDecodeError CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
1148 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
1149 if(!isWasmInitialized) {
1150 throw new Error("initializeWasm() must be awaited first!");
1152 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner);
1153 return nativeResponseValue;
1155 // struct LDKBuiltCommitmentTransaction CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
1157 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
1158 if(!isWasmInitialized) {
1159 throw new Error("initializeWasm() must be awaited first!");
1161 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner);
1162 return nativeResponseValue;
1164 // struct LDKDecodeError CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
1166 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
1167 if(!isWasmInitialized) {
1168 throw new Error("initializeWasm() must be awaited first!");
1170 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner);
1171 return nativeResponseValue;
1173 // struct LDKTrustedClosingTransaction CResult_TrustedClosingTransactionNoneZ_get_ok(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
1175 export function CResult_TrustedClosingTransactionNoneZ_get_ok(owner: bigint): bigint {
1176 if(!isWasmInitialized) {
1177 throw new Error("initializeWasm() must be awaited first!");
1179 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_ok(owner);
1180 return nativeResponseValue;
1182 // void CResult_TrustedClosingTransactionNoneZ_get_err(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
1184 export function CResult_TrustedClosingTransactionNoneZ_get_err(owner: bigint): void {
1185 if(!isWasmInitialized) {
1186 throw new Error("initializeWasm() must be awaited first!");
1188 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_err(owner);
1189 // debug statements here
1191 // struct LDKCommitmentTransaction CResult_CommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
1193 export function CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
1194 if(!isWasmInitialized) {
1195 throw new Error("initializeWasm() must be awaited first!");
1197 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner);
1198 return nativeResponseValue;
1200 // struct LDKDecodeError CResult_CommitmentTransactionDecodeErrorZ_get_err(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
1202 export function CResult_CommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
1203 if(!isWasmInitialized) {
1204 throw new Error("initializeWasm() must be awaited first!");
1206 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_err(owner);
1207 return nativeResponseValue;
1209 // struct LDKTrustedCommitmentTransaction CResult_TrustedCommitmentTransactionNoneZ_get_ok(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
1211 export function CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner: bigint): bigint {
1212 if(!isWasmInitialized) {
1213 throw new Error("initializeWasm() must be awaited first!");
1215 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner);
1216 return nativeResponseValue;
1218 // void CResult_TrustedCommitmentTransactionNoneZ_get_err(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
1220 export function CResult_TrustedCommitmentTransactionNoneZ_get_err(owner: bigint): void {
1221 if(!isWasmInitialized) {
1222 throw new Error("initializeWasm() must be awaited first!");
1224 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_err(owner);
1225 // debug statements here
1227 // struct LDKCVec_SignatureZ CResult_CVec_SignatureZNoneZ_get_ok(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
1229 export function CResult_CVec_SignatureZNoneZ_get_ok(owner: bigint): number {
1230 if(!isWasmInitialized) {
1231 throw new Error("initializeWasm() must be awaited first!");
1233 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_ok(owner);
1234 return nativeResponseValue;
1236 // void CResult_CVec_SignatureZNoneZ_get_err(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
1238 export function CResult_CVec_SignatureZNoneZ_get_err(owner: bigint): void {
1239 if(!isWasmInitialized) {
1240 throw new Error("initializeWasm() must be awaited first!");
1242 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_err(owner);
1243 // debug statements here
1245 // struct LDKShutdownScript CResult_ShutdownScriptDecodeErrorZ_get_ok(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
1247 export function CResult_ShutdownScriptDecodeErrorZ_get_ok(owner: bigint): bigint {
1248 if(!isWasmInitialized) {
1249 throw new Error("initializeWasm() must be awaited first!");
1251 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_ok(owner);
1252 return nativeResponseValue;
1254 // struct LDKDecodeError CResult_ShutdownScriptDecodeErrorZ_get_err(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
1256 export function CResult_ShutdownScriptDecodeErrorZ_get_err(owner: bigint): bigint {
1257 if(!isWasmInitialized) {
1258 throw new Error("initializeWasm() must be awaited first!");
1260 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_err(owner);
1261 return nativeResponseValue;
1263 // struct LDKShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
1265 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner: bigint): bigint {
1266 if(!isWasmInitialized) {
1267 throw new Error("initializeWasm() must be awaited first!");
1269 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner);
1270 return nativeResponseValue;
1272 // struct LDKInvalidShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
1274 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner: bigint): bigint {
1275 if(!isWasmInitialized) {
1276 throw new Error("initializeWasm() must be awaited first!");
1278 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner);
1279 return nativeResponseValue;
1281 // struct LDKBlindedPath CResult_BlindedPathNoneZ_get_ok(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner);
1283 export function CResult_BlindedPathNoneZ_get_ok(owner: bigint): bigint {
1284 if(!isWasmInitialized) {
1285 throw new Error("initializeWasm() must be awaited first!");
1287 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_get_ok(owner);
1288 return nativeResponseValue;
1290 // void CResult_BlindedPathNoneZ_get_err(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner);
1292 export function CResult_BlindedPathNoneZ_get_err(owner: bigint): void {
1293 if(!isWasmInitialized) {
1294 throw new Error("initializeWasm() must be awaited first!");
1296 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_get_err(owner);
1297 // debug statements here
1299 // struct LDKBlindedPath CResult_BlindedPathDecodeErrorZ_get_ok(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner);
1301 export function CResult_BlindedPathDecodeErrorZ_get_ok(owner: bigint): bigint {
1302 if(!isWasmInitialized) {
1303 throw new Error("initializeWasm() must be awaited first!");
1305 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_get_ok(owner);
1306 return nativeResponseValue;
1308 // struct LDKDecodeError CResult_BlindedPathDecodeErrorZ_get_err(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner);
1310 export function CResult_BlindedPathDecodeErrorZ_get_err(owner: bigint): bigint {
1311 if(!isWasmInitialized) {
1312 throw new Error("initializeWasm() must be awaited first!");
1314 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_get_err(owner);
1315 return nativeResponseValue;
1317 // struct LDKBlindedHop CResult_BlindedHopDecodeErrorZ_get_ok(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner);
1319 export function CResult_BlindedHopDecodeErrorZ_get_ok(owner: bigint): bigint {
1320 if(!isWasmInitialized) {
1321 throw new Error("initializeWasm() must be awaited first!");
1323 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_get_ok(owner);
1324 return nativeResponseValue;
1326 // struct LDKDecodeError CResult_BlindedHopDecodeErrorZ_get_err(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner);
1328 export function CResult_BlindedHopDecodeErrorZ_get_err(owner: bigint): bigint {
1329 if(!isWasmInitialized) {
1330 throw new Error("initializeWasm() must be awaited first!");
1332 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_get_err(owner);
1333 return nativeResponseValue;
1335 // struct LDKRoute CResult_RouteLightningErrorZ_get_ok(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
1337 export function CResult_RouteLightningErrorZ_get_ok(owner: bigint): bigint {
1338 if(!isWasmInitialized) {
1339 throw new Error("initializeWasm() must be awaited first!");
1341 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_ok(owner);
1342 return nativeResponseValue;
1344 // struct LDKLightningError CResult_RouteLightningErrorZ_get_err(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
1346 export function CResult_RouteLightningErrorZ_get_err(owner: bigint): bigint {
1347 if(!isWasmInitialized) {
1348 throw new Error("initializeWasm() must be awaited first!");
1350 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_err(owner);
1351 return nativeResponseValue;
1354 export class LDKCOption_u64Z {
1355 protected constructor() {}
1358 export function LDKCOption_u64Z_ty_from_ptr(ptr: bigint): number {
1359 if(!isWasmInitialized) {
1360 throw new Error("initializeWasm() must be awaited first!");
1362 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_ty_from_ptr(ptr);
1363 return nativeResponseValue;
1366 export function LDKCOption_u64Z_Some_get_some(ptr: bigint): bigint {
1367 if(!isWasmInitialized) {
1368 throw new Error("initializeWasm() must be awaited first!");
1370 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_Some_get_some(ptr);
1371 return nativeResponseValue;
1373 // struct LDKInFlightHtlcs CResult_InFlightHtlcsDecodeErrorZ_get_ok(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner);
1375 export function CResult_InFlightHtlcsDecodeErrorZ_get_ok(owner: bigint): bigint {
1376 if(!isWasmInitialized) {
1377 throw new Error("initializeWasm() must be awaited first!");
1379 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_get_ok(owner);
1380 return nativeResponseValue;
1382 // struct LDKDecodeError CResult_InFlightHtlcsDecodeErrorZ_get_err(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner);
1384 export function CResult_InFlightHtlcsDecodeErrorZ_get_err(owner: bigint): bigint {
1385 if(!isWasmInitialized) {
1386 throw new Error("initializeWasm() must be awaited first!");
1388 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_get_err(owner);
1389 return nativeResponseValue;
1391 // struct LDKRouteHop CResult_RouteHopDecodeErrorZ_get_ok(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
1393 export function CResult_RouteHopDecodeErrorZ_get_ok(owner: bigint): bigint {
1394 if(!isWasmInitialized) {
1395 throw new Error("initializeWasm() must be awaited first!");
1397 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_ok(owner);
1398 return nativeResponseValue;
1400 // struct LDKDecodeError CResult_RouteHopDecodeErrorZ_get_err(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
1402 export function CResult_RouteHopDecodeErrorZ_get_err(owner: bigint): bigint {
1403 if(!isWasmInitialized) {
1404 throw new Error("initializeWasm() must be awaited first!");
1406 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_err(owner);
1407 return nativeResponseValue;
1409 // struct LDKRoute CResult_RouteDecodeErrorZ_get_ok(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
1411 export function CResult_RouteDecodeErrorZ_get_ok(owner: bigint): bigint {
1412 if(!isWasmInitialized) {
1413 throw new Error("initializeWasm() must be awaited first!");
1415 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_ok(owner);
1416 return nativeResponseValue;
1418 // struct LDKDecodeError CResult_RouteDecodeErrorZ_get_err(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
1420 export function CResult_RouteDecodeErrorZ_get_err(owner: bigint): bigint {
1421 if(!isWasmInitialized) {
1422 throw new Error("initializeWasm() must be awaited first!");
1424 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_err(owner);
1425 return nativeResponseValue;
1427 // struct LDKRouteParameters CResult_RouteParametersDecodeErrorZ_get_ok(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
1429 export function CResult_RouteParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
1430 if(!isWasmInitialized) {
1431 throw new Error("initializeWasm() must be awaited first!");
1433 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_ok(owner);
1434 return nativeResponseValue;
1436 // struct LDKDecodeError CResult_RouteParametersDecodeErrorZ_get_err(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
1438 export function CResult_RouteParametersDecodeErrorZ_get_err(owner: bigint): bigint {
1439 if(!isWasmInitialized) {
1440 throw new Error("initializeWasm() must be awaited first!");
1442 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_err(owner);
1443 return nativeResponseValue;
1445 // struct LDKPaymentParameters CResult_PaymentParametersDecodeErrorZ_get_ok(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
1447 export function CResult_PaymentParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
1448 if(!isWasmInitialized) {
1449 throw new Error("initializeWasm() must be awaited first!");
1451 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_ok(owner);
1452 return nativeResponseValue;
1454 // struct LDKDecodeError CResult_PaymentParametersDecodeErrorZ_get_err(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
1456 export function CResult_PaymentParametersDecodeErrorZ_get_err(owner: bigint): bigint {
1457 if(!isWasmInitialized) {
1458 throw new Error("initializeWasm() must be awaited first!");
1460 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_err(owner);
1461 return nativeResponseValue;
1463 // struct LDKRouteHint CResult_RouteHintDecodeErrorZ_get_ok(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
1465 export function CResult_RouteHintDecodeErrorZ_get_ok(owner: bigint): bigint {
1466 if(!isWasmInitialized) {
1467 throw new Error("initializeWasm() must be awaited first!");
1469 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_ok(owner);
1470 return nativeResponseValue;
1472 // struct LDKDecodeError CResult_RouteHintDecodeErrorZ_get_err(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
1474 export function CResult_RouteHintDecodeErrorZ_get_err(owner: bigint): bigint {
1475 if(!isWasmInitialized) {
1476 throw new Error("initializeWasm() must be awaited first!");
1478 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_err(owner);
1479 return nativeResponseValue;
1481 // struct LDKRouteHintHop CResult_RouteHintHopDecodeErrorZ_get_ok(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
1483 export function CResult_RouteHintHopDecodeErrorZ_get_ok(owner: bigint): bigint {
1484 if(!isWasmInitialized) {
1485 throw new Error("initializeWasm() must be awaited first!");
1487 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_ok(owner);
1488 return nativeResponseValue;
1490 // struct LDKDecodeError CResult_RouteHintHopDecodeErrorZ_get_err(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
1492 export function CResult_RouteHintHopDecodeErrorZ_get_err(owner: bigint): bigint {
1493 if(!isWasmInitialized) {
1494 throw new Error("initializeWasm() must be awaited first!");
1496 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_err(owner);
1497 return nativeResponseValue;
1500 export class LDKPaymentPurpose {
1501 protected constructor() {}
1504 export function LDKPaymentPurpose_ty_from_ptr(ptr: bigint): number {
1505 if(!isWasmInitialized) {
1506 throw new Error("initializeWasm() must be awaited first!");
1508 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_ty_from_ptr(ptr);
1509 return nativeResponseValue;
1512 export function LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr: bigint): number {
1513 if(!isWasmInitialized) {
1514 throw new Error("initializeWasm() must be awaited first!");
1516 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr);
1517 return nativeResponseValue;
1520 export function LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr: bigint): number {
1521 if(!isWasmInitialized) {
1522 throw new Error("initializeWasm() must be awaited first!");
1524 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr);
1525 return nativeResponseValue;
1528 export function LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr: bigint): number {
1529 if(!isWasmInitialized) {
1530 throw new Error("initializeWasm() must be awaited first!");
1532 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr);
1533 return nativeResponseValue;
1535 // struct LDKPaymentPurpose CResult_PaymentPurposeDecodeErrorZ_get_ok(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
1537 export function CResult_PaymentPurposeDecodeErrorZ_get_ok(owner: bigint): bigint {
1538 if(!isWasmInitialized) {
1539 throw new Error("initializeWasm() must be awaited first!");
1541 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_ok(owner);
1542 return nativeResponseValue;
1544 // struct LDKDecodeError CResult_PaymentPurposeDecodeErrorZ_get_err(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
1546 export function CResult_PaymentPurposeDecodeErrorZ_get_err(owner: bigint): bigint {
1547 if(!isWasmInitialized) {
1548 throw new Error("initializeWasm() must be awaited first!");
1550 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_err(owner);
1551 return nativeResponseValue;
1554 export class LDKNetworkUpdate {
1555 protected constructor() {}
1558 export function LDKNetworkUpdate_ty_from_ptr(ptr: bigint): number {
1559 if(!isWasmInitialized) {
1560 throw new Error("initializeWasm() must be awaited first!");
1562 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ty_from_ptr(ptr);
1563 return nativeResponseValue;
1566 export function LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr: bigint): bigint {
1567 if(!isWasmInitialized) {
1568 throw new Error("initializeWasm() must be awaited first!");
1570 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr);
1571 return nativeResponseValue;
1574 export function LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr: bigint): bigint {
1575 if(!isWasmInitialized) {
1576 throw new Error("initializeWasm() must be awaited first!");
1578 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr);
1579 return nativeResponseValue;
1582 export function LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr: bigint): boolean {
1583 if(!isWasmInitialized) {
1584 throw new Error("initializeWasm() must be awaited first!");
1586 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr);
1587 return nativeResponseValue;
1590 export function LDKNetworkUpdate_NodeFailure_get_node_id(ptr: bigint): number {
1591 if(!isWasmInitialized) {
1592 throw new Error("initializeWasm() must be awaited first!");
1594 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_node_id(ptr);
1595 return nativeResponseValue;
1598 export function LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr: bigint): boolean {
1599 if(!isWasmInitialized) {
1600 throw new Error("initializeWasm() must be awaited first!");
1602 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr);
1603 return nativeResponseValue;
1606 export class LDKCOption_NetworkUpdateZ {
1607 protected constructor() {}
1610 export function LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr: bigint): number {
1611 if(!isWasmInitialized) {
1612 throw new Error("initializeWasm() must be awaited first!");
1614 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr);
1615 return nativeResponseValue;
1618 export function LDKCOption_NetworkUpdateZ_Some_get_some(ptr: bigint): bigint {
1619 if(!isWasmInitialized) {
1620 throw new Error("initializeWasm() must be awaited first!");
1622 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_Some_get_some(ptr);
1623 return nativeResponseValue;
1626 export class LDKPathFailure {
1627 protected constructor() {}
1630 export function LDKPathFailure_ty_from_ptr(ptr: bigint): number {
1631 if(!isWasmInitialized) {
1632 throw new Error("initializeWasm() must be awaited first!");
1634 const nativeResponseValue = wasm.TS_LDKPathFailure_ty_from_ptr(ptr);
1635 return nativeResponseValue;
1638 export function LDKPathFailure_InitialSend_get_err(ptr: bigint): bigint {
1639 if(!isWasmInitialized) {
1640 throw new Error("initializeWasm() must be awaited first!");
1642 const nativeResponseValue = wasm.TS_LDKPathFailure_InitialSend_get_err(ptr);
1643 return nativeResponseValue;
1646 export function LDKPathFailure_OnPath_get_network_update(ptr: bigint): bigint {
1647 if(!isWasmInitialized) {
1648 throw new Error("initializeWasm() must be awaited first!");
1650 const nativeResponseValue = wasm.TS_LDKPathFailure_OnPath_get_network_update(ptr);
1651 return nativeResponseValue;
1654 export class LDKCOption_PathFailureZ {
1655 protected constructor() {}
1658 export function LDKCOption_PathFailureZ_ty_from_ptr(ptr: bigint): number {
1659 if(!isWasmInitialized) {
1660 throw new Error("initializeWasm() must be awaited first!");
1662 const nativeResponseValue = wasm.TS_LDKCOption_PathFailureZ_ty_from_ptr(ptr);
1663 return nativeResponseValue;
1666 export function LDKCOption_PathFailureZ_Some_get_some(ptr: bigint): bigint {
1667 if(!isWasmInitialized) {
1668 throw new Error("initializeWasm() must be awaited first!");
1670 const nativeResponseValue = wasm.TS_LDKCOption_PathFailureZ_Some_get_some(ptr);
1671 return nativeResponseValue;
1673 // struct LDKCOption_PathFailureZ CResult_COption_PathFailureZDecodeErrorZ_get_ok(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR owner);
1675 export function CResult_COption_PathFailureZDecodeErrorZ_get_ok(owner: bigint): bigint {
1676 if(!isWasmInitialized) {
1677 throw new Error("initializeWasm() must be awaited first!");
1679 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_get_ok(owner);
1680 return nativeResponseValue;
1682 // struct LDKDecodeError CResult_COption_PathFailureZDecodeErrorZ_get_err(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR owner);
1684 export function CResult_COption_PathFailureZDecodeErrorZ_get_err(owner: bigint): bigint {
1685 if(!isWasmInitialized) {
1686 throw new Error("initializeWasm() must be awaited first!");
1688 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_get_err(owner);
1689 return nativeResponseValue;
1692 export class LDKClosureReason {
1693 protected constructor() {}
1696 export function LDKClosureReason_ty_from_ptr(ptr: bigint): number {
1697 if(!isWasmInitialized) {
1698 throw new Error("initializeWasm() must be awaited first!");
1700 const nativeResponseValue = wasm.TS_LDKClosureReason_ty_from_ptr(ptr);
1701 return nativeResponseValue;
1704 export function LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr: bigint): number {
1705 if(!isWasmInitialized) {
1706 throw new Error("initializeWasm() must be awaited first!");
1708 const nativeResponseValue = wasm.TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr);
1709 return nativeResponseValue;
1712 export function LDKClosureReason_ProcessingError_get_err(ptr: bigint): number {
1713 if(!isWasmInitialized) {
1714 throw new Error("initializeWasm() must be awaited first!");
1716 const nativeResponseValue = wasm.TS_LDKClosureReason_ProcessingError_get_err(ptr);
1717 return nativeResponseValue;
1720 export class LDKCOption_ClosureReasonZ {
1721 protected constructor() {}
1724 export function LDKCOption_ClosureReasonZ_ty_from_ptr(ptr: bigint): number {
1725 if(!isWasmInitialized) {
1726 throw new Error("initializeWasm() must be awaited first!");
1728 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_ty_from_ptr(ptr);
1729 return nativeResponseValue;
1732 export function LDKCOption_ClosureReasonZ_Some_get_some(ptr: bigint): bigint {
1733 if(!isWasmInitialized) {
1734 throw new Error("initializeWasm() must be awaited first!");
1736 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_Some_get_some(ptr);
1737 return nativeResponseValue;
1739 // struct LDKCOption_ClosureReasonZ CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
1741 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner: bigint): bigint {
1742 if(!isWasmInitialized) {
1743 throw new Error("initializeWasm() must be awaited first!");
1745 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner);
1746 return nativeResponseValue;
1748 // struct LDKDecodeError CResult_COption_ClosureReasonZDecodeErrorZ_get_err(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
1750 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner: bigint): bigint {
1751 if(!isWasmInitialized) {
1752 throw new Error("initializeWasm() must be awaited first!");
1754 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner);
1755 return nativeResponseValue;
1758 export class LDKHTLCDestination {
1759 protected constructor() {}
1762 export function LDKHTLCDestination_ty_from_ptr(ptr: bigint): number {
1763 if(!isWasmInitialized) {
1764 throw new Error("initializeWasm() must be awaited first!");
1766 const nativeResponseValue = wasm.TS_LDKHTLCDestination_ty_from_ptr(ptr);
1767 return nativeResponseValue;
1770 export function LDKHTLCDestination_NextHopChannel_get_node_id(ptr: bigint): number {
1771 if(!isWasmInitialized) {
1772 throw new Error("initializeWasm() must be awaited first!");
1774 const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_node_id(ptr);
1775 return nativeResponseValue;
1778 export function LDKHTLCDestination_NextHopChannel_get_channel_id(ptr: bigint): number {
1779 if(!isWasmInitialized) {
1780 throw new Error("initializeWasm() must be awaited first!");
1782 const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_channel_id(ptr);
1783 return nativeResponseValue;
1786 export function LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr: bigint): bigint {
1787 if(!isWasmInitialized) {
1788 throw new Error("initializeWasm() must be awaited first!");
1790 const nativeResponseValue = wasm.TS_LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr);
1791 return nativeResponseValue;
1794 export function LDKHTLCDestination_InvalidForward_get_requested_forward_scid(ptr: bigint): bigint {
1795 if(!isWasmInitialized) {
1796 throw new Error("initializeWasm() must be awaited first!");
1798 const nativeResponseValue = wasm.TS_LDKHTLCDestination_InvalidForward_get_requested_forward_scid(ptr);
1799 return nativeResponseValue;
1802 export function LDKHTLCDestination_FailedPayment_get_payment_hash(ptr: bigint): number {
1803 if(!isWasmInitialized) {
1804 throw new Error("initializeWasm() must be awaited first!");
1806 const nativeResponseValue = wasm.TS_LDKHTLCDestination_FailedPayment_get_payment_hash(ptr);
1807 return nativeResponseValue;
1810 export class LDKCOption_HTLCDestinationZ {
1811 protected constructor() {}
1814 export function LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr: bigint): number {
1815 if(!isWasmInitialized) {
1816 throw new Error("initializeWasm() must be awaited first!");
1818 const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr);
1819 return nativeResponseValue;
1822 export function LDKCOption_HTLCDestinationZ_Some_get_some(ptr: bigint): bigint {
1823 if(!isWasmInitialized) {
1824 throw new Error("initializeWasm() must be awaited first!");
1826 const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_Some_get_some(ptr);
1827 return nativeResponseValue;
1829 // struct LDKCOption_HTLCDestinationZ CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
1831 export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner: bigint): bigint {
1832 if(!isWasmInitialized) {
1833 throw new Error("initializeWasm() must be awaited first!");
1835 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner);
1836 return nativeResponseValue;
1838 // struct LDKDecodeError CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
1840 export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner: bigint): bigint {
1841 if(!isWasmInitialized) {
1842 throw new Error("initializeWasm() must be awaited first!");
1844 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner);
1845 return nativeResponseValue;
1848 export class LDKCOption_u128Z {
1849 protected constructor() {}
1852 export function LDKCOption_u128Z_ty_from_ptr(ptr: bigint): number {
1853 if(!isWasmInitialized) {
1854 throw new Error("initializeWasm() must be awaited first!");
1856 const nativeResponseValue = wasm.TS_LDKCOption_u128Z_ty_from_ptr(ptr);
1857 return nativeResponseValue;
1860 export function LDKCOption_u128Z_Some_get_some(ptr: bigint): number {
1861 if(!isWasmInitialized) {
1862 throw new Error("initializeWasm() must be awaited first!");
1864 const nativeResponseValue = wasm.TS_LDKCOption_u128Z_Some_get_some(ptr);
1865 return nativeResponseValue;
1868 export class LDKSpendableOutputDescriptor {
1869 protected constructor() {}
1872 export function LDKSpendableOutputDescriptor_ty_from_ptr(ptr: bigint): number {
1873 if(!isWasmInitialized) {
1874 throw new Error("initializeWasm() must be awaited first!");
1876 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_ty_from_ptr(ptr);
1877 return nativeResponseValue;
1880 export function LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr: bigint): bigint {
1881 if(!isWasmInitialized) {
1882 throw new Error("initializeWasm() must be awaited first!");
1884 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr);
1885 return nativeResponseValue;
1888 export function LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr: bigint): bigint {
1889 if(!isWasmInitialized) {
1890 throw new Error("initializeWasm() must be awaited first!");
1892 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr);
1893 return nativeResponseValue;
1896 export function LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr: bigint): bigint {
1897 if(!isWasmInitialized) {
1898 throw new Error("initializeWasm() must be awaited first!");
1900 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr);
1901 return nativeResponseValue;
1904 export function LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr: bigint): bigint {
1905 if(!isWasmInitialized) {
1906 throw new Error("initializeWasm() must be awaited first!");
1908 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr);
1909 return nativeResponseValue;
1912 export class LDKEvent {
1913 protected constructor() {}
1916 export function LDKEvent_ty_from_ptr(ptr: bigint): number {
1917 if(!isWasmInitialized) {
1918 throw new Error("initializeWasm() must be awaited first!");
1920 const nativeResponseValue = wasm.TS_LDKEvent_ty_from_ptr(ptr);
1921 return nativeResponseValue;
1924 export function LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr: bigint): number {
1925 if(!isWasmInitialized) {
1926 throw new Error("initializeWasm() must be awaited first!");
1928 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr);
1929 return nativeResponseValue;
1932 export function LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr: bigint): number {
1933 if(!isWasmInitialized) {
1934 throw new Error("initializeWasm() must be awaited first!");
1936 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr);
1937 return nativeResponseValue;
1940 export function LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr: bigint): bigint {
1941 if(!isWasmInitialized) {
1942 throw new Error("initializeWasm() must be awaited first!");
1944 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr);
1945 return nativeResponseValue;
1948 export function LDKEvent_FundingGenerationReady_get_output_script(ptr: bigint): number {
1949 if(!isWasmInitialized) {
1950 throw new Error("initializeWasm() must be awaited first!");
1952 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_output_script(ptr);
1953 return nativeResponseValue;
1956 export function LDKEvent_FundingGenerationReady_get_user_channel_id(ptr: bigint): number {
1957 if(!isWasmInitialized) {
1958 throw new Error("initializeWasm() must be awaited first!");
1960 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_user_channel_id(ptr);
1961 return nativeResponseValue;
1964 export function LDKEvent_PaymentClaimable_get_receiver_node_id(ptr: bigint): number {
1965 if(!isWasmInitialized) {
1966 throw new Error("initializeWasm() must be awaited first!");
1968 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_receiver_node_id(ptr);
1969 return nativeResponseValue;
1972 export function LDKEvent_PaymentClaimable_get_payment_hash(ptr: bigint): number {
1973 if(!isWasmInitialized) {
1974 throw new Error("initializeWasm() must be awaited first!");
1976 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_payment_hash(ptr);
1977 return nativeResponseValue;
1980 export function LDKEvent_PaymentClaimable_get_amount_msat(ptr: bigint): bigint {
1981 if(!isWasmInitialized) {
1982 throw new Error("initializeWasm() must be awaited first!");
1984 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_amount_msat(ptr);
1985 return nativeResponseValue;
1988 export function LDKEvent_PaymentClaimable_get_purpose(ptr: bigint): bigint {
1989 if(!isWasmInitialized) {
1990 throw new Error("initializeWasm() must be awaited first!");
1992 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_purpose(ptr);
1993 return nativeResponseValue;
1996 export function LDKEvent_PaymentClaimable_get_via_channel_id(ptr: bigint): number {
1997 if(!isWasmInitialized) {
1998 throw new Error("initializeWasm() must be awaited first!");
2000 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_via_channel_id(ptr);
2001 return nativeResponseValue;
2004 export function LDKEvent_PaymentClaimable_get_via_user_channel_id(ptr: bigint): bigint {
2005 if(!isWasmInitialized) {
2006 throw new Error("initializeWasm() must be awaited first!");
2008 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_via_user_channel_id(ptr);
2009 return nativeResponseValue;
2012 export function LDKEvent_PaymentClaimed_get_receiver_node_id(ptr: bigint): number {
2013 if(!isWasmInitialized) {
2014 throw new Error("initializeWasm() must be awaited first!");
2016 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_receiver_node_id(ptr);
2017 return nativeResponseValue;
2020 export function LDKEvent_PaymentClaimed_get_payment_hash(ptr: bigint): number {
2021 if(!isWasmInitialized) {
2022 throw new Error("initializeWasm() must be awaited first!");
2024 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_payment_hash(ptr);
2025 return nativeResponseValue;
2028 export function LDKEvent_PaymentClaimed_get_amount_msat(ptr: bigint): bigint {
2029 if(!isWasmInitialized) {
2030 throw new Error("initializeWasm() must be awaited first!");
2032 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_amount_msat(ptr);
2033 return nativeResponseValue;
2036 export function LDKEvent_PaymentClaimed_get_purpose(ptr: bigint): bigint {
2037 if(!isWasmInitialized) {
2038 throw new Error("initializeWasm() must be awaited first!");
2040 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_purpose(ptr);
2041 return nativeResponseValue;
2044 export function LDKEvent_PaymentSent_get_payment_id(ptr: bigint): number {
2045 if(!isWasmInitialized) {
2046 throw new Error("initializeWasm() must be awaited first!");
2048 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_id(ptr);
2049 return nativeResponseValue;
2052 export function LDKEvent_PaymentSent_get_payment_preimage(ptr: bigint): number {
2053 if(!isWasmInitialized) {
2054 throw new Error("initializeWasm() must be awaited first!");
2056 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_preimage(ptr);
2057 return nativeResponseValue;
2060 export function LDKEvent_PaymentSent_get_payment_hash(ptr: bigint): number {
2061 if(!isWasmInitialized) {
2062 throw new Error("initializeWasm() must be awaited first!");
2064 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_hash(ptr);
2065 return nativeResponseValue;
2068 export function LDKEvent_PaymentSent_get_fee_paid_msat(ptr: bigint): bigint {
2069 if(!isWasmInitialized) {
2070 throw new Error("initializeWasm() must be awaited first!");
2072 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_fee_paid_msat(ptr);
2073 return nativeResponseValue;
2076 export function LDKEvent_PaymentFailed_get_payment_id(ptr: bigint): number {
2077 if(!isWasmInitialized) {
2078 throw new Error("initializeWasm() must be awaited first!");
2080 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_id(ptr);
2081 return nativeResponseValue;
2084 export function LDKEvent_PaymentFailed_get_payment_hash(ptr: bigint): number {
2085 if(!isWasmInitialized) {
2086 throw new Error("initializeWasm() must be awaited first!");
2088 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_hash(ptr);
2089 return nativeResponseValue;
2092 export function LDKEvent_PaymentPathSuccessful_get_payment_id(ptr: bigint): number {
2093 if(!isWasmInitialized) {
2094 throw new Error("initializeWasm() must be awaited first!");
2096 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_id(ptr);
2097 return nativeResponseValue;
2100 export function LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr: bigint): number {
2101 if(!isWasmInitialized) {
2102 throw new Error("initializeWasm() must be awaited first!");
2104 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr);
2105 return nativeResponseValue;
2108 export function LDKEvent_PaymentPathSuccessful_get_path(ptr: bigint): number {
2109 if(!isWasmInitialized) {
2110 throw new Error("initializeWasm() must be awaited first!");
2112 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_path(ptr);
2113 return nativeResponseValue;
2116 export function LDKEvent_PaymentPathFailed_get_payment_id(ptr: bigint): number {
2117 if(!isWasmInitialized) {
2118 throw new Error("initializeWasm() must be awaited first!");
2120 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_id(ptr);
2121 return nativeResponseValue;
2124 export function LDKEvent_PaymentPathFailed_get_payment_hash(ptr: bigint): number {
2125 if(!isWasmInitialized) {
2126 throw new Error("initializeWasm() must be awaited first!");
2128 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_hash(ptr);
2129 return nativeResponseValue;
2132 export function LDKEvent_PaymentPathFailed_get_payment_failed_permanently(ptr: bigint): boolean {
2133 if(!isWasmInitialized) {
2134 throw new Error("initializeWasm() must be awaited first!");
2136 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_failed_permanently(ptr);
2137 return nativeResponseValue;
2140 export function LDKEvent_PaymentPathFailed_get_failure(ptr: bigint): bigint {
2141 if(!isWasmInitialized) {
2142 throw new Error("initializeWasm() must be awaited first!");
2144 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_failure(ptr);
2145 return nativeResponseValue;
2148 export function LDKEvent_PaymentPathFailed_get_path(ptr: bigint): number {
2149 if(!isWasmInitialized) {
2150 throw new Error("initializeWasm() must be awaited first!");
2152 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_path(ptr);
2153 return nativeResponseValue;
2156 export function LDKEvent_PaymentPathFailed_get_short_channel_id(ptr: bigint): bigint {
2157 if(!isWasmInitialized) {
2158 throw new Error("initializeWasm() must be awaited first!");
2160 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_short_channel_id(ptr);
2161 return nativeResponseValue;
2164 export function LDKEvent_PaymentPathFailed_get_retry(ptr: bigint): bigint {
2165 if(!isWasmInitialized) {
2166 throw new Error("initializeWasm() must be awaited first!");
2168 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_retry(ptr);
2169 return nativeResponseValue;
2172 export function LDKEvent_ProbeSuccessful_get_payment_id(ptr: bigint): number {
2173 if(!isWasmInitialized) {
2174 throw new Error("initializeWasm() must be awaited first!");
2176 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_payment_id(ptr);
2177 return nativeResponseValue;
2180 export function LDKEvent_ProbeSuccessful_get_payment_hash(ptr: bigint): number {
2181 if(!isWasmInitialized) {
2182 throw new Error("initializeWasm() must be awaited first!");
2184 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_payment_hash(ptr);
2185 return nativeResponseValue;
2188 export function LDKEvent_ProbeSuccessful_get_path(ptr: bigint): number {
2189 if(!isWasmInitialized) {
2190 throw new Error("initializeWasm() must be awaited first!");
2192 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_path(ptr);
2193 return nativeResponseValue;
2196 export function LDKEvent_ProbeFailed_get_payment_id(ptr: bigint): number {
2197 if(!isWasmInitialized) {
2198 throw new Error("initializeWasm() must be awaited first!");
2200 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_payment_id(ptr);
2201 return nativeResponseValue;
2204 export function LDKEvent_ProbeFailed_get_payment_hash(ptr: bigint): number {
2205 if(!isWasmInitialized) {
2206 throw new Error("initializeWasm() must be awaited first!");
2208 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_payment_hash(ptr);
2209 return nativeResponseValue;
2212 export function LDKEvent_ProbeFailed_get_path(ptr: bigint): number {
2213 if(!isWasmInitialized) {
2214 throw new Error("initializeWasm() must be awaited first!");
2216 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_path(ptr);
2217 return nativeResponseValue;
2220 export function LDKEvent_ProbeFailed_get_short_channel_id(ptr: bigint): bigint {
2221 if(!isWasmInitialized) {
2222 throw new Error("initializeWasm() must be awaited first!");
2224 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_short_channel_id(ptr);
2225 return nativeResponseValue;
2228 export function LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr: bigint): bigint {
2229 if(!isWasmInitialized) {
2230 throw new Error("initializeWasm() must be awaited first!");
2232 const nativeResponseValue = wasm.TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr);
2233 return nativeResponseValue;
2236 export function LDKEvent_HTLCIntercepted_get_intercept_id(ptr: bigint): number {
2237 if(!isWasmInitialized) {
2238 throw new Error("initializeWasm() must be awaited first!");
2240 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_intercept_id(ptr);
2241 return nativeResponseValue;
2244 export function LDKEvent_HTLCIntercepted_get_requested_next_hop_scid(ptr: bigint): bigint {
2245 if(!isWasmInitialized) {
2246 throw new Error("initializeWasm() must be awaited first!");
2248 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_requested_next_hop_scid(ptr);
2249 return nativeResponseValue;
2252 export function LDKEvent_HTLCIntercepted_get_payment_hash(ptr: bigint): number {
2253 if(!isWasmInitialized) {
2254 throw new Error("initializeWasm() must be awaited first!");
2256 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_payment_hash(ptr);
2257 return nativeResponseValue;
2260 export function LDKEvent_HTLCIntercepted_get_inbound_amount_msat(ptr: bigint): bigint {
2261 if(!isWasmInitialized) {
2262 throw new Error("initializeWasm() must be awaited first!");
2264 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_inbound_amount_msat(ptr);
2265 return nativeResponseValue;
2268 export function LDKEvent_HTLCIntercepted_get_expected_outbound_amount_msat(ptr: bigint): bigint {
2269 if(!isWasmInitialized) {
2270 throw new Error("initializeWasm() must be awaited first!");
2272 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_expected_outbound_amount_msat(ptr);
2273 return nativeResponseValue;
2276 export function LDKEvent_SpendableOutputs_get_outputs(ptr: bigint): number {
2277 if(!isWasmInitialized) {
2278 throw new Error("initializeWasm() must be awaited first!");
2280 const nativeResponseValue = wasm.TS_LDKEvent_SpendableOutputs_get_outputs(ptr);
2281 return nativeResponseValue;
2284 export function LDKEvent_PaymentForwarded_get_prev_channel_id(ptr: bigint): number {
2285 if(!isWasmInitialized) {
2286 throw new Error("initializeWasm() must be awaited first!");
2288 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_prev_channel_id(ptr);
2289 return nativeResponseValue;
2292 export function LDKEvent_PaymentForwarded_get_next_channel_id(ptr: bigint): number {
2293 if(!isWasmInitialized) {
2294 throw new Error("initializeWasm() must be awaited first!");
2296 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_next_channel_id(ptr);
2297 return nativeResponseValue;
2300 export function LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr: bigint): bigint {
2301 if(!isWasmInitialized) {
2302 throw new Error("initializeWasm() must be awaited first!");
2304 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr);
2305 return nativeResponseValue;
2308 export function LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr: bigint): boolean {
2309 if(!isWasmInitialized) {
2310 throw new Error("initializeWasm() must be awaited first!");
2312 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr);
2313 return nativeResponseValue;
2316 export function LDKEvent_ChannelReady_get_channel_id(ptr: bigint): number {
2317 if(!isWasmInitialized) {
2318 throw new Error("initializeWasm() must be awaited first!");
2320 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_channel_id(ptr);
2321 return nativeResponseValue;
2324 export function LDKEvent_ChannelReady_get_user_channel_id(ptr: bigint): number {
2325 if(!isWasmInitialized) {
2326 throw new Error("initializeWasm() must be awaited first!");
2328 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_user_channel_id(ptr);
2329 return nativeResponseValue;
2332 export function LDKEvent_ChannelReady_get_counterparty_node_id(ptr: bigint): number {
2333 if(!isWasmInitialized) {
2334 throw new Error("initializeWasm() must be awaited first!");
2336 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_counterparty_node_id(ptr);
2337 return nativeResponseValue;
2340 export function LDKEvent_ChannelReady_get_channel_type(ptr: bigint): bigint {
2341 if(!isWasmInitialized) {
2342 throw new Error("initializeWasm() must be awaited first!");
2344 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_channel_type(ptr);
2345 return nativeResponseValue;
2348 export function LDKEvent_ChannelClosed_get_channel_id(ptr: bigint): number {
2349 if(!isWasmInitialized) {
2350 throw new Error("initializeWasm() must be awaited first!");
2352 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_channel_id(ptr);
2353 return nativeResponseValue;
2356 export function LDKEvent_ChannelClosed_get_user_channel_id(ptr: bigint): number {
2357 if(!isWasmInitialized) {
2358 throw new Error("initializeWasm() must be awaited first!");
2360 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_user_channel_id(ptr);
2361 return nativeResponseValue;
2364 export function LDKEvent_ChannelClosed_get_reason(ptr: bigint): bigint {
2365 if(!isWasmInitialized) {
2366 throw new Error("initializeWasm() must be awaited first!");
2368 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_reason(ptr);
2369 return nativeResponseValue;
2372 export function LDKEvent_DiscardFunding_get_channel_id(ptr: bigint): number {
2373 if(!isWasmInitialized) {
2374 throw new Error("initializeWasm() must be awaited first!");
2376 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_channel_id(ptr);
2377 return nativeResponseValue;
2380 export function LDKEvent_DiscardFunding_get_transaction(ptr: bigint): number {
2381 if(!isWasmInitialized) {
2382 throw new Error("initializeWasm() must be awaited first!");
2384 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_transaction(ptr);
2385 return nativeResponseValue;
2388 export function LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr: bigint): number {
2389 if(!isWasmInitialized) {
2390 throw new Error("initializeWasm() must be awaited first!");
2392 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr);
2393 return nativeResponseValue;
2396 export function LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr: bigint): number {
2397 if(!isWasmInitialized) {
2398 throw new Error("initializeWasm() must be awaited first!");
2400 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr);
2401 return nativeResponseValue;
2404 export function LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr: bigint): bigint {
2405 if(!isWasmInitialized) {
2406 throw new Error("initializeWasm() must be awaited first!");
2408 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr);
2409 return nativeResponseValue;
2412 export function LDKEvent_OpenChannelRequest_get_push_msat(ptr: bigint): bigint {
2413 if(!isWasmInitialized) {
2414 throw new Error("initializeWasm() must be awaited first!");
2416 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_push_msat(ptr);
2417 return nativeResponseValue;
2420 export function LDKEvent_OpenChannelRequest_get_channel_type(ptr: bigint): bigint {
2421 if(!isWasmInitialized) {
2422 throw new Error("initializeWasm() must be awaited first!");
2424 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_channel_type(ptr);
2425 return nativeResponseValue;
2428 export function LDKEvent_HTLCHandlingFailed_get_prev_channel_id(ptr: bigint): number {
2429 if(!isWasmInitialized) {
2430 throw new Error("initializeWasm() must be awaited first!");
2432 const nativeResponseValue = wasm.TS_LDKEvent_HTLCHandlingFailed_get_prev_channel_id(ptr);
2433 return nativeResponseValue;
2436 export function LDKEvent_HTLCHandlingFailed_get_failed_next_destination(ptr: bigint): bigint {
2437 if(!isWasmInitialized) {
2438 throw new Error("initializeWasm() must be awaited first!");
2440 const nativeResponseValue = wasm.TS_LDKEvent_HTLCHandlingFailed_get_failed_next_destination(ptr);
2441 return nativeResponseValue;
2444 export class LDKCOption_EventZ {
2445 protected constructor() {}
2448 export function LDKCOption_EventZ_ty_from_ptr(ptr: bigint): number {
2449 if(!isWasmInitialized) {
2450 throw new Error("initializeWasm() must be awaited first!");
2452 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_ty_from_ptr(ptr);
2453 return nativeResponseValue;
2456 export function LDKCOption_EventZ_Some_get_some(ptr: bigint): bigint {
2457 if(!isWasmInitialized) {
2458 throw new Error("initializeWasm() must be awaited first!");
2460 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_Some_get_some(ptr);
2461 return nativeResponseValue;
2463 // struct LDKCOption_EventZ CResult_COption_EventZDecodeErrorZ_get_ok(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
2465 export function CResult_COption_EventZDecodeErrorZ_get_ok(owner: bigint): bigint {
2466 if(!isWasmInitialized) {
2467 throw new Error("initializeWasm() must be awaited first!");
2469 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_ok(owner);
2470 return nativeResponseValue;
2472 // struct LDKDecodeError CResult_COption_EventZDecodeErrorZ_get_err(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
2474 export function CResult_COption_EventZDecodeErrorZ_get_err(owner: bigint): bigint {
2475 if(!isWasmInitialized) {
2476 throw new Error("initializeWasm() must be awaited first!");
2478 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_err(owner);
2479 return nativeResponseValue;
2482 export class LDKErrorAction {
2483 protected constructor() {}
2486 export function LDKErrorAction_ty_from_ptr(ptr: bigint): number {
2487 if(!isWasmInitialized) {
2488 throw new Error("initializeWasm() must be awaited first!");
2490 const nativeResponseValue = wasm.TS_LDKErrorAction_ty_from_ptr(ptr);
2491 return nativeResponseValue;
2494 export function LDKErrorAction_DisconnectPeer_get_msg(ptr: bigint): bigint {
2495 if(!isWasmInitialized) {
2496 throw new Error("initializeWasm() must be awaited first!");
2498 const nativeResponseValue = wasm.TS_LDKErrorAction_DisconnectPeer_get_msg(ptr);
2499 return nativeResponseValue;
2502 export function LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr: bigint): Level {
2503 if(!isWasmInitialized) {
2504 throw new Error("initializeWasm() must be awaited first!");
2506 const nativeResponseValue = wasm.TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr);
2507 return nativeResponseValue;
2510 export function LDKErrorAction_SendErrorMessage_get_msg(ptr: bigint): bigint {
2511 if(!isWasmInitialized) {
2512 throw new Error("initializeWasm() must be awaited first!");
2514 const nativeResponseValue = wasm.TS_LDKErrorAction_SendErrorMessage_get_msg(ptr);
2515 return nativeResponseValue;
2518 export function LDKErrorAction_SendWarningMessage_get_msg(ptr: bigint): bigint {
2519 if(!isWasmInitialized) {
2520 throw new Error("initializeWasm() must be awaited first!");
2522 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_msg(ptr);
2523 return nativeResponseValue;
2526 export function LDKErrorAction_SendWarningMessage_get_log_level(ptr: bigint): Level {
2527 if(!isWasmInitialized) {
2528 throw new Error("initializeWasm() must be awaited first!");
2530 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_log_level(ptr);
2531 return nativeResponseValue;
2534 export class LDKMessageSendEvent {
2535 protected constructor() {}
2538 export function LDKMessageSendEvent_ty_from_ptr(ptr: bigint): number {
2539 if(!isWasmInitialized) {
2540 throw new Error("initializeWasm() must be awaited first!");
2542 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_ty_from_ptr(ptr);
2543 return nativeResponseValue;
2546 export function LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr: bigint): number {
2547 if(!isWasmInitialized) {
2548 throw new Error("initializeWasm() must be awaited first!");
2550 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr);
2551 return nativeResponseValue;
2554 export function LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr: bigint): bigint {
2555 if(!isWasmInitialized) {
2556 throw new Error("initializeWasm() must be awaited first!");
2558 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr);
2559 return nativeResponseValue;
2562 export function LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr: bigint): number {
2563 if(!isWasmInitialized) {
2564 throw new Error("initializeWasm() must be awaited first!");
2566 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr);
2567 return nativeResponseValue;
2570 export function LDKMessageSendEvent_SendOpenChannel_get_msg(ptr: bigint): bigint {
2571 if(!isWasmInitialized) {
2572 throw new Error("initializeWasm() must be awaited first!");
2574 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_msg(ptr);
2575 return nativeResponseValue;
2578 export function LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr: bigint): number {
2579 if(!isWasmInitialized) {
2580 throw new Error("initializeWasm() must be awaited first!");
2582 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr);
2583 return nativeResponseValue;
2586 export function LDKMessageSendEvent_SendFundingCreated_get_msg(ptr: bigint): bigint {
2587 if(!isWasmInitialized) {
2588 throw new Error("initializeWasm() must be awaited first!");
2590 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_msg(ptr);
2591 return nativeResponseValue;
2594 export function LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr: bigint): number {
2595 if(!isWasmInitialized) {
2596 throw new Error("initializeWasm() must be awaited first!");
2598 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr);
2599 return nativeResponseValue;
2602 export function LDKMessageSendEvent_SendFundingSigned_get_msg(ptr: bigint): bigint {
2603 if(!isWasmInitialized) {
2604 throw new Error("initializeWasm() must be awaited first!");
2606 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_msg(ptr);
2607 return nativeResponseValue;
2610 export function LDKMessageSendEvent_SendChannelReady_get_node_id(ptr: bigint): number {
2611 if(!isWasmInitialized) {
2612 throw new Error("initializeWasm() must be awaited first!");
2614 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_node_id(ptr);
2615 return nativeResponseValue;
2618 export function LDKMessageSendEvent_SendChannelReady_get_msg(ptr: bigint): bigint {
2619 if(!isWasmInitialized) {
2620 throw new Error("initializeWasm() must be awaited first!");
2622 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_msg(ptr);
2623 return nativeResponseValue;
2626 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr: bigint): number {
2627 if(!isWasmInitialized) {
2628 throw new Error("initializeWasm() must be awaited first!");
2630 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr);
2631 return nativeResponseValue;
2634 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr: bigint): bigint {
2635 if(!isWasmInitialized) {
2636 throw new Error("initializeWasm() must be awaited first!");
2638 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr);
2639 return nativeResponseValue;
2642 export function LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr: bigint): number {
2643 if(!isWasmInitialized) {
2644 throw new Error("initializeWasm() must be awaited first!");
2646 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr);
2647 return nativeResponseValue;
2650 export function LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr: bigint): bigint {
2651 if(!isWasmInitialized) {
2652 throw new Error("initializeWasm() must be awaited first!");
2654 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr);
2655 return nativeResponseValue;
2658 export function LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr: bigint): number {
2659 if(!isWasmInitialized) {
2660 throw new Error("initializeWasm() must be awaited first!");
2662 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr);
2663 return nativeResponseValue;
2666 export function LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr: bigint): bigint {
2667 if(!isWasmInitialized) {
2668 throw new Error("initializeWasm() must be awaited first!");
2670 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr);
2671 return nativeResponseValue;
2674 export function LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr: bigint): number {
2675 if(!isWasmInitialized) {
2676 throw new Error("initializeWasm() must be awaited first!");
2678 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr);
2679 return nativeResponseValue;
2682 export function LDKMessageSendEvent_SendClosingSigned_get_msg(ptr: bigint): bigint {
2683 if(!isWasmInitialized) {
2684 throw new Error("initializeWasm() must be awaited first!");
2686 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_msg(ptr);
2687 return nativeResponseValue;
2690 export function LDKMessageSendEvent_SendShutdown_get_node_id(ptr: bigint): number {
2691 if(!isWasmInitialized) {
2692 throw new Error("initializeWasm() must be awaited first!");
2694 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_node_id(ptr);
2695 return nativeResponseValue;
2698 export function LDKMessageSendEvent_SendShutdown_get_msg(ptr: bigint): bigint {
2699 if(!isWasmInitialized) {
2700 throw new Error("initializeWasm() must be awaited first!");
2702 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_msg(ptr);
2703 return nativeResponseValue;
2706 export function LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr: bigint): number {
2707 if(!isWasmInitialized) {
2708 throw new Error("initializeWasm() must be awaited first!");
2710 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr);
2711 return nativeResponseValue;
2714 export function LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr: bigint): bigint {
2715 if(!isWasmInitialized) {
2716 throw new Error("initializeWasm() must be awaited first!");
2718 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr);
2719 return nativeResponseValue;
2722 export function LDKMessageSendEvent_SendChannelAnnouncement_get_node_id(ptr: bigint): number {
2723 if(!isWasmInitialized) {
2724 throw new Error("initializeWasm() must be awaited first!");
2726 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelAnnouncement_get_node_id(ptr);
2727 return nativeResponseValue;
2730 export function LDKMessageSendEvent_SendChannelAnnouncement_get_msg(ptr: bigint): bigint {
2731 if(!isWasmInitialized) {
2732 throw new Error("initializeWasm() must be awaited first!");
2734 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelAnnouncement_get_msg(ptr);
2735 return nativeResponseValue;
2738 export function LDKMessageSendEvent_SendChannelAnnouncement_get_update_msg(ptr: bigint): bigint {
2739 if(!isWasmInitialized) {
2740 throw new Error("initializeWasm() must be awaited first!");
2742 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelAnnouncement_get_update_msg(ptr);
2743 return nativeResponseValue;
2746 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr: bigint): bigint {
2747 if(!isWasmInitialized) {
2748 throw new Error("initializeWasm() must be awaited first!");
2750 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr);
2751 return nativeResponseValue;
2754 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr: bigint): bigint {
2755 if(!isWasmInitialized) {
2756 throw new Error("initializeWasm() must be awaited first!");
2758 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr);
2759 return nativeResponseValue;
2762 export function LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr: bigint): bigint {
2763 if(!isWasmInitialized) {
2764 throw new Error("initializeWasm() must be awaited first!");
2766 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr);
2767 return nativeResponseValue;
2770 export function LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr: bigint): bigint {
2771 if(!isWasmInitialized) {
2772 throw new Error("initializeWasm() must be awaited first!");
2774 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr);
2775 return nativeResponseValue;
2778 export function LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr: bigint): number {
2779 if(!isWasmInitialized) {
2780 throw new Error("initializeWasm() must be awaited first!");
2782 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr);
2783 return nativeResponseValue;
2786 export function LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr: bigint): bigint {
2787 if(!isWasmInitialized) {
2788 throw new Error("initializeWasm() must be awaited first!");
2790 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr);
2791 return nativeResponseValue;
2794 export function LDKMessageSendEvent_HandleError_get_node_id(ptr: bigint): number {
2795 if(!isWasmInitialized) {
2796 throw new Error("initializeWasm() must be awaited first!");
2798 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_node_id(ptr);
2799 return nativeResponseValue;
2802 export function LDKMessageSendEvent_HandleError_get_action(ptr: bigint): bigint {
2803 if(!isWasmInitialized) {
2804 throw new Error("initializeWasm() must be awaited first!");
2806 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_action(ptr);
2807 return nativeResponseValue;
2810 export function LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr: bigint): number {
2811 if(!isWasmInitialized) {
2812 throw new Error("initializeWasm() must be awaited first!");
2814 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr);
2815 return nativeResponseValue;
2818 export function LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr: bigint): bigint {
2819 if(!isWasmInitialized) {
2820 throw new Error("initializeWasm() must be awaited first!");
2822 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr);
2823 return nativeResponseValue;
2826 export function LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr: bigint): number {
2827 if(!isWasmInitialized) {
2828 throw new Error("initializeWasm() must be awaited first!");
2830 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr);
2831 return nativeResponseValue;
2834 export function LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr: bigint): bigint {
2835 if(!isWasmInitialized) {
2836 throw new Error("initializeWasm() must be awaited first!");
2838 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr);
2839 return nativeResponseValue;
2842 export function LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr: bigint): number {
2843 if(!isWasmInitialized) {
2844 throw new Error("initializeWasm() must be awaited first!");
2846 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr);
2847 return nativeResponseValue;
2850 export function LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr: bigint): bigint {
2851 if(!isWasmInitialized) {
2852 throw new Error("initializeWasm() must be awaited first!");
2854 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr);
2855 return nativeResponseValue;
2858 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr: bigint): number {
2859 if(!isWasmInitialized) {
2860 throw new Error("initializeWasm() must be awaited first!");
2862 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr);
2863 return nativeResponseValue;
2866 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr: bigint): bigint {
2867 if(!isWasmInitialized) {
2868 throw new Error("initializeWasm() must be awaited first!");
2870 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr);
2871 return nativeResponseValue;
2873 // uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2875 export function C2Tuple_usizeTransactionZ_get_a(owner: bigint): number {
2876 if(!isWasmInitialized) {
2877 throw new Error("initializeWasm() must be awaited first!");
2879 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_a(owner);
2880 return nativeResponseValue;
2882 // struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2884 export function C2Tuple_usizeTransactionZ_get_b(owner: bigint): number {
2885 if(!isWasmInitialized) {
2886 throw new Error("initializeWasm() must be awaited first!");
2888 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_b(owner);
2889 return nativeResponseValue;
2891 // struct LDKThirtyTwoBytes C2Tuple_TxidBlockHashZ_get_a(LDKC2Tuple_TxidBlockHashZ *NONNULL_PTR owner);
2893 export function C2Tuple_TxidBlockHashZ_get_a(owner: bigint): number {
2894 if(!isWasmInitialized) {
2895 throw new Error("initializeWasm() must be awaited first!");
2897 const nativeResponseValue = wasm.TS_C2Tuple_TxidBlockHashZ_get_a(owner);
2898 return nativeResponseValue;
2900 // struct LDKThirtyTwoBytes C2Tuple_TxidBlockHashZ_get_b(LDKC2Tuple_TxidBlockHashZ *NONNULL_PTR owner);
2902 export function C2Tuple_TxidBlockHashZ_get_b(owner: bigint): number {
2903 if(!isWasmInitialized) {
2904 throw new Error("initializeWasm() must be awaited first!");
2906 const nativeResponseValue = wasm.TS_C2Tuple_TxidBlockHashZ_get_b(owner);
2907 return nativeResponseValue;
2910 export class LDKMonitorEvent {
2911 protected constructor() {}
2914 export function LDKMonitorEvent_ty_from_ptr(ptr: bigint): number {
2915 if(!isWasmInitialized) {
2916 throw new Error("initializeWasm() must be awaited first!");
2918 const nativeResponseValue = wasm.TS_LDKMonitorEvent_ty_from_ptr(ptr);
2919 return nativeResponseValue;
2922 export function LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr: bigint): bigint {
2923 if(!isWasmInitialized) {
2924 throw new Error("initializeWasm() must be awaited first!");
2926 const nativeResponseValue = wasm.TS_LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr);
2927 return nativeResponseValue;
2930 export function LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr: bigint): bigint {
2931 if(!isWasmInitialized) {
2932 throw new Error("initializeWasm() must be awaited first!");
2934 const nativeResponseValue = wasm.TS_LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr);
2935 return nativeResponseValue;
2938 export function LDKMonitorEvent_Completed_get_funding_txo(ptr: bigint): bigint {
2939 if(!isWasmInitialized) {
2940 throw new Error("initializeWasm() must be awaited first!");
2942 const nativeResponseValue = wasm.TS_LDKMonitorEvent_Completed_get_funding_txo(ptr);
2943 return nativeResponseValue;
2946 export function LDKMonitorEvent_Completed_get_monitor_update_id(ptr: bigint): bigint {
2947 if(!isWasmInitialized) {
2948 throw new Error("initializeWasm() must be awaited first!");
2950 const nativeResponseValue = wasm.TS_LDKMonitorEvent_Completed_get_monitor_update_id(ptr);
2951 return nativeResponseValue;
2954 export function LDKMonitorEvent_UpdateFailed_get_update_failed(ptr: bigint): bigint {
2955 if(!isWasmInitialized) {
2956 throw new Error("initializeWasm() must be awaited first!");
2958 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateFailed_get_update_failed(ptr);
2959 return nativeResponseValue;
2961 // struct LDKOutPoint C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2963 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner: bigint): bigint {
2964 if(!isWasmInitialized) {
2965 throw new Error("initializeWasm() must be awaited first!");
2967 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner);
2968 return nativeResponseValue;
2970 // struct LDKCVec_MonitorEventZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2972 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner: bigint): number {
2973 if(!isWasmInitialized) {
2974 throw new Error("initializeWasm() must be awaited first!");
2976 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner);
2977 return nativeResponseValue;
2979 // struct LDKPublicKey C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2981 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner: bigint): number {
2982 if(!isWasmInitialized) {
2983 throw new Error("initializeWasm() must be awaited first!");
2985 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner);
2986 return nativeResponseValue;
2988 // struct LDKFixedPenaltyScorer CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2990 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner: bigint): bigint {
2991 if(!isWasmInitialized) {
2992 throw new Error("initializeWasm() must be awaited first!");
2994 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner);
2995 return nativeResponseValue;
2997 // struct LDKDecodeError CResult_FixedPenaltyScorerDecodeErrorZ_get_err(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2999 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner: bigint): bigint {
3000 if(!isWasmInitialized) {
3001 throw new Error("initializeWasm() must be awaited first!");
3003 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner);
3004 return nativeResponseValue;
3006 // uint64_t C2Tuple_u64u64Z_get_a(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
3008 export function C2Tuple_u64u64Z_get_a(owner: bigint): bigint {
3009 if(!isWasmInitialized) {
3010 throw new Error("initializeWasm() must be awaited first!");
3012 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_a(owner);
3013 return nativeResponseValue;
3015 // uint64_t C2Tuple_u64u64Z_get_b(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
3017 export function C2Tuple_u64u64Z_get_b(owner: bigint): bigint {
3018 if(!isWasmInitialized) {
3019 throw new Error("initializeWasm() must be awaited first!");
3021 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_b(owner);
3022 return nativeResponseValue;
3025 export class LDKCOption_C2Tuple_u64u64ZZ {
3026 protected constructor() {}
3029 export function LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr: bigint): number {
3030 if(!isWasmInitialized) {
3031 throw new Error("initializeWasm() must be awaited first!");
3033 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr);
3034 return nativeResponseValue;
3037 export function LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr: bigint): bigint {
3038 if(!isWasmInitialized) {
3039 throw new Error("initializeWasm() must be awaited first!");
3041 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr);
3042 return nativeResponseValue;
3044 // struct LDKEightU16s C2Tuple_Z_get_a(LDKC2Tuple_Z *NONNULL_PTR owner);
3046 export function C2Tuple_Z_get_a(owner: bigint): number {
3047 if(!isWasmInitialized) {
3048 throw new Error("initializeWasm() must be awaited first!");
3050 const nativeResponseValue = wasm.TS_C2Tuple_Z_get_a(owner);
3051 return nativeResponseValue;
3053 // struct LDKEightU16s C2Tuple_Z_get_b(LDKC2Tuple_Z *NONNULL_PTR owner);
3055 export function C2Tuple_Z_get_b(owner: bigint): number {
3056 if(!isWasmInitialized) {
3057 throw new Error("initializeWasm() must be awaited first!");
3059 const nativeResponseValue = wasm.TS_C2Tuple_Z_get_b(owner);
3060 return nativeResponseValue;
3062 // struct LDKEightU16s C2Tuple__u168_u168Z_get_a(LDKC2Tuple__u168_u168Z *NONNULL_PTR owner);
3064 export function C2Tuple__u168_u168Z_get_a(owner: bigint): number {
3065 if(!isWasmInitialized) {
3066 throw new Error("initializeWasm() must be awaited first!");
3068 const nativeResponseValue = wasm.TS_C2Tuple__u168_u168Z_get_a(owner);
3069 return nativeResponseValue;
3071 // struct LDKEightU16s C2Tuple__u168_u168Z_get_b(LDKC2Tuple__u168_u168Z *NONNULL_PTR owner);
3073 export function C2Tuple__u168_u168Z_get_b(owner: bigint): number {
3074 if(!isWasmInitialized) {
3075 throw new Error("initializeWasm() must be awaited first!");
3077 const nativeResponseValue = wasm.TS_C2Tuple__u168_u168Z_get_b(owner);
3078 return nativeResponseValue;
3081 export class LDKCOption_C2Tuple_EightU16sEightU16sZZ {
3082 protected constructor() {}
3085 export function LDKCOption_C2Tuple_EightU16sEightU16sZZ_ty_from_ptr(ptr: bigint): number {
3086 if(!isWasmInitialized) {
3087 throw new Error("initializeWasm() must be awaited first!");
3089 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_EightU16sEightU16sZZ_ty_from_ptr(ptr);
3090 return nativeResponseValue;
3093 export function LDKCOption_C2Tuple_EightU16sEightU16sZZ_Some_get_some(ptr: bigint): bigint {
3094 if(!isWasmInitialized) {
3095 throw new Error("initializeWasm() must be awaited first!");
3097 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_EightU16sEightU16sZZ_Some_get_some(ptr);
3098 return nativeResponseValue;
3101 export interface LDKLogger {
3102 log (record: bigint): void;
3106 export function LDKLogger_new(impl: LDKLogger): [bigint, number] {
3107 if(!isWasmInitialized) {
3108 throw new Error("initializeWasm() must be awaited first!");
3110 var new_obj_idx = js_objs.length;
3111 for (var i = 0; i < js_objs.length; i++) {
3112 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3114 js_objs[i] = new WeakRef(impl);
3115 return [wasm.TS_LDKLogger_new(i), i];
3117 // struct LDKProbabilisticScorer CResult_ProbabilisticScorerDecodeErrorZ_get_ok(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
3119 export function CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner: bigint): bigint {
3120 if(!isWasmInitialized) {
3121 throw new Error("initializeWasm() must be awaited first!");
3123 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner);
3124 return nativeResponseValue;
3126 // struct LDKDecodeError CResult_ProbabilisticScorerDecodeErrorZ_get_err(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
3128 export function CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner: bigint): bigint {
3129 if(!isWasmInitialized) {
3130 throw new Error("initializeWasm() must be awaited first!");
3132 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner);
3133 return nativeResponseValue;
3135 // struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
3137 export function CResult_InitFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
3138 if(!isWasmInitialized) {
3139 throw new Error("initializeWasm() must be awaited first!");
3141 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_ok(owner);
3142 return nativeResponseValue;
3144 // struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
3146 export function CResult_InitFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
3147 if(!isWasmInitialized) {
3148 throw new Error("initializeWasm() must be awaited first!");
3150 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_err(owner);
3151 return nativeResponseValue;
3153 // struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
3155 export function CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
3156 if(!isWasmInitialized) {
3157 throw new Error("initializeWasm() must be awaited first!");
3159 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner);
3160 return nativeResponseValue;
3162 // struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
3164 export function CResult_ChannelFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
3165 if(!isWasmInitialized) {
3166 throw new Error("initializeWasm() must be awaited first!");
3168 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(owner);
3169 return nativeResponseValue;
3171 // struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
3173 export function CResult_NodeFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
3174 if(!isWasmInitialized) {
3175 throw new Error("initializeWasm() must be awaited first!");
3177 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(owner);
3178 return nativeResponseValue;
3180 // struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
3182 export function CResult_NodeFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
3183 if(!isWasmInitialized) {
3184 throw new Error("initializeWasm() must be awaited first!");
3186 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_err(owner);
3187 return nativeResponseValue;
3189 // struct LDKInvoiceFeatures CResult_InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
3191 export function CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
3192 if(!isWasmInitialized) {
3193 throw new Error("initializeWasm() must be awaited first!");
3195 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner);
3196 return nativeResponseValue;
3198 // struct LDKDecodeError CResult_InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
3200 export function CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
3201 if(!isWasmInitialized) {
3202 throw new Error("initializeWasm() must be awaited first!");
3204 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner);
3205 return nativeResponseValue;
3207 // struct LDKBlindedHopFeatures CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR owner);
3209 export function CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
3210 if(!isWasmInitialized) {
3211 throw new Error("initializeWasm() must be awaited first!");
3213 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(owner);
3214 return nativeResponseValue;
3216 // struct LDKDecodeError CResult_BlindedHopFeaturesDecodeErrorZ_get_err(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR owner);
3218 export function CResult_BlindedHopFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
3219 if(!isWasmInitialized) {
3220 throw new Error("initializeWasm() must be awaited first!");
3222 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_err(owner);
3223 return nativeResponseValue;
3225 // struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
3227 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
3228 if(!isWasmInitialized) {
3229 throw new Error("initializeWasm() must be awaited first!");
3231 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner);
3232 return nativeResponseValue;
3234 // struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
3236 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
3237 if(!isWasmInitialized) {
3238 throw new Error("initializeWasm() must be awaited first!");
3240 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner);
3241 return nativeResponseValue;
3243 // struct LDKNodeId CResult_NodeIdDecodeErrorZ_get_ok(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
3245 export function CResult_NodeIdDecodeErrorZ_get_ok(owner: bigint): bigint {
3246 if(!isWasmInitialized) {
3247 throw new Error("initializeWasm() must be awaited first!");
3249 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_ok(owner);
3250 return nativeResponseValue;
3252 // struct LDKDecodeError CResult_NodeIdDecodeErrorZ_get_err(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
3254 export function CResult_NodeIdDecodeErrorZ_get_err(owner: bigint): bigint {
3255 if(!isWasmInitialized) {
3256 throw new Error("initializeWasm() must be awaited first!");
3258 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_err(owner);
3259 return nativeResponseValue;
3261 // struct LDKCOption_NetworkUpdateZ CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
3263 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner: bigint): bigint {
3264 if(!isWasmInitialized) {
3265 throw new Error("initializeWasm() must be awaited first!");
3267 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner);
3268 return nativeResponseValue;
3270 // struct LDKDecodeError CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
3272 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner: bigint): bigint {
3273 if(!isWasmInitialized) {
3274 throw new Error("initializeWasm() must be awaited first!");
3276 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner);
3277 return nativeResponseValue;
3279 // struct LDKTxOut CResult_TxOutUtxoLookupErrorZ_get_ok(LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR owner);
3281 export function CResult_TxOutUtxoLookupErrorZ_get_ok(owner: bigint): bigint {
3282 if(!isWasmInitialized) {
3283 throw new Error("initializeWasm() must be awaited first!");
3285 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_get_ok(owner);
3286 return nativeResponseValue;
3288 // enum LDKUtxoLookupError CResult_TxOutUtxoLookupErrorZ_get_err(LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR owner);
3290 export function CResult_TxOutUtxoLookupErrorZ_get_err(owner: bigint): UtxoLookupError {
3291 if(!isWasmInitialized) {
3292 throw new Error("initializeWasm() must be awaited first!");
3294 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_get_err(owner);
3295 return nativeResponseValue;
3298 export class LDKUtxoResult {
3299 protected constructor() {}
3302 export function LDKUtxoResult_ty_from_ptr(ptr: bigint): number {
3303 if(!isWasmInitialized) {
3304 throw new Error("initializeWasm() must be awaited first!");
3306 const nativeResponseValue = wasm.TS_LDKUtxoResult_ty_from_ptr(ptr);
3307 return nativeResponseValue;
3310 export function LDKUtxoResult_Sync_get_sync(ptr: bigint): bigint {
3311 if(!isWasmInitialized) {
3312 throw new Error("initializeWasm() must be awaited first!");
3314 const nativeResponseValue = wasm.TS_LDKUtxoResult_Sync_get_sync(ptr);
3315 return nativeResponseValue;
3318 export function LDKUtxoResult_Async_get_async(ptr: bigint): bigint {
3319 if(!isWasmInitialized) {
3320 throw new Error("initializeWasm() must be awaited first!");
3322 const nativeResponseValue = wasm.TS_LDKUtxoResult_Async_get_async(ptr);
3323 return nativeResponseValue;
3326 export interface LDKUtxoLookup {
3327 get_utxo (genesis_hash: number, short_channel_id: bigint): bigint;
3331 export function LDKUtxoLookup_new(impl: LDKUtxoLookup): [bigint, number] {
3332 if(!isWasmInitialized) {
3333 throw new Error("initializeWasm() must be awaited first!");
3335 var new_obj_idx = js_objs.length;
3336 for (var i = 0; i < js_objs.length; i++) {
3337 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3339 js_objs[i] = new WeakRef(impl);
3340 return [wasm.TS_LDKUtxoLookup_new(i), i];
3342 // LDKUtxoResult UtxoLookup_get_utxo LDKUtxoLookup *NONNULL_PTR this_arg, const uint8_t (*genesis_hash)[32], uint64_t short_channel_id
3344 export function UtxoLookup_get_utxo(this_arg: bigint, genesis_hash: number, short_channel_id: bigint): bigint {
3345 if(!isWasmInitialized) {
3346 throw new Error("initializeWasm() must be awaited first!");
3348 const nativeResponseValue = wasm.TS_UtxoLookup_get_utxo(this_arg, genesis_hash, short_channel_id);
3349 return nativeResponseValue;
3352 export class LDKCOption_UtxoLookupZ {
3353 protected constructor() {}
3356 export function LDKCOption_UtxoLookupZ_ty_from_ptr(ptr: bigint): number {
3357 if(!isWasmInitialized) {
3358 throw new Error("initializeWasm() must be awaited first!");
3360 const nativeResponseValue = wasm.TS_LDKCOption_UtxoLookupZ_ty_from_ptr(ptr);
3361 return nativeResponseValue;
3364 export function LDKCOption_UtxoLookupZ_Some_get_some(ptr: bigint): bigint {
3365 if(!isWasmInitialized) {
3366 throw new Error("initializeWasm() must be awaited first!");
3368 const nativeResponseValue = wasm.TS_LDKCOption_UtxoLookupZ_Some_get_some(ptr);
3369 return nativeResponseValue;
3371 // bool CResult_boolLightningErrorZ_get_ok(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
3373 export function CResult_boolLightningErrorZ_get_ok(owner: bigint): boolean {
3374 if(!isWasmInitialized) {
3375 throw new Error("initializeWasm() must be awaited first!");
3377 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_ok(owner);
3378 return nativeResponseValue;
3380 // struct LDKLightningError CResult_boolLightningErrorZ_get_err(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
3382 export function CResult_boolLightningErrorZ_get_err(owner: bigint): bigint {
3383 if(!isWasmInitialized) {
3384 throw new Error("initializeWasm() must be awaited first!");
3386 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_err(owner);
3387 return nativeResponseValue;
3389 // struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
3391 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner: bigint): bigint {
3392 if(!isWasmInitialized) {
3393 throw new Error("initializeWasm() must be awaited first!");
3395 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner);
3396 return nativeResponseValue;
3398 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
3400 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner: bigint): bigint {
3401 if(!isWasmInitialized) {
3402 throw new Error("initializeWasm() must be awaited first!");
3404 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner);
3405 return nativeResponseValue;
3407 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
3409 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner: bigint): bigint {
3410 if(!isWasmInitialized) {
3411 throw new Error("initializeWasm() must be awaited first!");
3413 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner);
3414 return nativeResponseValue;
3417 export class LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
3418 protected constructor() {}
3421 export function LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_ty_from_ptr(ptr: bigint): number {
3422 if(!isWasmInitialized) {
3423 throw new Error("initializeWasm() must be awaited first!");
3425 const nativeResponseValue = wasm.TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_ty_from_ptr(ptr);
3426 return nativeResponseValue;
3429 export function LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_get_some(ptr: bigint): bigint {
3430 if(!isWasmInitialized) {
3431 throw new Error("initializeWasm() must be awaited first!");
3433 const nativeResponseValue = wasm.TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_get_some(ptr);
3434 return nativeResponseValue;
3436 // void CResult_NoneLightningErrorZ_get_ok(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
3438 export function CResult_NoneLightningErrorZ_get_ok(owner: bigint): void {
3439 if(!isWasmInitialized) {
3440 throw new Error("initializeWasm() must be awaited first!");
3442 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_ok(owner);
3443 // debug statements here
3445 // struct LDKLightningError CResult_NoneLightningErrorZ_get_err(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
3447 export function CResult_NoneLightningErrorZ_get_err(owner: bigint): bigint {
3448 if(!isWasmInitialized) {
3449 throw new Error("initializeWasm() must be awaited first!");
3451 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_err(owner);
3452 return nativeResponseValue;
3454 // struct LDKChannelUpdateInfo CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
3456 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
3457 if(!isWasmInitialized) {
3458 throw new Error("initializeWasm() must be awaited first!");
3460 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner);
3461 return nativeResponseValue;
3463 // struct LDKDecodeError CResult_ChannelUpdateInfoDecodeErrorZ_get_err(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
3465 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner: bigint): bigint {
3466 if(!isWasmInitialized) {
3467 throw new Error("initializeWasm() must be awaited first!");
3469 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner);
3470 return nativeResponseValue;
3472 // struct LDKChannelInfo CResult_ChannelInfoDecodeErrorZ_get_ok(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
3474 export function CResult_ChannelInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
3475 if(!isWasmInitialized) {
3476 throw new Error("initializeWasm() must be awaited first!");
3478 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_ok(owner);
3479 return nativeResponseValue;
3481 // struct LDKDecodeError CResult_ChannelInfoDecodeErrorZ_get_err(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
3483 export function CResult_ChannelInfoDecodeErrorZ_get_err(owner: bigint): bigint {
3484 if(!isWasmInitialized) {
3485 throw new Error("initializeWasm() must be awaited first!");
3487 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_err(owner);
3488 return nativeResponseValue;
3490 // struct LDKRoutingFees CResult_RoutingFeesDecodeErrorZ_get_ok(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
3492 export function CResult_RoutingFeesDecodeErrorZ_get_ok(owner: bigint): bigint {
3493 if(!isWasmInitialized) {
3494 throw new Error("initializeWasm() must be awaited first!");
3496 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_ok(owner);
3497 return nativeResponseValue;
3499 // struct LDKDecodeError CResult_RoutingFeesDecodeErrorZ_get_err(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
3501 export function CResult_RoutingFeesDecodeErrorZ_get_err(owner: bigint): bigint {
3502 if(!isWasmInitialized) {
3503 throw new Error("initializeWasm() must be awaited first!");
3505 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_err(owner);
3506 return nativeResponseValue;
3509 export class LDKNetAddress {
3510 protected constructor() {}
3513 export function LDKNetAddress_ty_from_ptr(ptr: bigint): number {
3514 if(!isWasmInitialized) {
3515 throw new Error("initializeWasm() must be awaited first!");
3517 const nativeResponseValue = wasm.TS_LDKNetAddress_ty_from_ptr(ptr);
3518 return nativeResponseValue;
3521 export function LDKNetAddress_IPv4_get_addr(ptr: bigint): number {
3522 if(!isWasmInitialized) {
3523 throw new Error("initializeWasm() must be awaited first!");
3525 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_addr(ptr);
3526 return nativeResponseValue;
3529 export function LDKNetAddress_IPv4_get_port(ptr: bigint): number {
3530 if(!isWasmInitialized) {
3531 throw new Error("initializeWasm() must be awaited first!");
3533 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_port(ptr);
3534 return nativeResponseValue;
3537 export function LDKNetAddress_IPv6_get_addr(ptr: bigint): number {
3538 if(!isWasmInitialized) {
3539 throw new Error("initializeWasm() must be awaited first!");
3541 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_addr(ptr);
3542 return nativeResponseValue;
3545 export function LDKNetAddress_IPv6_get_port(ptr: bigint): number {
3546 if(!isWasmInitialized) {
3547 throw new Error("initializeWasm() must be awaited first!");
3549 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_port(ptr);
3550 return nativeResponseValue;
3553 export function LDKNetAddress_OnionV2_get_onion_v2(ptr: bigint): number {
3554 if(!isWasmInitialized) {
3555 throw new Error("initializeWasm() must be awaited first!");
3557 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV2_get_onion_v2(ptr);
3558 return nativeResponseValue;
3561 export function LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr: bigint): number {
3562 if(!isWasmInitialized) {
3563 throw new Error("initializeWasm() must be awaited first!");
3565 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr);
3566 return nativeResponseValue;
3569 export function LDKNetAddress_OnionV3_get_checksum(ptr: bigint): number {
3570 if(!isWasmInitialized) {
3571 throw new Error("initializeWasm() must be awaited first!");
3573 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_checksum(ptr);
3574 return nativeResponseValue;
3577 export function LDKNetAddress_OnionV3_get_version(ptr: bigint): number {
3578 if(!isWasmInitialized) {
3579 throw new Error("initializeWasm() must be awaited first!");
3581 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_version(ptr);
3582 return nativeResponseValue;
3585 export function LDKNetAddress_OnionV3_get_port(ptr: bigint): number {
3586 if(!isWasmInitialized) {
3587 throw new Error("initializeWasm() must be awaited first!");
3589 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_port(ptr);
3590 return nativeResponseValue;
3593 export function LDKNetAddress_Hostname_get_hostname(ptr: bigint): bigint {
3594 if(!isWasmInitialized) {
3595 throw new Error("initializeWasm() must be awaited first!");
3597 const nativeResponseValue = wasm.TS_LDKNetAddress_Hostname_get_hostname(ptr);
3598 return nativeResponseValue;
3601 export function LDKNetAddress_Hostname_get_port(ptr: bigint): number {
3602 if(!isWasmInitialized) {
3603 throw new Error("initializeWasm() must be awaited first!");
3605 const nativeResponseValue = wasm.TS_LDKNetAddress_Hostname_get_port(ptr);
3606 return nativeResponseValue;
3608 // struct LDKNodeAnnouncementInfo CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
3610 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
3611 if(!isWasmInitialized) {
3612 throw new Error("initializeWasm() must be awaited first!");
3614 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner);
3615 return nativeResponseValue;
3617 // struct LDKDecodeError CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
3619 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner: bigint): bigint {
3620 if(!isWasmInitialized) {
3621 throw new Error("initializeWasm() must be awaited first!");
3623 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner);
3624 return nativeResponseValue;
3626 // struct LDKNodeAlias CResult_NodeAliasDecodeErrorZ_get_ok(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
3628 export function CResult_NodeAliasDecodeErrorZ_get_ok(owner: bigint): bigint {
3629 if(!isWasmInitialized) {
3630 throw new Error("initializeWasm() must be awaited first!");
3632 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_ok(owner);
3633 return nativeResponseValue;
3635 // struct LDKDecodeError CResult_NodeAliasDecodeErrorZ_get_err(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
3637 export function CResult_NodeAliasDecodeErrorZ_get_err(owner: bigint): bigint {
3638 if(!isWasmInitialized) {
3639 throw new Error("initializeWasm() must be awaited first!");
3641 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_err(owner);
3642 return nativeResponseValue;
3644 // struct LDKNodeInfo CResult_NodeInfoDecodeErrorZ_get_ok(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
3646 export function CResult_NodeInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
3647 if(!isWasmInitialized) {
3648 throw new Error("initializeWasm() must be awaited first!");
3650 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_ok(owner);
3651 return nativeResponseValue;
3653 // struct LDKDecodeError CResult_NodeInfoDecodeErrorZ_get_err(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
3655 export function CResult_NodeInfoDecodeErrorZ_get_err(owner: bigint): bigint {
3656 if(!isWasmInitialized) {
3657 throw new Error("initializeWasm() must be awaited first!");
3659 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_err(owner);
3660 return nativeResponseValue;
3662 // struct LDKNetworkGraph CResult_NetworkGraphDecodeErrorZ_get_ok(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
3664 export function CResult_NetworkGraphDecodeErrorZ_get_ok(owner: bigint): bigint {
3665 if(!isWasmInitialized) {
3666 throw new Error("initializeWasm() must be awaited first!");
3668 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_ok(owner);
3669 return nativeResponseValue;
3671 // struct LDKDecodeError CResult_NetworkGraphDecodeErrorZ_get_err(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
3673 export function CResult_NetworkGraphDecodeErrorZ_get_err(owner: bigint): bigint {
3674 if(!isWasmInitialized) {
3675 throw new Error("initializeWasm() must be awaited first!");
3677 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_err(owner);
3678 return nativeResponseValue;
3681 export class LDKCOption_CVec_NetAddressZZ {
3682 protected constructor() {}
3685 export function LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr: bigint): number {
3686 if(!isWasmInitialized) {
3687 throw new Error("initializeWasm() must be awaited first!");
3689 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr);
3690 return nativeResponseValue;
3693 export function LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr: bigint): number {
3694 if(!isWasmInitialized) {
3695 throw new Error("initializeWasm() must be awaited first!");
3697 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr);
3698 return nativeResponseValue;
3700 // struct LDKDelayedPaymentOutputDescriptor CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3702 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
3703 if(!isWasmInitialized) {
3704 throw new Error("initializeWasm() must be awaited first!");
3706 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
3707 return nativeResponseValue;
3709 // struct LDKDecodeError CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3711 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
3712 if(!isWasmInitialized) {
3713 throw new Error("initializeWasm() must be awaited first!");
3715 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
3716 return nativeResponseValue;
3718 // struct LDKStaticPaymentOutputDescriptor CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3720 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
3721 if(!isWasmInitialized) {
3722 throw new Error("initializeWasm() must be awaited first!");
3724 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
3725 return nativeResponseValue;
3727 // struct LDKDecodeError CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3729 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
3730 if(!isWasmInitialized) {
3731 throw new Error("initializeWasm() must be awaited first!");
3733 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
3734 return nativeResponseValue;
3736 // struct LDKSpendableOutputDescriptor CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3738 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
3739 if(!isWasmInitialized) {
3740 throw new Error("initializeWasm() must be awaited first!");
3742 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner);
3743 return nativeResponseValue;
3745 // struct LDKDecodeError CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3747 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
3748 if(!isWasmInitialized) {
3749 throw new Error("initializeWasm() must be awaited first!");
3751 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner);
3752 return nativeResponseValue;
3754 // struct LDKSignature C2Tuple_SignatureCVec_SignatureZZ_get_a(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
3756 export function C2Tuple_SignatureCVec_SignatureZZ_get_a(owner: bigint): number {
3757 if(!isWasmInitialized) {
3758 throw new Error("initializeWasm() must be awaited first!");
3760 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_a(owner);
3761 return nativeResponseValue;
3763 // struct LDKCVec_SignatureZ C2Tuple_SignatureCVec_SignatureZZ_get_b(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
3765 export function C2Tuple_SignatureCVec_SignatureZZ_get_b(owner: bigint): number {
3766 if(!isWasmInitialized) {
3767 throw new Error("initializeWasm() must be awaited first!");
3769 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_b(owner);
3770 return nativeResponseValue;
3772 // struct LDKC2Tuple_SignatureCVec_SignatureZZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
3774 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner: bigint): bigint {
3775 if(!isWasmInitialized) {
3776 throw new Error("initializeWasm() must be awaited first!");
3778 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner);
3779 return nativeResponseValue;
3781 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
3783 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner: bigint): void {
3784 if(!isWasmInitialized) {
3785 throw new Error("initializeWasm() must be awaited first!");
3787 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner);
3788 // debug statements here
3790 // struct LDKSignature CResult_SignatureNoneZ_get_ok(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
3792 export function CResult_SignatureNoneZ_get_ok(owner: bigint): number {
3793 if(!isWasmInitialized) {
3794 throw new Error("initializeWasm() must be awaited first!");
3796 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_ok(owner);
3797 return nativeResponseValue;
3799 // void CResult_SignatureNoneZ_get_err(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
3801 export function CResult_SignatureNoneZ_get_err(owner: bigint): void {
3802 if(!isWasmInitialized) {
3803 throw new Error("initializeWasm() must be awaited first!");
3805 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_err(owner);
3806 // debug statements here
3808 // struct LDKPublicKey CResult_PublicKeyNoneZ_get_ok(LDKCResult_PublicKeyNoneZ *NONNULL_PTR owner);
3810 export function CResult_PublicKeyNoneZ_get_ok(owner: bigint): number {
3811 if(!isWasmInitialized) {
3812 throw new Error("initializeWasm() must be awaited first!");
3814 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_get_ok(owner);
3815 return nativeResponseValue;
3817 // void CResult_PublicKeyNoneZ_get_err(LDKCResult_PublicKeyNoneZ *NONNULL_PTR owner);
3819 export function CResult_PublicKeyNoneZ_get_err(owner: bigint): void {
3820 if(!isWasmInitialized) {
3821 throw new Error("initializeWasm() must be awaited first!");
3823 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_get_err(owner);
3824 // debug statements here
3827 export class LDKCOption_ScalarZ {
3828 protected constructor() {}
3831 export function LDKCOption_ScalarZ_ty_from_ptr(ptr: bigint): number {
3832 if(!isWasmInitialized) {
3833 throw new Error("initializeWasm() must be awaited first!");
3835 const nativeResponseValue = wasm.TS_LDKCOption_ScalarZ_ty_from_ptr(ptr);
3836 return nativeResponseValue;
3839 export function LDKCOption_ScalarZ_Some_get_some(ptr: bigint): bigint {
3840 if(!isWasmInitialized) {
3841 throw new Error("initializeWasm() must be awaited first!");
3843 const nativeResponseValue = wasm.TS_LDKCOption_ScalarZ_Some_get_some(ptr);
3844 return nativeResponseValue;
3846 // struct LDKThirtyTwoBytes CResult_SharedSecretNoneZ_get_ok(LDKCResult_SharedSecretNoneZ *NONNULL_PTR owner);
3848 export function CResult_SharedSecretNoneZ_get_ok(owner: bigint): number {
3849 if(!isWasmInitialized) {
3850 throw new Error("initializeWasm() must be awaited first!");
3852 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_get_ok(owner);
3853 return nativeResponseValue;
3855 // void CResult_SharedSecretNoneZ_get_err(LDKCResult_SharedSecretNoneZ *NONNULL_PTR owner);
3857 export function CResult_SharedSecretNoneZ_get_err(owner: bigint): void {
3858 if(!isWasmInitialized) {
3859 throw new Error("initializeWasm() must be awaited first!");
3861 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_get_err(owner);
3862 // debug statements here
3864 // struct LDKRecoverableSignature CResult_RecoverableSignatureNoneZ_get_ok(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
3866 export function CResult_RecoverableSignatureNoneZ_get_ok(owner: bigint): number {
3867 if(!isWasmInitialized) {
3868 throw new Error("initializeWasm() must be awaited first!");
3870 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_ok(owner);
3871 return nativeResponseValue;
3873 // void CResult_RecoverableSignatureNoneZ_get_err(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
3875 export function CResult_RecoverableSignatureNoneZ_get_err(owner: bigint): void {
3876 if(!isWasmInitialized) {
3877 throw new Error("initializeWasm() must be awaited first!");
3879 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_err(owner);
3880 // debug statements here
3883 export interface LDKChannelSigner {
3884 get_per_commitment_point (idx: bigint): number;
3885 release_commitment_secret (idx: bigint): number;
3886 validate_holder_commitment (holder_tx: bigint, preimages: number): bigint;
3887 channel_keys_id (): number;
3888 provide_channel_parameters (channel_parameters: bigint): void;
3892 export function LDKChannelSigner_new(impl: LDKChannelSigner, pubkeys: bigint): [bigint, number] {
3893 if(!isWasmInitialized) {
3894 throw new Error("initializeWasm() must be awaited first!");
3896 var new_obj_idx = js_objs.length;
3897 for (var i = 0; i < js_objs.length; i++) {
3898 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3900 js_objs[i] = new WeakRef(impl);
3901 return [wasm.TS_LDKChannelSigner_new(i, pubkeys), i];
3903 // LDKPublicKey ChannelSigner_get_per_commitment_point LDKChannelSigner *NONNULL_PTR this_arg, uint64_t idx
3905 export function ChannelSigner_get_per_commitment_point(this_arg: bigint, idx: bigint): number {
3906 if(!isWasmInitialized) {
3907 throw new Error("initializeWasm() must be awaited first!");
3909 const nativeResponseValue = wasm.TS_ChannelSigner_get_per_commitment_point(this_arg, idx);
3910 return nativeResponseValue;
3912 // LDKThirtyTwoBytes ChannelSigner_release_commitment_secret LDKChannelSigner *NONNULL_PTR this_arg, uint64_t idx
3914 export function ChannelSigner_release_commitment_secret(this_arg: bigint, idx: bigint): number {
3915 if(!isWasmInitialized) {
3916 throw new Error("initializeWasm() must be awaited first!");
3918 const nativeResponseValue = wasm.TS_ChannelSigner_release_commitment_secret(this_arg, idx);
3919 return nativeResponseValue;
3921 // LDKCResult_NoneNoneZ ChannelSigner_validate_holder_commitment LDKChannelSigner *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_PaymentPreimageZ preimages
3923 export function ChannelSigner_validate_holder_commitment(this_arg: bigint, holder_tx: bigint, preimages: number): bigint {
3924 if(!isWasmInitialized) {
3925 throw new Error("initializeWasm() must be awaited first!");
3927 const nativeResponseValue = wasm.TS_ChannelSigner_validate_holder_commitment(this_arg, holder_tx, preimages);
3928 return nativeResponseValue;
3930 // LDKThirtyTwoBytes ChannelSigner_channel_keys_id LDKChannelSigner *NONNULL_PTR this_arg
3932 export function ChannelSigner_channel_keys_id(this_arg: bigint): number {
3933 if(!isWasmInitialized) {
3934 throw new Error("initializeWasm() must be awaited first!");
3936 const nativeResponseValue = wasm.TS_ChannelSigner_channel_keys_id(this_arg);
3937 return nativeResponseValue;
3939 // void ChannelSigner_provide_channel_parameters LDKChannelSigner *NONNULL_PTR this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters
3941 export function ChannelSigner_provide_channel_parameters(this_arg: bigint, channel_parameters: bigint): void {
3942 if(!isWasmInitialized) {
3943 throw new Error("initializeWasm() must be awaited first!");
3945 const nativeResponseValue = wasm.TS_ChannelSigner_provide_channel_parameters(this_arg, channel_parameters);
3946 // debug statements here
3948 // LDKChannelPublicKeys ChannelSigner_get_pubkeys LDKChannelSigner *NONNULL_PTR this_arg
3950 export function ChannelSigner_get_pubkeys(this_arg: bigint): bigint {
3951 if(!isWasmInitialized) {
3952 throw new Error("initializeWasm() must be awaited first!");
3954 const nativeResponseValue = wasm.TS_ChannelSigner_get_pubkeys(this_arg);
3955 return nativeResponseValue;
3958 export interface LDKEcdsaChannelSigner {
3959 sign_counterparty_commitment (commitment_tx: bigint, preimages: number): bigint;
3960 validate_counterparty_revocation (idx: bigint, secret: number): bigint;
3961 sign_holder_commitment_and_htlcs (commitment_tx: bigint): bigint;
3962 sign_justice_revoked_output (justice_tx: number, input: number, amount: bigint, per_commitment_key: number): bigint;
3963 sign_justice_revoked_htlc (justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: bigint): bigint;
3964 sign_counterparty_htlc_transaction (htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: bigint): bigint;
3965 sign_closing_transaction (closing_tx: bigint): bigint;
3966 sign_holder_anchor_input (anchor_tx: number, input: number): bigint;
3967 sign_channel_announcement_with_funding_key (msg: bigint): bigint;
3971 export function LDKEcdsaChannelSigner_new(impl: LDKEcdsaChannelSigner, ChannelSigner: number, pubkeys: bigint): [bigint, number] {
3972 if(!isWasmInitialized) {
3973 throw new Error("initializeWasm() must be awaited first!");
3975 var new_obj_idx = js_objs.length;
3976 for (var i = 0; i < js_objs.length; i++) {
3977 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3979 js_objs[i] = new WeakRef(impl);
3980 return [wasm.TS_LDKEcdsaChannelSigner_new(i, ChannelSigner, pubkeys), i];
3982 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ EcdsaChannelSigner_sign_counterparty_commitment LDKEcdsaChannelSigner *NONNULL_PTR this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_PaymentPreimageZ preimages
3984 export function EcdsaChannelSigner_sign_counterparty_commitment(this_arg: bigint, commitment_tx: bigint, preimages: number): bigint {
3985 if(!isWasmInitialized) {
3986 throw new Error("initializeWasm() must be awaited first!");
3988 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_counterparty_commitment(this_arg, commitment_tx, preimages);
3989 return nativeResponseValue;
3991 // LDKCResult_NoneNoneZ EcdsaChannelSigner_validate_counterparty_revocation LDKEcdsaChannelSigner *NONNULL_PTR this_arg, uint64_t idx, const uint8_t (*secret)[32]
3993 export function EcdsaChannelSigner_validate_counterparty_revocation(this_arg: bigint, idx: bigint, secret: number): bigint {
3994 if(!isWasmInitialized) {
3995 throw new Error("initializeWasm() must be awaited first!");
3997 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_validate_counterparty_revocation(this_arg, idx, secret);
3998 return nativeResponseValue;
4000 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ EcdsaChannelSigner_sign_holder_commitment_and_htlcs LDKEcdsaChannelSigner *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx
4002 export function EcdsaChannelSigner_sign_holder_commitment_and_htlcs(this_arg: bigint, commitment_tx: bigint): bigint {
4003 if(!isWasmInitialized) {
4004 throw new Error("initializeWasm() must be awaited first!");
4006 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_holder_commitment_and_htlcs(this_arg, commitment_tx);
4007 return nativeResponseValue;
4009 // LDKCResult_SignatureNoneZ EcdsaChannelSigner_sign_justice_revoked_output LDKEcdsaChannelSigner *NONNULL_PTR this_arg, struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32]
4011 export function EcdsaChannelSigner_sign_justice_revoked_output(this_arg: bigint, justice_tx: number, input: number, amount: bigint, per_commitment_key: number): bigint {
4012 if(!isWasmInitialized) {
4013 throw new Error("initializeWasm() must be awaited first!");
4015 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_justice_revoked_output(this_arg, justice_tx, input, amount, per_commitment_key);
4016 return nativeResponseValue;
4018 // LDKCResult_SignatureNoneZ EcdsaChannelSigner_sign_justice_revoked_htlc LDKEcdsaChannelSigner *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
4020 export function EcdsaChannelSigner_sign_justice_revoked_htlc(this_arg: bigint, justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: bigint): bigint {
4021 if(!isWasmInitialized) {
4022 throw new Error("initializeWasm() must be awaited first!");
4024 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_justice_revoked_htlc(this_arg, justice_tx, input, amount, per_commitment_key, htlc);
4025 return nativeResponseValue;
4027 // LDKCResult_SignatureNoneZ EcdsaChannelSigner_sign_counterparty_htlc_transaction LDKEcdsaChannelSigner *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
4029 export function EcdsaChannelSigner_sign_counterparty_htlc_transaction(this_arg: bigint, htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: bigint): bigint {
4030 if(!isWasmInitialized) {
4031 throw new Error("initializeWasm() must be awaited first!");
4033 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_counterparty_htlc_transaction(this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
4034 return nativeResponseValue;
4036 // LDKCResult_SignatureNoneZ EcdsaChannelSigner_sign_closing_transaction LDKEcdsaChannelSigner *NONNULL_PTR this_arg, const struct LDKClosingTransaction *NONNULL_PTR closing_tx
4038 export function EcdsaChannelSigner_sign_closing_transaction(this_arg: bigint, closing_tx: bigint): bigint {
4039 if(!isWasmInitialized) {
4040 throw new Error("initializeWasm() must be awaited first!");
4042 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_closing_transaction(this_arg, closing_tx);
4043 return nativeResponseValue;
4045 // LDKCResult_SignatureNoneZ EcdsaChannelSigner_sign_holder_anchor_input LDKEcdsaChannelSigner *NONNULL_PTR this_arg, struct LDKTransaction anchor_tx, uintptr_t input
4047 export function EcdsaChannelSigner_sign_holder_anchor_input(this_arg: bigint, anchor_tx: number, input: number): bigint {
4048 if(!isWasmInitialized) {
4049 throw new Error("initializeWasm() must be awaited first!");
4051 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_holder_anchor_input(this_arg, anchor_tx, input);
4052 return nativeResponseValue;
4054 // LDKCResult_SignatureNoneZ EcdsaChannelSigner_sign_channel_announcement_with_funding_key LDKEcdsaChannelSigner *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg
4056 export function EcdsaChannelSigner_sign_channel_announcement_with_funding_key(this_arg: bigint, msg: bigint): bigint {
4057 if(!isWasmInitialized) {
4058 throw new Error("initializeWasm() must be awaited first!");
4060 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_channel_announcement_with_funding_key(this_arg, msg);
4061 return nativeResponseValue;
4064 export interface LDKWriteableEcdsaChannelSigner {
4069 export function LDKWriteableEcdsaChannelSigner_new(impl: LDKWriteableEcdsaChannelSigner, EcdsaChannelSigner: number, ChannelSigner: number, pubkeys: bigint): [bigint, number] {
4070 if(!isWasmInitialized) {
4071 throw new Error("initializeWasm() must be awaited first!");
4073 var new_obj_idx = js_objs.length;
4074 for (var i = 0; i < js_objs.length; i++) {
4075 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4077 js_objs[i] = new WeakRef(impl);
4078 return [wasm.TS_LDKWriteableEcdsaChannelSigner_new(i, EcdsaChannelSigner, ChannelSigner, pubkeys), i];
4080 // LDKCVec_u8Z WriteableEcdsaChannelSigner_write LDKWriteableEcdsaChannelSigner *NONNULL_PTR this_arg
4082 export function WriteableEcdsaChannelSigner_write(this_arg: bigint): number {
4083 if(!isWasmInitialized) {
4084 throw new Error("initializeWasm() must be awaited first!");
4086 const nativeResponseValue = wasm.TS_WriteableEcdsaChannelSigner_write(this_arg);
4087 return nativeResponseValue;
4089 // struct LDKWriteableEcdsaChannelSigner CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR owner);
4091 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok(owner: bigint): bigint {
4092 if(!isWasmInitialized) {
4093 throw new Error("initializeWasm() must be awaited first!");
4095 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok(owner);
4096 return nativeResponseValue;
4098 // struct LDKDecodeError CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR owner);
4100 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err(owner: bigint): bigint {
4101 if(!isWasmInitialized) {
4102 throw new Error("initializeWasm() must be awaited first!");
4104 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err(owner);
4105 return nativeResponseValue;
4107 // struct LDKCVec_CVec_u8ZZ CResult_CVec_CVec_u8ZZNoneZ_get_ok(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
4109 export function CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner: bigint): number {
4110 if(!isWasmInitialized) {
4111 throw new Error("initializeWasm() must be awaited first!");
4113 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner);
4114 return nativeResponseValue;
4116 // void CResult_CVec_CVec_u8ZZNoneZ_get_err(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
4118 export function CResult_CVec_CVec_u8ZZNoneZ_get_err(owner: bigint): void {
4119 if(!isWasmInitialized) {
4120 throw new Error("initializeWasm() must be awaited first!");
4122 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_err(owner);
4123 // debug statements here
4125 // struct LDKInMemorySigner CResult_InMemorySignerDecodeErrorZ_get_ok(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
4127 export function CResult_InMemorySignerDecodeErrorZ_get_ok(owner: bigint): bigint {
4128 if(!isWasmInitialized) {
4129 throw new Error("initializeWasm() must be awaited first!");
4131 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_ok(owner);
4132 return nativeResponseValue;
4134 // struct LDKDecodeError CResult_InMemorySignerDecodeErrorZ_get_err(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
4136 export function CResult_InMemorySignerDecodeErrorZ_get_err(owner: bigint): bigint {
4137 if(!isWasmInitialized) {
4138 throw new Error("initializeWasm() must be awaited first!");
4140 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_err(owner);
4141 return nativeResponseValue;
4143 // struct LDKTransaction CResult_TransactionNoneZ_get_ok(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
4145 export function CResult_TransactionNoneZ_get_ok(owner: bigint): number {
4146 if(!isWasmInitialized) {
4147 throw new Error("initializeWasm() must be awaited first!");
4149 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_ok(owner);
4150 return nativeResponseValue;
4152 // void CResult_TransactionNoneZ_get_err(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
4154 export function CResult_TransactionNoneZ_get_err(owner: bigint): void {
4155 if(!isWasmInitialized) {
4156 throw new Error("initializeWasm() must be awaited first!");
4158 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_err(owner);
4159 // debug statements here
4162 export class LDKCOption_u16Z {
4163 protected constructor() {}
4166 export function LDKCOption_u16Z_ty_from_ptr(ptr: bigint): number {
4167 if(!isWasmInitialized) {
4168 throw new Error("initializeWasm() must be awaited first!");
4170 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_ty_from_ptr(ptr);
4171 return nativeResponseValue;
4174 export function LDKCOption_u16Z_Some_get_some(ptr: bigint): number {
4175 if(!isWasmInitialized) {
4176 throw new Error("initializeWasm() must be awaited first!");
4178 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_Some_get_some(ptr);
4179 return nativeResponseValue;
4181 // struct LDKThirtyTwoBytes CResult__u832APIErrorZ_get_ok(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
4183 export function CResult__u832APIErrorZ_get_ok(owner: bigint): number {
4184 if(!isWasmInitialized) {
4185 throw new Error("initializeWasm() must be awaited first!");
4187 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_ok(owner);
4188 return nativeResponseValue;
4190 // struct LDKAPIError CResult__u832APIErrorZ_get_err(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
4192 export function CResult__u832APIErrorZ_get_err(owner: bigint): bigint {
4193 if(!isWasmInitialized) {
4194 throw new Error("initializeWasm() must be awaited first!");
4196 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_err(owner);
4197 return nativeResponseValue;
4200 export class LDKRecentPaymentDetails {
4201 protected constructor() {}
4204 export function LDKRecentPaymentDetails_ty_from_ptr(ptr: bigint): number {
4205 if(!isWasmInitialized) {
4206 throw new Error("initializeWasm() must be awaited first!");
4208 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_ty_from_ptr(ptr);
4209 return nativeResponseValue;
4212 export function LDKRecentPaymentDetails_Pending_get_payment_hash(ptr: bigint): number {
4213 if(!isWasmInitialized) {
4214 throw new Error("initializeWasm() must be awaited first!");
4216 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Pending_get_payment_hash(ptr);
4217 return nativeResponseValue;
4220 export function LDKRecentPaymentDetails_Pending_get_total_msat(ptr: bigint): bigint {
4221 if(!isWasmInitialized) {
4222 throw new Error("initializeWasm() must be awaited first!");
4224 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Pending_get_total_msat(ptr);
4225 return nativeResponseValue;
4228 export function LDKRecentPaymentDetails_Fulfilled_get_payment_hash(ptr: bigint): number {
4229 if(!isWasmInitialized) {
4230 throw new Error("initializeWasm() must be awaited first!");
4232 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Fulfilled_get_payment_hash(ptr);
4233 return nativeResponseValue;
4236 export function LDKRecentPaymentDetails_Abandoned_get_payment_hash(ptr: bigint): number {
4237 if(!isWasmInitialized) {
4238 throw new Error("initializeWasm() must be awaited first!");
4240 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Abandoned_get_payment_hash(ptr);
4241 return nativeResponseValue;
4244 export class LDKPaymentSendFailure {
4245 protected constructor() {}
4248 export function LDKPaymentSendFailure_ty_from_ptr(ptr: bigint): number {
4249 if(!isWasmInitialized) {
4250 throw new Error("initializeWasm() must be awaited first!");
4252 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ty_from_ptr(ptr);
4253 return nativeResponseValue;
4256 export function LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr: bigint): bigint {
4257 if(!isWasmInitialized) {
4258 throw new Error("initializeWasm() must be awaited first!");
4260 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr);
4261 return nativeResponseValue;
4264 export function LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr: bigint): number {
4265 if(!isWasmInitialized) {
4266 throw new Error("initializeWasm() must be awaited first!");
4268 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr);
4269 return nativeResponseValue;
4272 export function LDKPaymentSendFailure_AllFailedResendSafe_get_all_failed_resend_safe(ptr: bigint): number {
4273 if(!isWasmInitialized) {
4274 throw new Error("initializeWasm() must be awaited first!");
4276 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_AllFailedResendSafe_get_all_failed_resend_safe(ptr);
4277 return nativeResponseValue;
4280 export function LDKPaymentSendFailure_PartialFailure_get_results(ptr: bigint): number {
4281 if(!isWasmInitialized) {
4282 throw new Error("initializeWasm() must be awaited first!");
4284 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_results(ptr);
4285 return nativeResponseValue;
4288 export function LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr: bigint): bigint {
4289 if(!isWasmInitialized) {
4290 throw new Error("initializeWasm() must be awaited first!");
4292 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr);
4293 return nativeResponseValue;
4296 export function LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr: bigint): number {
4297 if(!isWasmInitialized) {
4298 throw new Error("initializeWasm() must be awaited first!");
4300 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr);
4301 return nativeResponseValue;
4303 // void CResult_NonePaymentSendFailureZ_get_ok(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
4305 export function CResult_NonePaymentSendFailureZ_get_ok(owner: bigint): void {
4306 if(!isWasmInitialized) {
4307 throw new Error("initializeWasm() must be awaited first!");
4309 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_ok(owner);
4310 // debug statements here
4312 // struct LDKPaymentSendFailure CResult_NonePaymentSendFailureZ_get_err(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
4314 export function CResult_NonePaymentSendFailureZ_get_err(owner: bigint): bigint {
4315 if(!isWasmInitialized) {
4316 throw new Error("initializeWasm() must be awaited first!");
4318 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_err(owner);
4319 return nativeResponseValue;
4321 // void CResult_NoneRetryableSendFailureZ_get_ok(LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR owner);
4323 export function CResult_NoneRetryableSendFailureZ_get_ok(owner: bigint): void {
4324 if(!isWasmInitialized) {
4325 throw new Error("initializeWasm() must be awaited first!");
4327 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_get_ok(owner);
4328 // debug statements here
4330 // enum LDKRetryableSendFailure CResult_NoneRetryableSendFailureZ_get_err(LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR owner);
4332 export function CResult_NoneRetryableSendFailureZ_get_err(owner: bigint): RetryableSendFailure {
4333 if(!isWasmInitialized) {
4334 throw new Error("initializeWasm() must be awaited first!");
4336 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_get_err(owner);
4337 return nativeResponseValue;
4339 // struct LDKThirtyTwoBytes CResult_PaymentHashPaymentSendFailureZ_get_ok(LDKCResult_PaymentHashPaymentSendFailureZ *NONNULL_PTR owner);
4341 export function CResult_PaymentHashPaymentSendFailureZ_get_ok(owner: bigint): number {
4342 if(!isWasmInitialized) {
4343 throw new Error("initializeWasm() must be awaited first!");
4345 const nativeResponseValue = wasm.TS_CResult_PaymentHashPaymentSendFailureZ_get_ok(owner);
4346 return nativeResponseValue;
4348 // struct LDKPaymentSendFailure CResult_PaymentHashPaymentSendFailureZ_get_err(LDKCResult_PaymentHashPaymentSendFailureZ *NONNULL_PTR owner);
4350 export function CResult_PaymentHashPaymentSendFailureZ_get_err(owner: bigint): bigint {
4351 if(!isWasmInitialized) {
4352 throw new Error("initializeWasm() must be awaited first!");
4354 const nativeResponseValue = wasm.TS_CResult_PaymentHashPaymentSendFailureZ_get_err(owner);
4355 return nativeResponseValue;
4357 // struct LDKThirtyTwoBytes CResult_PaymentHashRetryableSendFailureZ_get_ok(LDKCResult_PaymentHashRetryableSendFailureZ *NONNULL_PTR owner);
4359 export function CResult_PaymentHashRetryableSendFailureZ_get_ok(owner: bigint): number {
4360 if(!isWasmInitialized) {
4361 throw new Error("initializeWasm() must be awaited first!");
4363 const nativeResponseValue = wasm.TS_CResult_PaymentHashRetryableSendFailureZ_get_ok(owner);
4364 return nativeResponseValue;
4366 // enum LDKRetryableSendFailure CResult_PaymentHashRetryableSendFailureZ_get_err(LDKCResult_PaymentHashRetryableSendFailureZ *NONNULL_PTR owner);
4368 export function CResult_PaymentHashRetryableSendFailureZ_get_err(owner: bigint): RetryableSendFailure {
4369 if(!isWasmInitialized) {
4370 throw new Error("initializeWasm() must be awaited first!");
4372 const nativeResponseValue = wasm.TS_CResult_PaymentHashRetryableSendFailureZ_get_err(owner);
4373 return nativeResponseValue;
4375 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_a(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
4377 export function C2Tuple_PaymentHashPaymentIdZ_get_a(owner: bigint): number {
4378 if(!isWasmInitialized) {
4379 throw new Error("initializeWasm() must be awaited first!");
4381 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_a(owner);
4382 return nativeResponseValue;
4384 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_b(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
4386 export function C2Tuple_PaymentHashPaymentIdZ_get_b(owner: bigint): number {
4387 if(!isWasmInitialized) {
4388 throw new Error("initializeWasm() must be awaited first!");
4390 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_b(owner);
4391 return nativeResponseValue;
4393 // struct LDKC2Tuple_PaymentHashPaymentIdZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
4395 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner: bigint): bigint {
4396 if(!isWasmInitialized) {
4397 throw new Error("initializeWasm() must be awaited first!");
4399 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner);
4400 return nativeResponseValue;
4402 // struct LDKPaymentSendFailure CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
4404 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner: bigint): bigint {
4405 if(!isWasmInitialized) {
4406 throw new Error("initializeWasm() must be awaited first!");
4408 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner);
4409 return nativeResponseValue;
4411 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_a(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
4413 export function C2Tuple_PaymentHashPaymentSecretZ_get_a(owner: bigint): number {
4414 if(!isWasmInitialized) {
4415 throw new Error("initializeWasm() must be awaited first!");
4417 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_a(owner);
4418 return nativeResponseValue;
4420 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_b(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
4422 export function C2Tuple_PaymentHashPaymentSecretZ_get_b(owner: bigint): number {
4423 if(!isWasmInitialized) {
4424 throw new Error("initializeWasm() must be awaited first!");
4426 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_b(owner);
4427 return nativeResponseValue;
4429 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
4431 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner: bigint): bigint {
4432 if(!isWasmInitialized) {
4433 throw new Error("initializeWasm() must be awaited first!");
4435 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner);
4436 return nativeResponseValue;
4438 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
4440 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner: bigint): void {
4441 if(!isWasmInitialized) {
4442 throw new Error("initializeWasm() must be awaited first!");
4444 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner);
4445 // debug statements here
4447 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
4449 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner: bigint): bigint {
4450 if(!isWasmInitialized) {
4451 throw new Error("initializeWasm() must be awaited first!");
4453 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner);
4454 return nativeResponseValue;
4456 // struct LDKAPIError CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
4458 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner: bigint): bigint {
4459 if(!isWasmInitialized) {
4460 throw new Error("initializeWasm() must be awaited first!");
4462 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner);
4463 return nativeResponseValue;
4465 // struct LDKThirtyTwoBytes CResult_PaymentSecretNoneZ_get_ok(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
4467 export function CResult_PaymentSecretNoneZ_get_ok(owner: bigint): number {
4468 if(!isWasmInitialized) {
4469 throw new Error("initializeWasm() must be awaited first!");
4471 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_ok(owner);
4472 return nativeResponseValue;
4474 // void CResult_PaymentSecretNoneZ_get_err(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
4476 export function CResult_PaymentSecretNoneZ_get_err(owner: bigint): void {
4477 if(!isWasmInitialized) {
4478 throw new Error("initializeWasm() must be awaited first!");
4480 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_err(owner);
4481 // debug statements here
4483 // struct LDKThirtyTwoBytes CResult_PaymentSecretAPIErrorZ_get_ok(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
4485 export function CResult_PaymentSecretAPIErrorZ_get_ok(owner: bigint): number {
4486 if(!isWasmInitialized) {
4487 throw new Error("initializeWasm() must be awaited first!");
4489 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_ok(owner);
4490 return nativeResponseValue;
4492 // struct LDKAPIError CResult_PaymentSecretAPIErrorZ_get_err(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
4494 export function CResult_PaymentSecretAPIErrorZ_get_err(owner: bigint): bigint {
4495 if(!isWasmInitialized) {
4496 throw new Error("initializeWasm() must be awaited first!");
4498 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_err(owner);
4499 return nativeResponseValue;
4501 // struct LDKThirtyTwoBytes CResult_PaymentPreimageAPIErrorZ_get_ok(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
4503 export function CResult_PaymentPreimageAPIErrorZ_get_ok(owner: bigint): number {
4504 if(!isWasmInitialized) {
4505 throw new Error("initializeWasm() must be awaited first!");
4507 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_ok(owner);
4508 return nativeResponseValue;
4510 // struct LDKAPIError CResult_PaymentPreimageAPIErrorZ_get_err(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
4512 export function CResult_PaymentPreimageAPIErrorZ_get_err(owner: bigint): bigint {
4513 if(!isWasmInitialized) {
4514 throw new Error("initializeWasm() must be awaited first!");
4516 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_err(owner);
4517 return nativeResponseValue;
4519 // struct LDKCounterpartyForwardingInfo CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
4521 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
4522 if(!isWasmInitialized) {
4523 throw new Error("initializeWasm() must be awaited first!");
4525 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner);
4526 return nativeResponseValue;
4528 // struct LDKDecodeError CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
4530 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner: bigint): bigint {
4531 if(!isWasmInitialized) {
4532 throw new Error("initializeWasm() must be awaited first!");
4534 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner);
4535 return nativeResponseValue;
4537 // struct LDKChannelCounterparty CResult_ChannelCounterpartyDecodeErrorZ_get_ok(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
4539 export function CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner: bigint): bigint {
4540 if(!isWasmInitialized) {
4541 throw new Error("initializeWasm() must be awaited first!");
4543 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner);
4544 return nativeResponseValue;
4546 // struct LDKDecodeError CResult_ChannelCounterpartyDecodeErrorZ_get_err(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
4548 export function CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner: bigint): bigint {
4549 if(!isWasmInitialized) {
4550 throw new Error("initializeWasm() must be awaited first!");
4552 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner);
4553 return nativeResponseValue;
4555 // struct LDKChannelDetails CResult_ChannelDetailsDecodeErrorZ_get_ok(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
4557 export function CResult_ChannelDetailsDecodeErrorZ_get_ok(owner: bigint): bigint {
4558 if(!isWasmInitialized) {
4559 throw new Error("initializeWasm() must be awaited first!");
4561 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_ok(owner);
4562 return nativeResponseValue;
4564 // struct LDKDecodeError CResult_ChannelDetailsDecodeErrorZ_get_err(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
4566 export function CResult_ChannelDetailsDecodeErrorZ_get_err(owner: bigint): bigint {
4567 if(!isWasmInitialized) {
4568 throw new Error("initializeWasm() must be awaited first!");
4570 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_err(owner);
4571 return nativeResponseValue;
4573 // struct LDKPhantomRouteHints CResult_PhantomRouteHintsDecodeErrorZ_get_ok(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
4575 export function CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner: bigint): bigint {
4576 if(!isWasmInitialized) {
4577 throw new Error("initializeWasm() must be awaited first!");
4579 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner);
4580 return nativeResponseValue;
4582 // struct LDKDecodeError CResult_PhantomRouteHintsDecodeErrorZ_get_err(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
4584 export function CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner: bigint): bigint {
4585 if(!isWasmInitialized) {
4586 throw new Error("initializeWasm() must be awaited first!");
4588 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner);
4589 return nativeResponseValue;
4592 export interface LDKWatch {
4593 watch_channel (funding_txo: bigint, monitor: bigint): ChannelMonitorUpdateStatus;
4594 update_channel (funding_txo: bigint, update: bigint): ChannelMonitorUpdateStatus;
4595 release_pending_monitor_events (): number;
4599 export function LDKWatch_new(impl: LDKWatch): [bigint, number] {
4600 if(!isWasmInitialized) {
4601 throw new Error("initializeWasm() must be awaited first!");
4603 var new_obj_idx = js_objs.length;
4604 for (var i = 0; i < js_objs.length; i++) {
4605 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4607 js_objs[i] = new WeakRef(impl);
4608 return [wasm.TS_LDKWatch_new(i), i];
4610 // LDKChannelMonitorUpdateStatus Watch_watch_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor
4612 export function Watch_watch_channel(this_arg: bigint, funding_txo: bigint, monitor: bigint): ChannelMonitorUpdateStatus {
4613 if(!isWasmInitialized) {
4614 throw new Error("initializeWasm() must be awaited first!");
4616 const nativeResponseValue = wasm.TS_Watch_watch_channel(this_arg, funding_txo, monitor);
4617 return nativeResponseValue;
4619 // LDKChannelMonitorUpdateStatus Watch_update_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, const struct LDKChannelMonitorUpdate *NONNULL_PTR update
4621 export function Watch_update_channel(this_arg: bigint, funding_txo: bigint, update: bigint): ChannelMonitorUpdateStatus {
4622 if(!isWasmInitialized) {
4623 throw new Error("initializeWasm() must be awaited first!");
4625 const nativeResponseValue = wasm.TS_Watch_update_channel(this_arg, funding_txo, update);
4626 return nativeResponseValue;
4628 // LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Watch_release_pending_monitor_events LDKWatch *NONNULL_PTR this_arg
4630 export function Watch_release_pending_monitor_events(this_arg: bigint): number {
4631 if(!isWasmInitialized) {
4632 throw new Error("initializeWasm() must be awaited first!");
4634 const nativeResponseValue = wasm.TS_Watch_release_pending_monitor_events(this_arg);
4635 return nativeResponseValue;
4638 export interface LDKBroadcasterInterface {
4639 broadcast_transaction (tx: number): void;
4643 export function LDKBroadcasterInterface_new(impl: LDKBroadcasterInterface): [bigint, number] {
4644 if(!isWasmInitialized) {
4645 throw new Error("initializeWasm() must be awaited first!");
4647 var new_obj_idx = js_objs.length;
4648 for (var i = 0; i < js_objs.length; i++) {
4649 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4651 js_objs[i] = new WeakRef(impl);
4652 return [wasm.TS_LDKBroadcasterInterface_new(i), i];
4654 // void BroadcasterInterface_broadcast_transaction LDKBroadcasterInterface *NONNULL_PTR this_arg, struct LDKTransaction tx
4656 export function BroadcasterInterface_broadcast_transaction(this_arg: bigint, tx: number): void {
4657 if(!isWasmInitialized) {
4658 throw new Error("initializeWasm() must be awaited first!");
4660 const nativeResponseValue = wasm.TS_BroadcasterInterface_broadcast_transaction(this_arg, tx);
4661 // debug statements here
4664 export interface LDKEntropySource {
4665 get_secure_random_bytes (): number;
4669 export function LDKEntropySource_new(impl: LDKEntropySource): [bigint, number] {
4670 if(!isWasmInitialized) {
4671 throw new Error("initializeWasm() must be awaited first!");
4673 var new_obj_idx = js_objs.length;
4674 for (var i = 0; i < js_objs.length; i++) {
4675 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4677 js_objs[i] = new WeakRef(impl);
4678 return [wasm.TS_LDKEntropySource_new(i), i];
4680 // LDKThirtyTwoBytes EntropySource_get_secure_random_bytes LDKEntropySource *NONNULL_PTR this_arg
4682 export function EntropySource_get_secure_random_bytes(this_arg: bigint): number {
4683 if(!isWasmInitialized) {
4684 throw new Error("initializeWasm() must be awaited first!");
4686 const nativeResponseValue = wasm.TS_EntropySource_get_secure_random_bytes(this_arg);
4687 return nativeResponseValue;
4690 export class LDKUnsignedGossipMessage {
4691 protected constructor() {}
4694 export function LDKUnsignedGossipMessage_ty_from_ptr(ptr: bigint): number {
4695 if(!isWasmInitialized) {
4696 throw new Error("initializeWasm() must be awaited first!");
4698 const nativeResponseValue = wasm.TS_LDKUnsignedGossipMessage_ty_from_ptr(ptr);
4699 return nativeResponseValue;
4702 export function LDKUnsignedGossipMessage_ChannelAnnouncement_get_channel_announcement(ptr: bigint): bigint {
4703 if(!isWasmInitialized) {
4704 throw new Error("initializeWasm() must be awaited first!");
4706 const nativeResponseValue = wasm.TS_LDKUnsignedGossipMessage_ChannelAnnouncement_get_channel_announcement(ptr);
4707 return nativeResponseValue;
4710 export function LDKUnsignedGossipMessage_ChannelUpdate_get_channel_update(ptr: bigint): bigint {
4711 if(!isWasmInitialized) {
4712 throw new Error("initializeWasm() must be awaited first!");
4714 const nativeResponseValue = wasm.TS_LDKUnsignedGossipMessage_ChannelUpdate_get_channel_update(ptr);
4715 return nativeResponseValue;
4718 export function LDKUnsignedGossipMessage_NodeAnnouncement_get_node_announcement(ptr: bigint): bigint {
4719 if(!isWasmInitialized) {
4720 throw new Error("initializeWasm() must be awaited first!");
4722 const nativeResponseValue = wasm.TS_LDKUnsignedGossipMessage_NodeAnnouncement_get_node_announcement(ptr);
4723 return nativeResponseValue;
4726 export interface LDKNodeSigner {
4727 get_inbound_payment_key_material (): number;
4728 get_node_id (recipient: Recipient): bigint;
4729 ecdh (recipient: Recipient, other_key: number, tweak: bigint): bigint;
4730 sign_invoice (hrp_bytes: number, invoice_data: number, recipient: Recipient): bigint;
4731 sign_gossip_message (msg: bigint): bigint;
4735 export function LDKNodeSigner_new(impl: LDKNodeSigner): [bigint, number] {
4736 if(!isWasmInitialized) {
4737 throw new Error("initializeWasm() must be awaited first!");
4739 var new_obj_idx = js_objs.length;
4740 for (var i = 0; i < js_objs.length; i++) {
4741 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4743 js_objs[i] = new WeakRef(impl);
4744 return [wasm.TS_LDKNodeSigner_new(i), i];
4746 // LDKThirtyTwoBytes NodeSigner_get_inbound_payment_key_material LDKNodeSigner *NONNULL_PTR this_arg
4748 export function NodeSigner_get_inbound_payment_key_material(this_arg: bigint): number {
4749 if(!isWasmInitialized) {
4750 throw new Error("initializeWasm() must be awaited first!");
4752 const nativeResponseValue = wasm.TS_NodeSigner_get_inbound_payment_key_material(this_arg);
4753 return nativeResponseValue;
4755 // LDKCResult_PublicKeyNoneZ NodeSigner_get_node_id LDKNodeSigner *NONNULL_PTR this_arg, enum LDKRecipient recipient
4757 export function NodeSigner_get_node_id(this_arg: bigint, recipient: Recipient): bigint {
4758 if(!isWasmInitialized) {
4759 throw new Error("initializeWasm() must be awaited first!");
4761 const nativeResponseValue = wasm.TS_NodeSigner_get_node_id(this_arg, recipient);
4762 return nativeResponseValue;
4764 // LDKCResult_SharedSecretNoneZ NodeSigner_ecdh LDKNodeSigner *NONNULL_PTR this_arg, enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_ScalarZ tweak
4766 export function NodeSigner_ecdh(this_arg: bigint, recipient: Recipient, other_key: number, tweak: bigint): bigint {
4767 if(!isWasmInitialized) {
4768 throw new Error("initializeWasm() must be awaited first!");
4770 const nativeResponseValue = wasm.TS_NodeSigner_ecdh(this_arg, recipient, other_key, tweak);
4771 return nativeResponseValue;
4773 // LDKCResult_RecoverableSignatureNoneZ NodeSigner_sign_invoice LDKNodeSigner *NONNULL_PTR this_arg, struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z invoice_data, enum LDKRecipient recipient
4775 export function NodeSigner_sign_invoice(this_arg: bigint, hrp_bytes: number, invoice_data: number, recipient: Recipient): bigint {
4776 if(!isWasmInitialized) {
4777 throw new Error("initializeWasm() must be awaited first!");
4779 const nativeResponseValue = wasm.TS_NodeSigner_sign_invoice(this_arg, hrp_bytes, invoice_data, recipient);
4780 return nativeResponseValue;
4782 // LDKCResult_SignatureNoneZ NodeSigner_sign_gossip_message LDKNodeSigner *NONNULL_PTR this_arg, struct LDKUnsignedGossipMessage msg
4784 export function NodeSigner_sign_gossip_message(this_arg: bigint, msg: bigint): bigint {
4785 if(!isWasmInitialized) {
4786 throw new Error("initializeWasm() must be awaited first!");
4788 const nativeResponseValue = wasm.TS_NodeSigner_sign_gossip_message(this_arg, msg);
4789 return nativeResponseValue;
4792 export interface LDKSignerProvider {
4793 generate_channel_keys_id (inbound: boolean, channel_value_satoshis: bigint, user_channel_id: number): number;
4794 derive_channel_signer (channel_value_satoshis: bigint, channel_keys_id: number): bigint;
4795 read_chan_signer (reader: number): bigint;
4796 get_destination_script (): number;
4797 get_shutdown_scriptpubkey (): bigint;
4801 export function LDKSignerProvider_new(impl: LDKSignerProvider): [bigint, number] {
4802 if(!isWasmInitialized) {
4803 throw new Error("initializeWasm() must be awaited first!");
4805 var new_obj_idx = js_objs.length;
4806 for (var i = 0; i < js_objs.length; i++) {
4807 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4809 js_objs[i] = new WeakRef(impl);
4810 return [wasm.TS_LDKSignerProvider_new(i), i];
4812 // LDKThirtyTwoBytes SignerProvider_generate_channel_keys_id LDKSignerProvider *NONNULL_PTR this_arg, bool inbound, uint64_t channel_value_satoshis, struct LDKU128 user_channel_id
4814 export function SignerProvider_generate_channel_keys_id(this_arg: bigint, inbound: boolean, channel_value_satoshis: bigint, user_channel_id: number): number {
4815 if(!isWasmInitialized) {
4816 throw new Error("initializeWasm() must be awaited first!");
4818 const nativeResponseValue = wasm.TS_SignerProvider_generate_channel_keys_id(this_arg, inbound, channel_value_satoshis, user_channel_id);
4819 return nativeResponseValue;
4821 // LDKWriteableEcdsaChannelSigner SignerProvider_derive_channel_signer LDKSignerProvider *NONNULL_PTR this_arg, uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id
4823 export function SignerProvider_derive_channel_signer(this_arg: bigint, channel_value_satoshis: bigint, channel_keys_id: number): bigint {
4824 if(!isWasmInitialized) {
4825 throw new Error("initializeWasm() must be awaited first!");
4827 const nativeResponseValue = wasm.TS_SignerProvider_derive_channel_signer(this_arg, channel_value_satoshis, channel_keys_id);
4828 return nativeResponseValue;
4830 // LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ SignerProvider_read_chan_signer LDKSignerProvider *NONNULL_PTR this_arg, struct LDKu8slice reader
4832 export function SignerProvider_read_chan_signer(this_arg: bigint, reader: number): bigint {
4833 if(!isWasmInitialized) {
4834 throw new Error("initializeWasm() must be awaited first!");
4836 const nativeResponseValue = wasm.TS_SignerProvider_read_chan_signer(this_arg, reader);
4837 return nativeResponseValue;
4839 // LDKCVec_u8Z SignerProvider_get_destination_script LDKSignerProvider *NONNULL_PTR this_arg
4841 export function SignerProvider_get_destination_script(this_arg: bigint): number {
4842 if(!isWasmInitialized) {
4843 throw new Error("initializeWasm() must be awaited first!");
4845 const nativeResponseValue = wasm.TS_SignerProvider_get_destination_script(this_arg);
4846 return nativeResponseValue;
4848 // LDKShutdownScript SignerProvider_get_shutdown_scriptpubkey LDKSignerProvider *NONNULL_PTR this_arg
4850 export function SignerProvider_get_shutdown_scriptpubkey(this_arg: bigint): bigint {
4851 if(!isWasmInitialized) {
4852 throw new Error("initializeWasm() must be awaited first!");
4854 const nativeResponseValue = wasm.TS_SignerProvider_get_shutdown_scriptpubkey(this_arg);
4855 return nativeResponseValue;
4858 export interface LDKFeeEstimator {
4859 get_est_sat_per_1000_weight (confirmation_target: ConfirmationTarget): number;
4863 export function LDKFeeEstimator_new(impl: LDKFeeEstimator): [bigint, number] {
4864 if(!isWasmInitialized) {
4865 throw new Error("initializeWasm() must be awaited first!");
4867 var new_obj_idx = js_objs.length;
4868 for (var i = 0; i < js_objs.length; i++) {
4869 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4871 js_objs[i] = new WeakRef(impl);
4872 return [wasm.TS_LDKFeeEstimator_new(i), i];
4874 // uint32_t FeeEstimator_get_est_sat_per_1000_weight LDKFeeEstimator *NONNULL_PTR this_arg, enum LDKConfirmationTarget confirmation_target
4876 export function FeeEstimator_get_est_sat_per_1000_weight(this_arg: bigint, confirmation_target: ConfirmationTarget): number {
4877 if(!isWasmInitialized) {
4878 throw new Error("initializeWasm() must be awaited first!");
4880 const nativeResponseValue = wasm.TS_FeeEstimator_get_est_sat_per_1000_weight(this_arg, confirmation_target);
4881 return nativeResponseValue;
4884 export interface LDKRouter {
4885 find_route (payer: number, route_params: bigint, first_hops: number, inflight_htlcs: bigint): bigint;
4886 find_route_with_id (payer: number, route_params: bigint, first_hops: number, inflight_htlcs: bigint, _payment_hash: number, _payment_id: number): bigint;
4890 export function LDKRouter_new(impl: LDKRouter): [bigint, number] {
4891 if(!isWasmInitialized) {
4892 throw new Error("initializeWasm() must be awaited first!");
4894 var new_obj_idx = js_objs.length;
4895 for (var i = 0; i < js_objs.length; i++) {
4896 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4898 js_objs[i] = new WeakRef(impl);
4899 return [wasm.TS_LDKRouter_new(i), i];
4901 // LDKCResult_RouteLightningErrorZ Router_find_route LDKRouter *NONNULL_PTR this_arg, struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, struct LDKCVec_ChannelDetailsZ *first_hops, const struct LDKInFlightHtlcs *NONNULL_PTR inflight_htlcs
4903 export function Router_find_route(this_arg: bigint, payer: number, route_params: bigint, first_hops: number, inflight_htlcs: bigint): bigint {
4904 if(!isWasmInitialized) {
4905 throw new Error("initializeWasm() must be awaited first!");
4907 const nativeResponseValue = wasm.TS_Router_find_route(this_arg, payer, route_params, first_hops, inflight_htlcs);
4908 return nativeResponseValue;
4910 // LDKCResult_RouteLightningErrorZ Router_find_route_with_id LDKRouter *NONNULL_PTR this_arg, struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, struct LDKCVec_ChannelDetailsZ *first_hops, const struct LDKInFlightHtlcs *NONNULL_PTR inflight_htlcs, struct LDKThirtyTwoBytes _payment_hash, struct LDKThirtyTwoBytes _payment_id
4912 export function Router_find_route_with_id(this_arg: bigint, payer: number, route_params: bigint, first_hops: number, inflight_htlcs: bigint, _payment_hash: number, _payment_id: number): bigint {
4913 if(!isWasmInitialized) {
4914 throw new Error("initializeWasm() must be awaited first!");
4916 const nativeResponseValue = wasm.TS_Router_find_route_with_id(this_arg, payer, route_params, first_hops, inflight_htlcs, _payment_hash, _payment_id);
4917 return nativeResponseValue;
4919 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelManagerZ_get_a(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
4921 export function C2Tuple_BlockHashChannelManagerZ_get_a(owner: bigint): number {
4922 if(!isWasmInitialized) {
4923 throw new Error("initializeWasm() must be awaited first!");
4925 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_a(owner);
4926 return nativeResponseValue;
4928 // struct LDKChannelManager C2Tuple_BlockHashChannelManagerZ_get_b(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
4930 export function C2Tuple_BlockHashChannelManagerZ_get_b(owner: bigint): bigint {
4931 if(!isWasmInitialized) {
4932 throw new Error("initializeWasm() must be awaited first!");
4934 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_b(owner);
4935 return nativeResponseValue;
4937 // struct LDKC2Tuple_BlockHashChannelManagerZ *CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
4939 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner: bigint): bigint {
4940 if(!isWasmInitialized) {
4941 throw new Error("initializeWasm() must be awaited first!");
4943 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner);
4944 return nativeResponseValue;
4946 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
4948 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner: bigint): bigint {
4949 if(!isWasmInitialized) {
4950 throw new Error("initializeWasm() must be awaited first!");
4952 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner);
4953 return nativeResponseValue;
4955 // struct LDKChannelConfig CResult_ChannelConfigDecodeErrorZ_get_ok(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
4957 export function CResult_ChannelConfigDecodeErrorZ_get_ok(owner: bigint): bigint {
4958 if(!isWasmInitialized) {
4959 throw new Error("initializeWasm() must be awaited first!");
4961 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_ok(owner);
4962 return nativeResponseValue;
4964 // struct LDKDecodeError CResult_ChannelConfigDecodeErrorZ_get_err(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
4966 export function CResult_ChannelConfigDecodeErrorZ_get_err(owner: bigint): bigint {
4967 if(!isWasmInitialized) {
4968 throw new Error("initializeWasm() must be awaited first!");
4970 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_err(owner);
4971 return nativeResponseValue;
4974 export class LDKCOption_APIErrorZ {
4975 protected constructor() {}
4978 export function LDKCOption_APIErrorZ_ty_from_ptr(ptr: bigint): number {
4979 if(!isWasmInitialized) {
4980 throw new Error("initializeWasm() must be awaited first!");
4982 const nativeResponseValue = wasm.TS_LDKCOption_APIErrorZ_ty_from_ptr(ptr);
4983 return nativeResponseValue;
4986 export function LDKCOption_APIErrorZ_Some_get_some(ptr: bigint): bigint {
4987 if(!isWasmInitialized) {
4988 throw new Error("initializeWasm() must be awaited first!");
4990 const nativeResponseValue = wasm.TS_LDKCOption_APIErrorZ_Some_get_some(ptr);
4991 return nativeResponseValue;
4993 // struct LDKCOption_APIErrorZ CResult_COption_APIErrorZDecodeErrorZ_get_ok(LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR owner);
4995 export function CResult_COption_APIErrorZDecodeErrorZ_get_ok(owner: bigint): bigint {
4996 if(!isWasmInitialized) {
4997 throw new Error("initializeWasm() must be awaited first!");
4999 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_get_ok(owner);
5000 return nativeResponseValue;
5002 // struct LDKDecodeError CResult_COption_APIErrorZDecodeErrorZ_get_err(LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR owner);
5004 export function CResult_COption_APIErrorZDecodeErrorZ_get_err(owner: bigint): bigint {
5005 if(!isWasmInitialized) {
5006 throw new Error("initializeWasm() must be awaited first!");
5008 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_get_err(owner);
5009 return nativeResponseValue;
5011 // struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
5013 export function CResult_OutPointDecodeErrorZ_get_ok(owner: bigint): bigint {
5014 if(!isWasmInitialized) {
5015 throw new Error("initializeWasm() must be awaited first!");
5017 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_ok(owner);
5018 return nativeResponseValue;
5020 // struct LDKDecodeError CResult_OutPointDecodeErrorZ_get_err(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
5022 export function CResult_OutPointDecodeErrorZ_get_err(owner: bigint): bigint {
5023 if(!isWasmInitialized) {
5024 throw new Error("initializeWasm() must be awaited first!");
5026 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_err(owner);
5027 return nativeResponseValue;
5030 export interface LDKType {
5032 debug_str (): number;
5037 export function LDKType_new(impl: LDKType): [bigint, number] {
5038 if(!isWasmInitialized) {
5039 throw new Error("initializeWasm() must be awaited first!");
5041 var new_obj_idx = js_objs.length;
5042 for (var i = 0; i < js_objs.length; i++) {
5043 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5045 js_objs[i] = new WeakRef(impl);
5046 return [wasm.TS_LDKType_new(i), i];
5048 // uint16_t Type_type_id LDKType *NONNULL_PTR this_arg
5050 export function Type_type_id(this_arg: bigint): number {
5051 if(!isWasmInitialized) {
5052 throw new Error("initializeWasm() must be awaited first!");
5054 const nativeResponseValue = wasm.TS_Type_type_id(this_arg);
5055 return nativeResponseValue;
5057 // LDKStr Type_debug_str LDKType *NONNULL_PTR this_arg
5059 export function Type_debug_str(this_arg: bigint): number {
5060 if(!isWasmInitialized) {
5061 throw new Error("initializeWasm() must be awaited first!");
5063 const nativeResponseValue = wasm.TS_Type_debug_str(this_arg);
5064 return nativeResponseValue;
5066 // LDKCVec_u8Z Type_write LDKType *NONNULL_PTR this_arg
5068 export function Type_write(this_arg: bigint): number {
5069 if(!isWasmInitialized) {
5070 throw new Error("initializeWasm() must be awaited first!");
5072 const nativeResponseValue = wasm.TS_Type_write(this_arg);
5073 return nativeResponseValue;
5076 export class LDKCOption_TypeZ {
5077 protected constructor() {}
5080 export function LDKCOption_TypeZ_ty_from_ptr(ptr: bigint): number {
5081 if(!isWasmInitialized) {
5082 throw new Error("initializeWasm() must be awaited first!");
5084 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_ty_from_ptr(ptr);
5085 return nativeResponseValue;
5088 export function LDKCOption_TypeZ_Some_get_some(ptr: bigint): bigint {
5089 if(!isWasmInitialized) {
5090 throw new Error("initializeWasm() must be awaited first!");
5092 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_Some_get_some(ptr);
5093 return nativeResponseValue;
5095 // struct LDKCOption_TypeZ CResult_COption_TypeZDecodeErrorZ_get_ok(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
5097 export function CResult_COption_TypeZDecodeErrorZ_get_ok(owner: bigint): bigint {
5098 if(!isWasmInitialized) {
5099 throw new Error("initializeWasm() must be awaited first!");
5101 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_ok(owner);
5102 return nativeResponseValue;
5104 // struct LDKDecodeError CResult_COption_TypeZDecodeErrorZ_get_err(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
5106 export function CResult_COption_TypeZDecodeErrorZ_get_err(owner: bigint): bigint {
5107 if(!isWasmInitialized) {
5108 throw new Error("initializeWasm() must be awaited first!");
5110 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_err(owner);
5111 return nativeResponseValue;
5114 export class LDKPaymentError {
5115 protected constructor() {}
5118 export function LDKPaymentError_ty_from_ptr(ptr: bigint): number {
5119 if(!isWasmInitialized) {
5120 throw new Error("initializeWasm() must be awaited first!");
5122 const nativeResponseValue = wasm.TS_LDKPaymentError_ty_from_ptr(ptr);
5123 return nativeResponseValue;
5126 export function LDKPaymentError_Invoice_get_invoice(ptr: bigint): number {
5127 if(!isWasmInitialized) {
5128 throw new Error("initializeWasm() must be awaited first!");
5130 const nativeResponseValue = wasm.TS_LDKPaymentError_Invoice_get_invoice(ptr);
5131 return nativeResponseValue;
5134 export function LDKPaymentError_Sending_get_sending(ptr: bigint): RetryableSendFailure {
5135 if(!isWasmInitialized) {
5136 throw new Error("initializeWasm() must be awaited first!");
5138 const nativeResponseValue = wasm.TS_LDKPaymentError_Sending_get_sending(ptr);
5139 return nativeResponseValue;
5141 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentErrorZ_get_ok(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
5143 export function CResult_PaymentIdPaymentErrorZ_get_ok(owner: bigint): number {
5144 if(!isWasmInitialized) {
5145 throw new Error("initializeWasm() must be awaited first!");
5147 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_ok(owner);
5148 return nativeResponseValue;
5150 // struct LDKPaymentError CResult_PaymentIdPaymentErrorZ_get_err(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
5152 export function CResult_PaymentIdPaymentErrorZ_get_err(owner: bigint): bigint {
5153 if(!isWasmInitialized) {
5154 throw new Error("initializeWasm() must be awaited first!");
5156 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_err(owner);
5157 return nativeResponseValue;
5159 // void CResult_NonePaymentErrorZ_get_ok(LDKCResult_NonePaymentErrorZ *NONNULL_PTR owner);
5161 export function CResult_NonePaymentErrorZ_get_ok(owner: bigint): void {
5162 if(!isWasmInitialized) {
5163 throw new Error("initializeWasm() must be awaited first!");
5165 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_get_ok(owner);
5166 // debug statements here
5168 // struct LDKPaymentError CResult_NonePaymentErrorZ_get_err(LDKCResult_NonePaymentErrorZ *NONNULL_PTR owner);
5170 export function CResult_NonePaymentErrorZ_get_err(owner: bigint): bigint {
5171 if(!isWasmInitialized) {
5172 throw new Error("initializeWasm() must be awaited first!");
5174 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_get_err(owner);
5175 return nativeResponseValue;
5177 // struct LDKStr CResult_StringErrorZ_get_ok(LDKCResult_StringErrorZ *NONNULL_PTR owner);
5179 export function CResult_StringErrorZ_get_ok(owner: bigint): number {
5180 if(!isWasmInitialized) {
5181 throw new Error("initializeWasm() must be awaited first!");
5183 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_ok(owner);
5184 return nativeResponseValue;
5186 // enum LDKSecp256k1Error CResult_StringErrorZ_get_err(LDKCResult_StringErrorZ *NONNULL_PTR owner);
5188 export function CResult_StringErrorZ_get_err(owner: bigint): Secp256k1Error {
5189 if(!isWasmInitialized) {
5190 throw new Error("initializeWasm() must be awaited first!");
5192 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_err(owner);
5193 return nativeResponseValue;
5195 // struct LDKPublicKey CResult_PublicKeyErrorZ_get_ok(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
5197 export function CResult_PublicKeyErrorZ_get_ok(owner: bigint): number {
5198 if(!isWasmInitialized) {
5199 throw new Error("initializeWasm() must be awaited first!");
5201 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_ok(owner);
5202 return nativeResponseValue;
5204 // enum LDKSecp256k1Error CResult_PublicKeyErrorZ_get_err(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
5206 export function CResult_PublicKeyErrorZ_get_err(owner: bigint): Secp256k1Error {
5207 if(!isWasmInitialized) {
5208 throw new Error("initializeWasm() must be awaited first!");
5210 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_err(owner);
5211 return nativeResponseValue;
5213 // struct LDKChannelMonitorUpdate CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
5215 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
5216 if(!isWasmInitialized) {
5217 throw new Error("initializeWasm() must be awaited first!");
5219 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner);
5220 return nativeResponseValue;
5222 // struct LDKDecodeError CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
5224 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
5225 if(!isWasmInitialized) {
5226 throw new Error("initializeWasm() must be awaited first!");
5228 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner);
5229 return nativeResponseValue;
5232 export class LDKCOption_MonitorEventZ {
5233 protected constructor() {}
5236 export function LDKCOption_MonitorEventZ_ty_from_ptr(ptr: bigint): number {
5237 if(!isWasmInitialized) {
5238 throw new Error("initializeWasm() must be awaited first!");
5240 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_ty_from_ptr(ptr);
5241 return nativeResponseValue;
5244 export function LDKCOption_MonitorEventZ_Some_get_some(ptr: bigint): bigint {
5245 if(!isWasmInitialized) {
5246 throw new Error("initializeWasm() must be awaited first!");
5248 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_Some_get_some(ptr);
5249 return nativeResponseValue;
5251 // struct LDKCOption_MonitorEventZ CResult_COption_MonitorEventZDecodeErrorZ_get_ok(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
5253 export function CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner: bigint): bigint {
5254 if(!isWasmInitialized) {
5255 throw new Error("initializeWasm() must be awaited first!");
5257 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner);
5258 return nativeResponseValue;
5260 // struct LDKDecodeError CResult_COption_MonitorEventZDecodeErrorZ_get_err(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
5262 export function CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner: bigint): bigint {
5263 if(!isWasmInitialized) {
5264 throw new Error("initializeWasm() must be awaited first!");
5266 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner);
5267 return nativeResponseValue;
5269 // struct LDKHTLCUpdate CResult_HTLCUpdateDecodeErrorZ_get_ok(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
5271 export function CResult_HTLCUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
5272 if(!isWasmInitialized) {
5273 throw new Error("initializeWasm() must be awaited first!");
5275 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_ok(owner);
5276 return nativeResponseValue;
5278 // struct LDKDecodeError CResult_HTLCUpdateDecodeErrorZ_get_err(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
5280 export function CResult_HTLCUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
5281 if(!isWasmInitialized) {
5282 throw new Error("initializeWasm() must be awaited first!");
5284 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_err(owner);
5285 return nativeResponseValue;
5287 // struct LDKOutPoint C2Tuple_OutPointScriptZ_get_a(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
5289 export function C2Tuple_OutPointScriptZ_get_a(owner: bigint): bigint {
5290 if(!isWasmInitialized) {
5291 throw new Error("initializeWasm() must be awaited first!");
5293 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_a(owner);
5294 return nativeResponseValue;
5296 // struct LDKCVec_u8Z C2Tuple_OutPointScriptZ_get_b(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
5298 export function C2Tuple_OutPointScriptZ_get_b(owner: bigint): number {
5299 if(!isWasmInitialized) {
5300 throw new Error("initializeWasm() must be awaited first!");
5302 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_b(owner);
5303 return nativeResponseValue;
5305 // uint32_t C2Tuple_u32ScriptZ_get_a(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
5307 export function C2Tuple_u32ScriptZ_get_a(owner: bigint): number {
5308 if(!isWasmInitialized) {
5309 throw new Error("initializeWasm() must be awaited first!");
5311 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_a(owner);
5312 return nativeResponseValue;
5314 // struct LDKCVec_u8Z C2Tuple_u32ScriptZ_get_b(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
5316 export function C2Tuple_u32ScriptZ_get_b(owner: bigint): number {
5317 if(!isWasmInitialized) {
5318 throw new Error("initializeWasm() must be awaited first!");
5320 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_b(owner);
5321 return nativeResponseValue;
5323 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
5325 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner: bigint): number {
5326 if(!isWasmInitialized) {
5327 throw new Error("initializeWasm() must be awaited first!");
5329 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner);
5330 return nativeResponseValue;
5332 // struct LDKCVec_C2Tuple_u32ScriptZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
5334 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner: bigint): number {
5335 if(!isWasmInitialized) {
5336 throw new Error("initializeWasm() must be awaited first!");
5338 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner);
5339 return nativeResponseValue;
5341 // uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
5343 export function C2Tuple_u32TxOutZ_get_a(owner: bigint): number {
5344 if(!isWasmInitialized) {
5345 throw new Error("initializeWasm() must be awaited first!");
5347 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_a(owner);
5348 return nativeResponseValue;
5350 // struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
5352 export function C2Tuple_u32TxOutZ_get_b(owner: bigint): bigint {
5353 if(!isWasmInitialized) {
5354 throw new Error("initializeWasm() must be awaited first!");
5356 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_b(owner);
5357 return nativeResponseValue;
5359 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
5361 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner: bigint): number {
5362 if(!isWasmInitialized) {
5363 throw new Error("initializeWasm() must be awaited first!");
5365 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner);
5366 return nativeResponseValue;
5368 // struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
5370 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner: bigint): number {
5371 if(!isWasmInitialized) {
5372 throw new Error("initializeWasm() must be awaited first!");
5374 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner);
5375 return nativeResponseValue;
5378 export class LDKBalance {
5379 protected constructor() {}
5382 export function LDKBalance_ty_from_ptr(ptr: bigint): number {
5383 if(!isWasmInitialized) {
5384 throw new Error("initializeWasm() must be awaited first!");
5386 const nativeResponseValue = wasm.TS_LDKBalance_ty_from_ptr(ptr);
5387 return nativeResponseValue;
5390 export function LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr: bigint): bigint {
5391 if(!isWasmInitialized) {
5392 throw new Error("initializeWasm() must be awaited first!");
5394 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr);
5395 return nativeResponseValue;
5398 export function LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr: bigint): bigint {
5399 if(!isWasmInitialized) {
5400 throw new Error("initializeWasm() must be awaited first!");
5402 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr);
5403 return nativeResponseValue;
5406 export function LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr: bigint): number {
5407 if(!isWasmInitialized) {
5408 throw new Error("initializeWasm() must be awaited first!");
5410 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr);
5411 return nativeResponseValue;
5414 export function LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr: bigint): bigint {
5415 if(!isWasmInitialized) {
5416 throw new Error("initializeWasm() must be awaited first!");
5418 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr);
5419 return nativeResponseValue;
5422 export function LDKBalance_ContentiousClaimable_get_timeout_height(ptr: bigint): number {
5423 if(!isWasmInitialized) {
5424 throw new Error("initializeWasm() must be awaited first!");
5426 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_timeout_height(ptr);
5427 return nativeResponseValue;
5430 export function LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_amount_satoshis(ptr: bigint): bigint {
5431 if(!isWasmInitialized) {
5432 throw new Error("initializeWasm() must be awaited first!");
5434 const nativeResponseValue = wasm.TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_amount_satoshis(ptr);
5435 return nativeResponseValue;
5438 export function LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_height(ptr: bigint): number {
5439 if(!isWasmInitialized) {
5440 throw new Error("initializeWasm() must be awaited first!");
5442 const nativeResponseValue = wasm.TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_height(ptr);
5443 return nativeResponseValue;
5446 export function LDKBalance_MaybePreimageClaimableHTLC_get_claimable_amount_satoshis(ptr: bigint): bigint {
5447 if(!isWasmInitialized) {
5448 throw new Error("initializeWasm() must be awaited first!");
5450 const nativeResponseValue = wasm.TS_LDKBalance_MaybePreimageClaimableHTLC_get_claimable_amount_satoshis(ptr);
5451 return nativeResponseValue;
5454 export function LDKBalance_MaybePreimageClaimableHTLC_get_expiry_height(ptr: bigint): number {
5455 if(!isWasmInitialized) {
5456 throw new Error("initializeWasm() must be awaited first!");
5458 const nativeResponseValue = wasm.TS_LDKBalance_MaybePreimageClaimableHTLC_get_expiry_height(ptr);
5459 return nativeResponseValue;
5462 export function LDKBalance_CounterpartyRevokedOutputClaimable_get_claimable_amount_satoshis(ptr: bigint): bigint {
5463 if(!isWasmInitialized) {
5464 throw new Error("initializeWasm() must be awaited first!");
5466 const nativeResponseValue = wasm.TS_LDKBalance_CounterpartyRevokedOutputClaimable_get_claimable_amount_satoshis(ptr);
5467 return nativeResponseValue;
5469 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelMonitorZ_get_a(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
5471 export function C2Tuple_BlockHashChannelMonitorZ_get_a(owner: bigint): number {
5472 if(!isWasmInitialized) {
5473 throw new Error("initializeWasm() must be awaited first!");
5475 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_a(owner);
5476 return nativeResponseValue;
5478 // struct LDKChannelMonitor C2Tuple_BlockHashChannelMonitorZ_get_b(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
5480 export function C2Tuple_BlockHashChannelMonitorZ_get_b(owner: bigint): bigint {
5481 if(!isWasmInitialized) {
5482 throw new Error("initializeWasm() must be awaited first!");
5484 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_b(owner);
5485 return nativeResponseValue;
5487 // struct LDKC2Tuple_BlockHashChannelMonitorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
5489 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner: bigint): bigint {
5490 if(!isWasmInitialized) {
5491 throw new Error("initializeWasm() must be awaited first!");
5493 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner);
5494 return nativeResponseValue;
5496 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
5498 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner: bigint): bigint {
5499 if(!isWasmInitialized) {
5500 throw new Error("initializeWasm() must be awaited first!");
5502 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner);
5503 return nativeResponseValue;
5505 // struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
5507 export function C2Tuple_PublicKeyTypeZ_get_a(owner: bigint): number {
5508 if(!isWasmInitialized) {
5509 throw new Error("initializeWasm() must be awaited first!");
5511 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_a(owner);
5512 return nativeResponseValue;
5514 // struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
5516 export function C2Tuple_PublicKeyTypeZ_get_b(owner: bigint): bigint {
5517 if(!isWasmInitialized) {
5518 throw new Error("initializeWasm() must be awaited first!");
5520 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_b(owner);
5521 return nativeResponseValue;
5524 export interface LDKCustomOnionMessageContents {
5525 tlv_type (): bigint;
5530 export function LDKCustomOnionMessageContents_new(impl: LDKCustomOnionMessageContents): [bigint, number] {
5531 if(!isWasmInitialized) {
5532 throw new Error("initializeWasm() must be awaited first!");
5534 var new_obj_idx = js_objs.length;
5535 for (var i = 0; i < js_objs.length; i++) {
5536 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5538 js_objs[i] = new WeakRef(impl);
5539 return [wasm.TS_LDKCustomOnionMessageContents_new(i), i];
5541 // uint64_t CustomOnionMessageContents_tlv_type LDKCustomOnionMessageContents *NONNULL_PTR this_arg
5543 export function CustomOnionMessageContents_tlv_type(this_arg: bigint): bigint {
5544 if(!isWasmInitialized) {
5545 throw new Error("initializeWasm() must be awaited first!");
5547 const nativeResponseValue = wasm.TS_CustomOnionMessageContents_tlv_type(this_arg);
5548 return nativeResponseValue;
5550 // LDKCVec_u8Z CustomOnionMessageContents_write LDKCustomOnionMessageContents *NONNULL_PTR this_arg
5552 export function CustomOnionMessageContents_write(this_arg: bigint): number {
5553 if(!isWasmInitialized) {
5554 throw new Error("initializeWasm() must be awaited first!");
5556 const nativeResponseValue = wasm.TS_CustomOnionMessageContents_write(this_arg);
5557 return nativeResponseValue;
5560 export class LDKCOption_CustomOnionMessageContentsZ {
5561 protected constructor() {}
5564 export function LDKCOption_CustomOnionMessageContentsZ_ty_from_ptr(ptr: bigint): number {
5565 if(!isWasmInitialized) {
5566 throw new Error("initializeWasm() must be awaited first!");
5568 const nativeResponseValue = wasm.TS_LDKCOption_CustomOnionMessageContentsZ_ty_from_ptr(ptr);
5569 return nativeResponseValue;
5572 export function LDKCOption_CustomOnionMessageContentsZ_Some_get_some(ptr: bigint): bigint {
5573 if(!isWasmInitialized) {
5574 throw new Error("initializeWasm() must be awaited first!");
5576 const nativeResponseValue = wasm.TS_LDKCOption_CustomOnionMessageContentsZ_Some_get_some(ptr);
5577 return nativeResponseValue;
5579 // struct LDKCOption_CustomOnionMessageContentsZ CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR owner);
5581 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok(owner: bigint): bigint {
5582 if(!isWasmInitialized) {
5583 throw new Error("initializeWasm() must be awaited first!");
5585 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok(owner);
5586 return nativeResponseValue;
5588 // struct LDKDecodeError CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR owner);
5590 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err(owner: bigint): bigint {
5591 if(!isWasmInitialized) {
5592 throw new Error("initializeWasm() must be awaited first!");
5594 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err(owner);
5595 return nativeResponseValue;
5598 export class LDKCOption_NetAddressZ {
5599 protected constructor() {}
5602 export function LDKCOption_NetAddressZ_ty_from_ptr(ptr: bigint): number {
5603 if(!isWasmInitialized) {
5604 throw new Error("initializeWasm() must be awaited first!");
5606 const nativeResponseValue = wasm.TS_LDKCOption_NetAddressZ_ty_from_ptr(ptr);
5607 return nativeResponseValue;
5610 export function LDKCOption_NetAddressZ_Some_get_some(ptr: bigint): bigint {
5611 if(!isWasmInitialized) {
5612 throw new Error("initializeWasm() must be awaited first!");
5614 const nativeResponseValue = wasm.TS_LDKCOption_NetAddressZ_Some_get_some(ptr);
5615 return nativeResponseValue;
5617 // struct LDKPublicKey C2Tuple_PublicKeyCOption_NetAddressZZ_get_a(LDKC2Tuple_PublicKeyCOption_NetAddressZZ *NONNULL_PTR owner);
5619 export function C2Tuple_PublicKeyCOption_NetAddressZZ_get_a(owner: bigint): number {
5620 if(!isWasmInitialized) {
5621 throw new Error("initializeWasm() must be awaited first!");
5623 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_NetAddressZZ_get_a(owner);
5624 return nativeResponseValue;
5626 // struct LDKCOption_NetAddressZ C2Tuple_PublicKeyCOption_NetAddressZZ_get_b(LDKC2Tuple_PublicKeyCOption_NetAddressZZ *NONNULL_PTR owner);
5628 export function C2Tuple_PublicKeyCOption_NetAddressZZ_get_b(owner: bigint): bigint {
5629 if(!isWasmInitialized) {
5630 throw new Error("initializeWasm() must be awaited first!");
5632 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_NetAddressZZ_get_b(owner);
5633 return nativeResponseValue;
5635 // struct LDKCVec_u8Z CResult_CVec_u8ZPeerHandleErrorZ_get_ok(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
5637 export function CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner: bigint): number {
5638 if(!isWasmInitialized) {
5639 throw new Error("initializeWasm() must be awaited first!");
5641 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner);
5642 return nativeResponseValue;
5644 // struct LDKPeerHandleError CResult_CVec_u8ZPeerHandleErrorZ_get_err(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
5646 export function CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner: bigint): bigint {
5647 if(!isWasmInitialized) {
5648 throw new Error("initializeWasm() must be awaited first!");
5650 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner);
5651 return nativeResponseValue;
5653 // void CResult_NonePeerHandleErrorZ_get_ok(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
5655 export function CResult_NonePeerHandleErrorZ_get_ok(owner: bigint): void {
5656 if(!isWasmInitialized) {
5657 throw new Error("initializeWasm() must be awaited first!");
5659 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_ok(owner);
5660 // debug statements here
5662 // struct LDKPeerHandleError CResult_NonePeerHandleErrorZ_get_err(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
5664 export function CResult_NonePeerHandleErrorZ_get_err(owner: bigint): bigint {
5665 if(!isWasmInitialized) {
5666 throw new Error("initializeWasm() must be awaited first!");
5668 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_err(owner);
5669 return nativeResponseValue;
5671 // bool CResult_boolPeerHandleErrorZ_get_ok(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
5673 export function CResult_boolPeerHandleErrorZ_get_ok(owner: bigint): boolean {
5674 if(!isWasmInitialized) {
5675 throw new Error("initializeWasm() must be awaited first!");
5677 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_ok(owner);
5678 return nativeResponseValue;
5680 // struct LDKPeerHandleError CResult_boolPeerHandleErrorZ_get_err(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
5682 export function CResult_boolPeerHandleErrorZ_get_err(owner: bigint): bigint {
5683 if(!isWasmInitialized) {
5684 throw new Error("initializeWasm() must be awaited first!");
5686 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_err(owner);
5687 return nativeResponseValue;
5690 export class LDKSendError {
5691 protected constructor() {}
5694 export function LDKSendError_ty_from_ptr(ptr: bigint): number {
5695 if(!isWasmInitialized) {
5696 throw new Error("initializeWasm() must be awaited first!");
5698 const nativeResponseValue = wasm.TS_LDKSendError_ty_from_ptr(ptr);
5699 return nativeResponseValue;
5702 export function LDKSendError_Secp256k1_get_secp256k1(ptr: bigint): Secp256k1Error {
5703 if(!isWasmInitialized) {
5704 throw new Error("initializeWasm() must be awaited first!");
5706 const nativeResponseValue = wasm.TS_LDKSendError_Secp256k1_get_secp256k1(ptr);
5707 return nativeResponseValue;
5709 // void CResult_NoneSendErrorZ_get_ok(LDKCResult_NoneSendErrorZ *NONNULL_PTR owner);
5711 export function CResult_NoneSendErrorZ_get_ok(owner: bigint): void {
5712 if(!isWasmInitialized) {
5713 throw new Error("initializeWasm() must be awaited first!");
5715 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_get_ok(owner);
5716 // debug statements here
5718 // struct LDKSendError CResult_NoneSendErrorZ_get_err(LDKCResult_NoneSendErrorZ *NONNULL_PTR owner);
5720 export function CResult_NoneSendErrorZ_get_err(owner: bigint): bigint {
5721 if(!isWasmInitialized) {
5722 throw new Error("initializeWasm() must be awaited first!");
5724 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_get_err(owner);
5725 return nativeResponseValue;
5728 export class LDKGraphSyncError {
5729 protected constructor() {}
5732 export function LDKGraphSyncError_ty_from_ptr(ptr: bigint): number {
5733 if(!isWasmInitialized) {
5734 throw new Error("initializeWasm() must be awaited first!");
5736 const nativeResponseValue = wasm.TS_LDKGraphSyncError_ty_from_ptr(ptr);
5737 return nativeResponseValue;
5740 export function LDKGraphSyncError_DecodeError_get_decode_error(ptr: bigint): bigint {
5741 if(!isWasmInitialized) {
5742 throw new Error("initializeWasm() must be awaited first!");
5744 const nativeResponseValue = wasm.TS_LDKGraphSyncError_DecodeError_get_decode_error(ptr);
5745 return nativeResponseValue;
5748 export function LDKGraphSyncError_LightningError_get_lightning_error(ptr: bigint): bigint {
5749 if(!isWasmInitialized) {
5750 throw new Error("initializeWasm() must be awaited first!");
5752 const nativeResponseValue = wasm.TS_LDKGraphSyncError_LightningError_get_lightning_error(ptr);
5753 return nativeResponseValue;
5755 // uint32_t CResult_u32GraphSyncErrorZ_get_ok(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner);
5757 export function CResult_u32GraphSyncErrorZ_get_ok(owner: bigint): number {
5758 if(!isWasmInitialized) {
5759 throw new Error("initializeWasm() must be awaited first!");
5761 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_get_ok(owner);
5762 return nativeResponseValue;
5764 // struct LDKGraphSyncError CResult_u32GraphSyncErrorZ_get_err(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner);
5766 export function CResult_u32GraphSyncErrorZ_get_err(owner: bigint): bigint {
5767 if(!isWasmInitialized) {
5768 throw new Error("initializeWasm() must be awaited first!");
5770 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_get_err(owner);
5771 return nativeResponseValue;
5774 export class LDKParseError {
5775 protected constructor() {}
5778 export function LDKParseError_ty_from_ptr(ptr: bigint): number {
5779 if(!isWasmInitialized) {
5780 throw new Error("initializeWasm() must be awaited first!");
5782 const nativeResponseValue = wasm.TS_LDKParseError_ty_from_ptr(ptr);
5783 return nativeResponseValue;
5786 export function LDKParseError_Bech32Error_get_bech32_error(ptr: bigint): bigint {
5787 if(!isWasmInitialized) {
5788 throw new Error("initializeWasm() must be awaited first!");
5790 const nativeResponseValue = wasm.TS_LDKParseError_Bech32Error_get_bech32_error(ptr);
5791 return nativeResponseValue;
5794 export function LDKParseError_ParseAmountError_get_parse_amount_error(ptr: bigint): number {
5795 if(!isWasmInitialized) {
5796 throw new Error("initializeWasm() must be awaited first!");
5798 const nativeResponseValue = wasm.TS_LDKParseError_ParseAmountError_get_parse_amount_error(ptr);
5799 return nativeResponseValue;
5802 export function LDKParseError_MalformedSignature_get_malformed_signature(ptr: bigint): Secp256k1Error {
5803 if(!isWasmInitialized) {
5804 throw new Error("initializeWasm() must be awaited first!");
5806 const nativeResponseValue = wasm.TS_LDKParseError_MalformedSignature_get_malformed_signature(ptr);
5807 return nativeResponseValue;
5810 export function LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr: bigint): number {
5811 if(!isWasmInitialized) {
5812 throw new Error("initializeWasm() must be awaited first!");
5814 const nativeResponseValue = wasm.TS_LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr);
5815 return nativeResponseValue;
5818 export function LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr: bigint): number {
5819 if(!isWasmInitialized) {
5820 throw new Error("initializeWasm() must be awaited first!");
5822 const nativeResponseValue = wasm.TS_LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr);
5823 return nativeResponseValue;
5825 // enum LDKSiPrefix CResult_SiPrefixParseErrorZ_get_ok(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
5827 export function CResult_SiPrefixParseErrorZ_get_ok(owner: bigint): SiPrefix {
5828 if(!isWasmInitialized) {
5829 throw new Error("initializeWasm() must be awaited first!");
5831 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_ok(owner);
5832 return nativeResponseValue;
5834 // struct LDKParseError CResult_SiPrefixParseErrorZ_get_err(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
5836 export function CResult_SiPrefixParseErrorZ_get_err(owner: bigint): bigint {
5837 if(!isWasmInitialized) {
5838 throw new Error("initializeWasm() must be awaited first!");
5840 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_err(owner);
5841 return nativeResponseValue;
5844 export class LDKParseOrSemanticError {
5845 protected constructor() {}
5848 export function LDKParseOrSemanticError_ty_from_ptr(ptr: bigint): number {
5849 if(!isWasmInitialized) {
5850 throw new Error("initializeWasm() must be awaited first!");
5852 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ty_from_ptr(ptr);
5853 return nativeResponseValue;
5856 export function LDKParseOrSemanticError_ParseError_get_parse_error(ptr: bigint): bigint {
5857 if(!isWasmInitialized) {
5858 throw new Error("initializeWasm() must be awaited first!");
5860 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ParseError_get_parse_error(ptr);
5861 return nativeResponseValue;
5864 export function LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr: bigint): SemanticError {
5865 if(!isWasmInitialized) {
5866 throw new Error("initializeWasm() must be awaited first!");
5868 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr);
5869 return nativeResponseValue;
5871 // struct LDKInvoice CResult_InvoiceParseOrSemanticErrorZ_get_ok(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
5873 export function CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner: bigint): bigint {
5874 if(!isWasmInitialized) {
5875 throw new Error("initializeWasm() must be awaited first!");
5877 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner);
5878 return nativeResponseValue;
5880 // struct LDKParseOrSemanticError CResult_InvoiceParseOrSemanticErrorZ_get_err(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
5882 export function CResult_InvoiceParseOrSemanticErrorZ_get_err(owner: bigint): bigint {
5883 if(!isWasmInitialized) {
5884 throw new Error("initializeWasm() must be awaited first!");
5886 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_err(owner);
5887 return nativeResponseValue;
5889 // struct LDKSignedRawInvoice CResult_SignedRawInvoiceParseErrorZ_get_ok(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
5891 export function CResult_SignedRawInvoiceParseErrorZ_get_ok(owner: bigint): bigint {
5892 if(!isWasmInitialized) {
5893 throw new Error("initializeWasm() must be awaited first!");
5895 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_ok(owner);
5896 return nativeResponseValue;
5898 // struct LDKParseError CResult_SignedRawInvoiceParseErrorZ_get_err(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
5900 export function CResult_SignedRawInvoiceParseErrorZ_get_err(owner: bigint): bigint {
5901 if(!isWasmInitialized) {
5902 throw new Error("initializeWasm() must be awaited first!");
5904 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_err(owner);
5905 return nativeResponseValue;
5907 // struct LDKRawInvoice C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
5909 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner: bigint): bigint {
5910 if(!isWasmInitialized) {
5911 throw new Error("initializeWasm() must be awaited first!");
5913 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner);
5914 return nativeResponseValue;
5916 // struct LDKThirtyTwoBytes C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
5918 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner: bigint): number {
5919 if(!isWasmInitialized) {
5920 throw new Error("initializeWasm() must be awaited first!");
5922 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner);
5923 return nativeResponseValue;
5925 // struct LDKInvoiceSignature C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
5927 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner: bigint): bigint {
5928 if(!isWasmInitialized) {
5929 throw new Error("initializeWasm() must be awaited first!");
5931 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner);
5932 return nativeResponseValue;
5934 // struct LDKPayeePubKey CResult_PayeePubKeyErrorZ_get_ok(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
5936 export function CResult_PayeePubKeyErrorZ_get_ok(owner: bigint): bigint {
5937 if(!isWasmInitialized) {
5938 throw new Error("initializeWasm() must be awaited first!");
5940 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_ok(owner);
5941 return nativeResponseValue;
5943 // enum LDKSecp256k1Error CResult_PayeePubKeyErrorZ_get_err(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
5945 export function CResult_PayeePubKeyErrorZ_get_err(owner: bigint): Secp256k1Error {
5946 if(!isWasmInitialized) {
5947 throw new Error("initializeWasm() must be awaited first!");
5949 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_err(owner);
5950 return nativeResponseValue;
5952 // struct LDKPositiveTimestamp CResult_PositiveTimestampCreationErrorZ_get_ok(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
5954 export function CResult_PositiveTimestampCreationErrorZ_get_ok(owner: bigint): bigint {
5955 if(!isWasmInitialized) {
5956 throw new Error("initializeWasm() must be awaited first!");
5958 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_ok(owner);
5959 return nativeResponseValue;
5961 // enum LDKCreationError CResult_PositiveTimestampCreationErrorZ_get_err(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
5963 export function CResult_PositiveTimestampCreationErrorZ_get_err(owner: bigint): CreationError {
5964 if(!isWasmInitialized) {
5965 throw new Error("initializeWasm() must be awaited first!");
5967 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_err(owner);
5968 return nativeResponseValue;
5970 // void CResult_NoneSemanticErrorZ_get_ok(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
5972 export function CResult_NoneSemanticErrorZ_get_ok(owner: bigint): void {
5973 if(!isWasmInitialized) {
5974 throw new Error("initializeWasm() must be awaited first!");
5976 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_ok(owner);
5977 // debug statements here
5979 // enum LDKSemanticError CResult_NoneSemanticErrorZ_get_err(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
5981 export function CResult_NoneSemanticErrorZ_get_err(owner: bigint): SemanticError {
5982 if(!isWasmInitialized) {
5983 throw new Error("initializeWasm() must be awaited first!");
5985 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_err(owner);
5986 return nativeResponseValue;
5988 // struct LDKInvoice CResult_InvoiceSemanticErrorZ_get_ok(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
5990 export function CResult_InvoiceSemanticErrorZ_get_ok(owner: bigint): bigint {
5991 if(!isWasmInitialized) {
5992 throw new Error("initializeWasm() must be awaited first!");
5994 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_ok(owner);
5995 return nativeResponseValue;
5997 // enum LDKSemanticError CResult_InvoiceSemanticErrorZ_get_err(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
5999 export function CResult_InvoiceSemanticErrorZ_get_err(owner: bigint): SemanticError {
6000 if(!isWasmInitialized) {
6001 throw new Error("initializeWasm() must be awaited first!");
6003 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_err(owner);
6004 return nativeResponseValue;
6006 // struct LDKDescription CResult_DescriptionCreationErrorZ_get_ok(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
6008 export function CResult_DescriptionCreationErrorZ_get_ok(owner: bigint): bigint {
6009 if(!isWasmInitialized) {
6010 throw new Error("initializeWasm() must be awaited first!");
6012 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_ok(owner);
6013 return nativeResponseValue;
6015 // enum LDKCreationError CResult_DescriptionCreationErrorZ_get_err(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
6017 export function CResult_DescriptionCreationErrorZ_get_err(owner: bigint): CreationError {
6018 if(!isWasmInitialized) {
6019 throw new Error("initializeWasm() must be awaited first!");
6021 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_err(owner);
6022 return nativeResponseValue;
6024 // struct LDKPrivateRoute CResult_PrivateRouteCreationErrorZ_get_ok(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
6026 export function CResult_PrivateRouteCreationErrorZ_get_ok(owner: bigint): bigint {
6027 if(!isWasmInitialized) {
6028 throw new Error("initializeWasm() must be awaited first!");
6030 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_ok(owner);
6031 return nativeResponseValue;
6033 // enum LDKCreationError CResult_PrivateRouteCreationErrorZ_get_err(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
6035 export function CResult_PrivateRouteCreationErrorZ_get_err(owner: bigint): CreationError {
6036 if(!isWasmInitialized) {
6037 throw new Error("initializeWasm() must be awaited first!");
6039 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_err(owner);
6040 return nativeResponseValue;
6042 // void CResult_NoneErrorZ_get_ok(LDKCResult_NoneErrorZ *NONNULL_PTR owner);
6044 export function CResult_NoneErrorZ_get_ok(owner: bigint): void {
6045 if(!isWasmInitialized) {
6046 throw new Error("initializeWasm() must be awaited first!");
6048 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_get_ok(owner);
6049 // debug statements here
6051 // enum LDKIOError CResult_NoneErrorZ_get_err(LDKCResult_NoneErrorZ *NONNULL_PTR owner);
6053 export function CResult_NoneErrorZ_get_err(owner: bigint): IOError {
6054 if(!isWasmInitialized) {
6055 throw new Error("initializeWasm() must be awaited first!");
6057 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_get_err(owner);
6058 return nativeResponseValue;
6060 // struct LDKNetAddress CResult_NetAddressDecodeErrorZ_get_ok(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
6062 export function CResult_NetAddressDecodeErrorZ_get_ok(owner: bigint): bigint {
6063 if(!isWasmInitialized) {
6064 throw new Error("initializeWasm() must be awaited first!");
6066 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_ok(owner);
6067 return nativeResponseValue;
6069 // struct LDKDecodeError CResult_NetAddressDecodeErrorZ_get_err(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
6071 export function CResult_NetAddressDecodeErrorZ_get_err(owner: bigint): bigint {
6072 if(!isWasmInitialized) {
6073 throw new Error("initializeWasm() must be awaited first!");
6075 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_err(owner);
6076 return nativeResponseValue;
6078 // struct LDKAcceptChannel CResult_AcceptChannelDecodeErrorZ_get_ok(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
6080 export function CResult_AcceptChannelDecodeErrorZ_get_ok(owner: bigint): bigint {
6081 if(!isWasmInitialized) {
6082 throw new Error("initializeWasm() must be awaited first!");
6084 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_ok(owner);
6085 return nativeResponseValue;
6087 // struct LDKDecodeError CResult_AcceptChannelDecodeErrorZ_get_err(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
6089 export function CResult_AcceptChannelDecodeErrorZ_get_err(owner: bigint): bigint {
6090 if(!isWasmInitialized) {
6091 throw new Error("initializeWasm() must be awaited first!");
6093 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_err(owner);
6094 return nativeResponseValue;
6096 // struct LDKAnnouncementSignatures CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
6098 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
6099 if(!isWasmInitialized) {
6100 throw new Error("initializeWasm() must be awaited first!");
6102 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner);
6103 return nativeResponseValue;
6105 // struct LDKDecodeError CResult_AnnouncementSignaturesDecodeErrorZ_get_err(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
6107 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner: bigint): bigint {
6108 if(!isWasmInitialized) {
6109 throw new Error("initializeWasm() must be awaited first!");
6111 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner);
6112 return nativeResponseValue;
6114 // struct LDKChannelReestablish CResult_ChannelReestablishDecodeErrorZ_get_ok(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
6116 export function CResult_ChannelReestablishDecodeErrorZ_get_ok(owner: bigint): bigint {
6117 if(!isWasmInitialized) {
6118 throw new Error("initializeWasm() must be awaited first!");
6120 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_ok(owner);
6121 return nativeResponseValue;
6123 // struct LDKDecodeError CResult_ChannelReestablishDecodeErrorZ_get_err(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
6125 export function CResult_ChannelReestablishDecodeErrorZ_get_err(owner: bigint): bigint {
6126 if(!isWasmInitialized) {
6127 throw new Error("initializeWasm() must be awaited first!");
6129 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_err(owner);
6130 return nativeResponseValue;
6132 // struct LDKClosingSigned CResult_ClosingSignedDecodeErrorZ_get_ok(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
6134 export function CResult_ClosingSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
6135 if(!isWasmInitialized) {
6136 throw new Error("initializeWasm() must be awaited first!");
6138 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_ok(owner);
6139 return nativeResponseValue;
6141 // struct LDKDecodeError CResult_ClosingSignedDecodeErrorZ_get_err(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
6143 export function CResult_ClosingSignedDecodeErrorZ_get_err(owner: bigint): bigint {
6144 if(!isWasmInitialized) {
6145 throw new Error("initializeWasm() must be awaited first!");
6147 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_err(owner);
6148 return nativeResponseValue;
6150 // struct LDKClosingSignedFeeRange CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
6152 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
6153 if(!isWasmInitialized) {
6154 throw new Error("initializeWasm() must be awaited first!");
6156 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner);
6157 return nativeResponseValue;
6159 // struct LDKDecodeError CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
6161 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner: bigint): bigint {
6162 if(!isWasmInitialized) {
6163 throw new Error("initializeWasm() must be awaited first!");
6165 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner);
6166 return nativeResponseValue;
6168 // struct LDKCommitmentSigned CResult_CommitmentSignedDecodeErrorZ_get_ok(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
6170 export function CResult_CommitmentSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
6171 if(!isWasmInitialized) {
6172 throw new Error("initializeWasm() must be awaited first!");
6174 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_ok(owner);
6175 return nativeResponseValue;
6177 // struct LDKDecodeError CResult_CommitmentSignedDecodeErrorZ_get_err(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
6179 export function CResult_CommitmentSignedDecodeErrorZ_get_err(owner: bigint): bigint {
6180 if(!isWasmInitialized) {
6181 throw new Error("initializeWasm() must be awaited first!");
6183 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_err(owner);
6184 return nativeResponseValue;
6186 // struct LDKFundingCreated CResult_FundingCreatedDecodeErrorZ_get_ok(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
6188 export function CResult_FundingCreatedDecodeErrorZ_get_ok(owner: bigint): bigint {
6189 if(!isWasmInitialized) {
6190 throw new Error("initializeWasm() must be awaited first!");
6192 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_ok(owner);
6193 return nativeResponseValue;
6195 // struct LDKDecodeError CResult_FundingCreatedDecodeErrorZ_get_err(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
6197 export function CResult_FundingCreatedDecodeErrorZ_get_err(owner: bigint): bigint {
6198 if(!isWasmInitialized) {
6199 throw new Error("initializeWasm() must be awaited first!");
6201 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_err(owner);
6202 return nativeResponseValue;
6204 // struct LDKFundingSigned CResult_FundingSignedDecodeErrorZ_get_ok(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
6206 export function CResult_FundingSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
6207 if(!isWasmInitialized) {
6208 throw new Error("initializeWasm() must be awaited first!");
6210 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_ok(owner);
6211 return nativeResponseValue;
6213 // struct LDKDecodeError CResult_FundingSignedDecodeErrorZ_get_err(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
6215 export function CResult_FundingSignedDecodeErrorZ_get_err(owner: bigint): bigint {
6216 if(!isWasmInitialized) {
6217 throw new Error("initializeWasm() must be awaited first!");
6219 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_err(owner);
6220 return nativeResponseValue;
6222 // struct LDKChannelReady CResult_ChannelReadyDecodeErrorZ_get_ok(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
6224 export function CResult_ChannelReadyDecodeErrorZ_get_ok(owner: bigint): bigint {
6225 if(!isWasmInitialized) {
6226 throw new Error("initializeWasm() must be awaited first!");
6228 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_ok(owner);
6229 return nativeResponseValue;
6231 // struct LDKDecodeError CResult_ChannelReadyDecodeErrorZ_get_err(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
6233 export function CResult_ChannelReadyDecodeErrorZ_get_err(owner: bigint): bigint {
6234 if(!isWasmInitialized) {
6235 throw new Error("initializeWasm() must be awaited first!");
6237 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_err(owner);
6238 return nativeResponseValue;
6240 // struct LDKInit CResult_InitDecodeErrorZ_get_ok(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
6242 export function CResult_InitDecodeErrorZ_get_ok(owner: bigint): bigint {
6243 if(!isWasmInitialized) {
6244 throw new Error("initializeWasm() must be awaited first!");
6246 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_ok(owner);
6247 return nativeResponseValue;
6249 // struct LDKDecodeError CResult_InitDecodeErrorZ_get_err(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
6251 export function CResult_InitDecodeErrorZ_get_err(owner: bigint): bigint {
6252 if(!isWasmInitialized) {
6253 throw new Error("initializeWasm() must be awaited first!");
6255 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_err(owner);
6256 return nativeResponseValue;
6258 // struct LDKOpenChannel CResult_OpenChannelDecodeErrorZ_get_ok(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
6260 export function CResult_OpenChannelDecodeErrorZ_get_ok(owner: bigint): bigint {
6261 if(!isWasmInitialized) {
6262 throw new Error("initializeWasm() must be awaited first!");
6264 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_ok(owner);
6265 return nativeResponseValue;
6267 // struct LDKDecodeError CResult_OpenChannelDecodeErrorZ_get_err(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
6269 export function CResult_OpenChannelDecodeErrorZ_get_err(owner: bigint): bigint {
6270 if(!isWasmInitialized) {
6271 throw new Error("initializeWasm() must be awaited first!");
6273 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_err(owner);
6274 return nativeResponseValue;
6276 // struct LDKRevokeAndACK CResult_RevokeAndACKDecodeErrorZ_get_ok(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
6278 export function CResult_RevokeAndACKDecodeErrorZ_get_ok(owner: bigint): bigint {
6279 if(!isWasmInitialized) {
6280 throw new Error("initializeWasm() must be awaited first!");
6282 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_ok(owner);
6283 return nativeResponseValue;
6285 // struct LDKDecodeError CResult_RevokeAndACKDecodeErrorZ_get_err(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
6287 export function CResult_RevokeAndACKDecodeErrorZ_get_err(owner: bigint): bigint {
6288 if(!isWasmInitialized) {
6289 throw new Error("initializeWasm() must be awaited first!");
6291 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_err(owner);
6292 return nativeResponseValue;
6294 // struct LDKShutdown CResult_ShutdownDecodeErrorZ_get_ok(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
6296 export function CResult_ShutdownDecodeErrorZ_get_ok(owner: bigint): bigint {
6297 if(!isWasmInitialized) {
6298 throw new Error("initializeWasm() must be awaited first!");
6300 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_ok(owner);
6301 return nativeResponseValue;
6303 // struct LDKDecodeError CResult_ShutdownDecodeErrorZ_get_err(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
6305 export function CResult_ShutdownDecodeErrorZ_get_err(owner: bigint): bigint {
6306 if(!isWasmInitialized) {
6307 throw new Error("initializeWasm() must be awaited first!");
6309 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_err(owner);
6310 return nativeResponseValue;
6312 // struct LDKUpdateFailHTLC CResult_UpdateFailHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
6314 export function CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
6315 if(!isWasmInitialized) {
6316 throw new Error("initializeWasm() must be awaited first!");
6318 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner);
6319 return nativeResponseValue;
6321 // struct LDKDecodeError CResult_UpdateFailHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
6323 export function CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
6324 if(!isWasmInitialized) {
6325 throw new Error("initializeWasm() must be awaited first!");
6327 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner);
6328 return nativeResponseValue;
6330 // struct LDKUpdateFailMalformedHTLC CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
6332 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
6333 if(!isWasmInitialized) {
6334 throw new Error("initializeWasm() must be awaited first!");
6336 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner);
6337 return nativeResponseValue;
6339 // struct LDKDecodeError CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
6341 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
6342 if(!isWasmInitialized) {
6343 throw new Error("initializeWasm() must be awaited first!");
6345 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner);
6346 return nativeResponseValue;
6348 // struct LDKUpdateFee CResult_UpdateFeeDecodeErrorZ_get_ok(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
6350 export function CResult_UpdateFeeDecodeErrorZ_get_ok(owner: bigint): bigint {
6351 if(!isWasmInitialized) {
6352 throw new Error("initializeWasm() must be awaited first!");
6354 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_ok(owner);
6355 return nativeResponseValue;
6357 // struct LDKDecodeError CResult_UpdateFeeDecodeErrorZ_get_err(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
6359 export function CResult_UpdateFeeDecodeErrorZ_get_err(owner: bigint): bigint {
6360 if(!isWasmInitialized) {
6361 throw new Error("initializeWasm() must be awaited first!");
6363 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_err(owner);
6364 return nativeResponseValue;
6366 // struct LDKUpdateFulfillHTLC CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
6368 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
6369 if(!isWasmInitialized) {
6370 throw new Error("initializeWasm() must be awaited first!");
6372 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner);
6373 return nativeResponseValue;
6375 // struct LDKDecodeError CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
6377 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
6378 if(!isWasmInitialized) {
6379 throw new Error("initializeWasm() must be awaited first!");
6381 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner);
6382 return nativeResponseValue;
6384 // struct LDKUpdateAddHTLC CResult_UpdateAddHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
6386 export function CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
6387 if(!isWasmInitialized) {
6388 throw new Error("initializeWasm() must be awaited first!");
6390 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner);
6391 return nativeResponseValue;
6393 // struct LDKDecodeError CResult_UpdateAddHTLCDecodeErrorZ_get_err(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
6395 export function CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
6396 if(!isWasmInitialized) {
6397 throw new Error("initializeWasm() must be awaited first!");
6399 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner);
6400 return nativeResponseValue;
6402 // struct LDKOnionMessage CResult_OnionMessageDecodeErrorZ_get_ok(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner);
6404 export function CResult_OnionMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
6405 if(!isWasmInitialized) {
6406 throw new Error("initializeWasm() must be awaited first!");
6408 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_get_ok(owner);
6409 return nativeResponseValue;
6411 // struct LDKDecodeError CResult_OnionMessageDecodeErrorZ_get_err(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner);
6413 export function CResult_OnionMessageDecodeErrorZ_get_err(owner: bigint): bigint {
6414 if(!isWasmInitialized) {
6415 throw new Error("initializeWasm() must be awaited first!");
6417 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_get_err(owner);
6418 return nativeResponseValue;
6420 // struct LDKPing CResult_PingDecodeErrorZ_get_ok(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
6422 export function CResult_PingDecodeErrorZ_get_ok(owner: bigint): bigint {
6423 if(!isWasmInitialized) {
6424 throw new Error("initializeWasm() must be awaited first!");
6426 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_ok(owner);
6427 return nativeResponseValue;
6429 // struct LDKDecodeError CResult_PingDecodeErrorZ_get_err(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
6431 export function CResult_PingDecodeErrorZ_get_err(owner: bigint): bigint {
6432 if(!isWasmInitialized) {
6433 throw new Error("initializeWasm() must be awaited first!");
6435 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_err(owner);
6436 return nativeResponseValue;
6438 // struct LDKPong CResult_PongDecodeErrorZ_get_ok(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
6440 export function CResult_PongDecodeErrorZ_get_ok(owner: bigint): bigint {
6441 if(!isWasmInitialized) {
6442 throw new Error("initializeWasm() must be awaited first!");
6444 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_ok(owner);
6445 return nativeResponseValue;
6447 // struct LDKDecodeError CResult_PongDecodeErrorZ_get_err(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
6449 export function CResult_PongDecodeErrorZ_get_err(owner: bigint): bigint {
6450 if(!isWasmInitialized) {
6451 throw new Error("initializeWasm() must be awaited first!");
6453 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_err(owner);
6454 return nativeResponseValue;
6456 // struct LDKUnsignedChannelAnnouncement CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6458 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
6459 if(!isWasmInitialized) {
6460 throw new Error("initializeWasm() must be awaited first!");
6462 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner);
6463 return nativeResponseValue;
6465 // struct LDKDecodeError CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6467 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
6468 if(!isWasmInitialized) {
6469 throw new Error("initializeWasm() must be awaited first!");
6471 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner);
6472 return nativeResponseValue;
6474 // struct LDKChannelAnnouncement CResult_ChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6476 export function CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
6477 if(!isWasmInitialized) {
6478 throw new Error("initializeWasm() must be awaited first!");
6480 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner);
6481 return nativeResponseValue;
6483 // struct LDKDecodeError CResult_ChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6485 export function CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
6486 if(!isWasmInitialized) {
6487 throw new Error("initializeWasm() must be awaited first!");
6489 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner);
6490 return nativeResponseValue;
6492 // struct LDKUnsignedChannelUpdate CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
6494 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
6495 if(!isWasmInitialized) {
6496 throw new Error("initializeWasm() must be awaited first!");
6498 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner);
6499 return nativeResponseValue;
6501 // struct LDKDecodeError CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
6503 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
6504 if(!isWasmInitialized) {
6505 throw new Error("initializeWasm() must be awaited first!");
6507 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner);
6508 return nativeResponseValue;
6510 // struct LDKChannelUpdate CResult_ChannelUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
6512 export function CResult_ChannelUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
6513 if(!isWasmInitialized) {
6514 throw new Error("initializeWasm() must be awaited first!");
6516 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_ok(owner);
6517 return nativeResponseValue;
6519 // struct LDKDecodeError CResult_ChannelUpdateDecodeErrorZ_get_err(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
6521 export function CResult_ChannelUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
6522 if(!isWasmInitialized) {
6523 throw new Error("initializeWasm() must be awaited first!");
6525 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_err(owner);
6526 return nativeResponseValue;
6528 // struct LDKErrorMessage CResult_ErrorMessageDecodeErrorZ_get_ok(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
6530 export function CResult_ErrorMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
6531 if(!isWasmInitialized) {
6532 throw new Error("initializeWasm() must be awaited first!");
6534 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_ok(owner);
6535 return nativeResponseValue;
6537 // struct LDKDecodeError CResult_ErrorMessageDecodeErrorZ_get_err(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
6539 export function CResult_ErrorMessageDecodeErrorZ_get_err(owner: bigint): bigint {
6540 if(!isWasmInitialized) {
6541 throw new Error("initializeWasm() must be awaited first!");
6543 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_err(owner);
6544 return nativeResponseValue;
6546 // struct LDKWarningMessage CResult_WarningMessageDecodeErrorZ_get_ok(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
6548 export function CResult_WarningMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
6549 if(!isWasmInitialized) {
6550 throw new Error("initializeWasm() must be awaited first!");
6552 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_ok(owner);
6553 return nativeResponseValue;
6555 // struct LDKDecodeError CResult_WarningMessageDecodeErrorZ_get_err(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
6557 export function CResult_WarningMessageDecodeErrorZ_get_err(owner: bigint): bigint {
6558 if(!isWasmInitialized) {
6559 throw new Error("initializeWasm() must be awaited first!");
6561 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_err(owner);
6562 return nativeResponseValue;
6564 // struct LDKUnsignedNodeAnnouncement CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6566 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
6567 if(!isWasmInitialized) {
6568 throw new Error("initializeWasm() must be awaited first!");
6570 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner);
6571 return nativeResponseValue;
6573 // struct LDKDecodeError CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6575 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
6576 if(!isWasmInitialized) {
6577 throw new Error("initializeWasm() must be awaited first!");
6579 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner);
6580 return nativeResponseValue;
6582 // struct LDKNodeAnnouncement CResult_NodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6584 export function CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
6585 if(!isWasmInitialized) {
6586 throw new Error("initializeWasm() must be awaited first!");
6588 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner);
6589 return nativeResponseValue;
6591 // struct LDKDecodeError CResult_NodeAnnouncementDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6593 export function CResult_NodeAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
6594 if(!isWasmInitialized) {
6595 throw new Error("initializeWasm() must be awaited first!");
6597 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_err(owner);
6598 return nativeResponseValue;
6600 // struct LDKQueryShortChannelIds CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
6602 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner: bigint): bigint {
6603 if(!isWasmInitialized) {
6604 throw new Error("initializeWasm() must be awaited first!");
6606 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner);
6607 return nativeResponseValue;
6609 // struct LDKDecodeError CResult_QueryShortChannelIdsDecodeErrorZ_get_err(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
6611 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner: bigint): bigint {
6612 if(!isWasmInitialized) {
6613 throw new Error("initializeWasm() must be awaited first!");
6615 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner);
6616 return nativeResponseValue;
6618 // struct LDKReplyShortChannelIdsEnd CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
6620 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner: bigint): bigint {
6621 if(!isWasmInitialized) {
6622 throw new Error("initializeWasm() must be awaited first!");
6624 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner);
6625 return nativeResponseValue;
6627 // struct LDKDecodeError CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
6629 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner: bigint): bigint {
6630 if(!isWasmInitialized) {
6631 throw new Error("initializeWasm() must be awaited first!");
6633 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner);
6634 return nativeResponseValue;
6636 // struct LDKQueryChannelRange CResult_QueryChannelRangeDecodeErrorZ_get_ok(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
6638 export function CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
6639 if(!isWasmInitialized) {
6640 throw new Error("initializeWasm() must be awaited first!");
6642 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner);
6643 return nativeResponseValue;
6645 // struct LDKDecodeError CResult_QueryChannelRangeDecodeErrorZ_get_err(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
6647 export function CResult_QueryChannelRangeDecodeErrorZ_get_err(owner: bigint): bigint {
6648 if(!isWasmInitialized) {
6649 throw new Error("initializeWasm() must be awaited first!");
6651 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_err(owner);
6652 return nativeResponseValue;
6654 // struct LDKReplyChannelRange CResult_ReplyChannelRangeDecodeErrorZ_get_ok(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
6656 export function CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
6657 if(!isWasmInitialized) {
6658 throw new Error("initializeWasm() must be awaited first!");
6660 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner);
6661 return nativeResponseValue;
6663 // struct LDKDecodeError CResult_ReplyChannelRangeDecodeErrorZ_get_err(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
6665 export function CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner: bigint): bigint {
6666 if(!isWasmInitialized) {
6667 throw new Error("initializeWasm() must be awaited first!");
6669 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner);
6670 return nativeResponseValue;
6672 // struct LDKGossipTimestampFilter CResult_GossipTimestampFilterDecodeErrorZ_get_ok(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
6674 export function CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner: bigint): bigint {
6675 if(!isWasmInitialized) {
6676 throw new Error("initializeWasm() must be awaited first!");
6678 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner);
6679 return nativeResponseValue;
6681 // struct LDKDecodeError CResult_GossipTimestampFilterDecodeErrorZ_get_err(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
6683 export function CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner: bigint): bigint {
6684 if(!isWasmInitialized) {
6685 throw new Error("initializeWasm() must be awaited first!");
6687 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner);
6688 return nativeResponseValue;
6691 export class LDKSignOrCreationError {
6692 protected constructor() {}
6695 export function LDKSignOrCreationError_ty_from_ptr(ptr: bigint): number {
6696 if(!isWasmInitialized) {
6697 throw new Error("initializeWasm() must be awaited first!");
6699 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_ty_from_ptr(ptr);
6700 return nativeResponseValue;
6703 export function LDKSignOrCreationError_CreationError_get_creation_error(ptr: bigint): CreationError {
6704 if(!isWasmInitialized) {
6705 throw new Error("initializeWasm() must be awaited first!");
6707 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_CreationError_get_creation_error(ptr);
6708 return nativeResponseValue;
6710 // struct LDKInvoice CResult_InvoiceSignOrCreationErrorZ_get_ok(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
6712 export function CResult_InvoiceSignOrCreationErrorZ_get_ok(owner: bigint): bigint {
6713 if(!isWasmInitialized) {
6714 throw new Error("initializeWasm() must be awaited first!");
6716 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_ok(owner);
6717 return nativeResponseValue;
6719 // struct LDKSignOrCreationError CResult_InvoiceSignOrCreationErrorZ_get_err(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
6721 export function CResult_InvoiceSignOrCreationErrorZ_get_err(owner: bigint): bigint {
6722 if(!isWasmInitialized) {
6723 throw new Error("initializeWasm() must be awaited first!");
6725 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_err(owner);
6726 return nativeResponseValue;
6729 export interface LDKFilter {
6730 register_tx (txid: number, script_pubkey: number): void;
6731 register_output (output: bigint): void;
6735 export function LDKFilter_new(impl: LDKFilter): [bigint, number] {
6736 if(!isWasmInitialized) {
6737 throw new Error("initializeWasm() must be awaited first!");
6739 var new_obj_idx = js_objs.length;
6740 for (var i = 0; i < js_objs.length; i++) {
6741 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6743 js_objs[i] = new WeakRef(impl);
6744 return [wasm.TS_LDKFilter_new(i), i];
6746 // void Filter_register_tx LDKFilter *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
6748 export function Filter_register_tx(this_arg: bigint, txid: number, script_pubkey: number): void {
6749 if(!isWasmInitialized) {
6750 throw new Error("initializeWasm() must be awaited first!");
6752 const nativeResponseValue = wasm.TS_Filter_register_tx(this_arg, txid, script_pubkey);
6753 // debug statements here
6755 // void Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
6757 export function Filter_register_output(this_arg: bigint, output: bigint): void {
6758 if(!isWasmInitialized) {
6759 throw new Error("initializeWasm() must be awaited first!");
6761 const nativeResponseValue = wasm.TS_Filter_register_output(this_arg, output);
6762 // debug statements here
6765 export class LDKCOption_FilterZ {
6766 protected constructor() {}
6769 export function LDKCOption_FilterZ_ty_from_ptr(ptr: bigint): number {
6770 if(!isWasmInitialized) {
6771 throw new Error("initializeWasm() must be awaited first!");
6773 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_ty_from_ptr(ptr);
6774 return nativeResponseValue;
6777 export function LDKCOption_FilterZ_Some_get_some(ptr: bigint): bigint {
6778 if(!isWasmInitialized) {
6779 throw new Error("initializeWasm() must be awaited first!");
6781 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_Some_get_some(ptr);
6782 return nativeResponseValue;
6784 // struct LDKLockedChannelMonitor CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
6786 export function CResult_LockedChannelMonitorNoneZ_get_ok(owner: bigint): bigint {
6787 if(!isWasmInitialized) {
6788 throw new Error("initializeWasm() must be awaited first!");
6790 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_ok(owner);
6791 return nativeResponseValue;
6793 // void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
6795 export function CResult_LockedChannelMonitorNoneZ_get_err(owner: bigint): void {
6796 if(!isWasmInitialized) {
6797 throw new Error("initializeWasm() must be awaited first!");
6799 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_err(owner);
6800 // debug statements here
6802 // struct LDKOutPoint C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner);
6804 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(owner: bigint): bigint {
6805 if(!isWasmInitialized) {
6806 throw new Error("initializeWasm() must be awaited first!");
6808 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(owner);
6809 return nativeResponseValue;
6811 // struct LDKCVec_MonitorUpdateIdZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner);
6813 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(owner: bigint): number {
6814 if(!isWasmInitialized) {
6815 throw new Error("initializeWasm() must be awaited first!");
6817 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(owner);
6818 return nativeResponseValue;
6821 export interface LDKMessageSendEventsProvider {
6822 get_and_clear_pending_msg_events (): number;
6826 export function LDKMessageSendEventsProvider_new(impl: LDKMessageSendEventsProvider): [bigint, number] {
6827 if(!isWasmInitialized) {
6828 throw new Error("initializeWasm() must be awaited first!");
6830 var new_obj_idx = js_objs.length;
6831 for (var i = 0; i < js_objs.length; i++) {
6832 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6834 js_objs[i] = new WeakRef(impl);
6835 return [wasm.TS_LDKMessageSendEventsProvider_new(i), i];
6837 // LDKCVec_MessageSendEventZ MessageSendEventsProvider_get_and_clear_pending_msg_events LDKMessageSendEventsProvider *NONNULL_PTR this_arg
6839 export function MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg: bigint): number {
6840 if(!isWasmInitialized) {
6841 throw new Error("initializeWasm() must be awaited first!");
6843 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg);
6844 return nativeResponseValue;
6847 export interface LDKOnionMessageProvider {
6848 next_onion_message_for_peer (peer_node_id: number): bigint;
6852 export function LDKOnionMessageProvider_new(impl: LDKOnionMessageProvider): [bigint, number] {
6853 if(!isWasmInitialized) {
6854 throw new Error("initializeWasm() must be awaited first!");
6856 var new_obj_idx = js_objs.length;
6857 for (var i = 0; i < js_objs.length; i++) {
6858 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6860 js_objs[i] = new WeakRef(impl);
6861 return [wasm.TS_LDKOnionMessageProvider_new(i), i];
6863 // LDKOnionMessage OnionMessageProvider_next_onion_message_for_peer LDKOnionMessageProvider *NONNULL_PTR this_arg, struct LDKPublicKey peer_node_id
6865 export function OnionMessageProvider_next_onion_message_for_peer(this_arg: bigint, peer_node_id: number): bigint {
6866 if(!isWasmInitialized) {
6867 throw new Error("initializeWasm() must be awaited first!");
6869 const nativeResponseValue = wasm.TS_OnionMessageProvider_next_onion_message_for_peer(this_arg, peer_node_id);
6870 return nativeResponseValue;
6873 export interface LDKEventHandler {
6874 handle_event (event: bigint): void;
6878 export function LDKEventHandler_new(impl: LDKEventHandler): [bigint, number] {
6879 if(!isWasmInitialized) {
6880 throw new Error("initializeWasm() must be awaited first!");
6882 var new_obj_idx = js_objs.length;
6883 for (var i = 0; i < js_objs.length; i++) {
6884 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6886 js_objs[i] = new WeakRef(impl);
6887 return [wasm.TS_LDKEventHandler_new(i), i];
6889 // void EventHandler_handle_event LDKEventHandler *NONNULL_PTR this_arg, struct LDKEvent event
6891 export function EventHandler_handle_event(this_arg: bigint, event: bigint): void {
6892 if(!isWasmInitialized) {
6893 throw new Error("initializeWasm() must be awaited first!");
6895 const nativeResponseValue = wasm.TS_EventHandler_handle_event(this_arg, event);
6896 // debug statements here
6899 export interface LDKEventsProvider {
6900 process_pending_events (handler: bigint): void;
6904 export function LDKEventsProvider_new(impl: LDKEventsProvider): [bigint, number] {
6905 if(!isWasmInitialized) {
6906 throw new Error("initializeWasm() must be awaited first!");
6908 var new_obj_idx = js_objs.length;
6909 for (var i = 0; i < js_objs.length; i++) {
6910 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6912 js_objs[i] = new WeakRef(impl);
6913 return [wasm.TS_LDKEventsProvider_new(i), i];
6915 // void EventsProvider_process_pending_events LDKEventsProvider *NONNULL_PTR this_arg, struct LDKEventHandler handler
6917 export function EventsProvider_process_pending_events(this_arg: bigint, handler: bigint): void {
6918 if(!isWasmInitialized) {
6919 throw new Error("initializeWasm() must be awaited first!");
6921 const nativeResponseValue = wasm.TS_EventsProvider_process_pending_events(this_arg, handler);
6922 // debug statements here
6925 export interface LDKScore {
6926 channel_penalty_msat (short_channel_id: bigint, source: bigint, target: bigint, usage: bigint): bigint;
6927 payment_path_failed (path: number, short_channel_id: bigint): void;
6928 payment_path_successful (path: number): void;
6929 probe_failed (path: number, short_channel_id: bigint): void;
6930 probe_successful (path: number): void;
6935 export function LDKScore_new(impl: LDKScore): [bigint, number] {
6936 if(!isWasmInitialized) {
6937 throw new Error("initializeWasm() must be awaited first!");
6939 var new_obj_idx = js_objs.length;
6940 for (var i = 0; i < js_objs.length; i++) {
6941 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6943 js_objs[i] = new WeakRef(impl);
6944 return [wasm.TS_LDKScore_new(i), i];
6946 // 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
6948 export function Score_channel_penalty_msat(this_arg: bigint, short_channel_id: bigint, source: bigint, target: bigint, usage: bigint): bigint {
6949 if(!isWasmInitialized) {
6950 throw new Error("initializeWasm() must be awaited first!");
6952 const nativeResponseValue = wasm.TS_Score_channel_penalty_msat(this_arg, short_channel_id, source, target, usage);
6953 return nativeResponseValue;
6955 // void Score_payment_path_failed LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
6957 export function Score_payment_path_failed(this_arg: bigint, path: number, short_channel_id: bigint): void {
6958 if(!isWasmInitialized) {
6959 throw new Error("initializeWasm() must be awaited first!");
6961 const nativeResponseValue = wasm.TS_Score_payment_path_failed(this_arg, path, short_channel_id);
6962 // debug statements here
6964 // void Score_payment_path_successful LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
6966 export function Score_payment_path_successful(this_arg: bigint, path: number): void {
6967 if(!isWasmInitialized) {
6968 throw new Error("initializeWasm() must be awaited first!");
6970 const nativeResponseValue = wasm.TS_Score_payment_path_successful(this_arg, path);
6971 // debug statements here
6973 // void Score_probe_failed LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
6975 export function Score_probe_failed(this_arg: bigint, path: number, short_channel_id: bigint): void {
6976 if(!isWasmInitialized) {
6977 throw new Error("initializeWasm() must be awaited first!");
6979 const nativeResponseValue = wasm.TS_Score_probe_failed(this_arg, path, short_channel_id);
6980 // debug statements here
6982 // void Score_probe_successful LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
6984 export function Score_probe_successful(this_arg: bigint, path: number): void {
6985 if(!isWasmInitialized) {
6986 throw new Error("initializeWasm() must be awaited first!");
6988 const nativeResponseValue = wasm.TS_Score_probe_successful(this_arg, path);
6989 // debug statements here
6991 // LDKCVec_u8Z Score_write LDKScore *NONNULL_PTR this_arg
6993 export function Score_write(this_arg: bigint): number {
6994 if(!isWasmInitialized) {
6995 throw new Error("initializeWasm() must be awaited first!");
6997 const nativeResponseValue = wasm.TS_Score_write(this_arg);
6998 return nativeResponseValue;
7001 export interface LDKLockableScore {
7006 export function LDKLockableScore_new(impl: LDKLockableScore): [bigint, number] {
7007 if(!isWasmInitialized) {
7008 throw new Error("initializeWasm() must be awaited first!");
7010 var new_obj_idx = js_objs.length;
7011 for (var i = 0; i < js_objs.length; i++) {
7012 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7014 js_objs[i] = new WeakRef(impl);
7015 return [wasm.TS_LDKLockableScore_new(i), i];
7017 // LDKScore LockableScore_lock LDKLockableScore *NONNULL_PTR this_arg
7019 export function LockableScore_lock(this_arg: bigint): bigint {
7020 if(!isWasmInitialized) {
7021 throw new Error("initializeWasm() must be awaited first!");
7023 const nativeResponseValue = wasm.TS_LockableScore_lock(this_arg);
7024 return nativeResponseValue;
7027 export interface LDKWriteableScore {
7032 export function LDKWriteableScore_new(impl: LDKWriteableScore, LockableScore: number): [bigint, number] {
7033 if(!isWasmInitialized) {
7034 throw new Error("initializeWasm() must be awaited first!");
7036 var new_obj_idx = js_objs.length;
7037 for (var i = 0; i < js_objs.length; i++) {
7038 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7040 js_objs[i] = new WeakRef(impl);
7041 return [wasm.TS_LDKWriteableScore_new(i, LockableScore), i];
7043 // LDKCVec_u8Z WriteableScore_write LDKWriteableScore *NONNULL_PTR this_arg
7045 export function WriteableScore_write(this_arg: bigint): number {
7046 if(!isWasmInitialized) {
7047 throw new Error("initializeWasm() must be awaited first!");
7049 const nativeResponseValue = wasm.TS_WriteableScore_write(this_arg);
7050 return nativeResponseValue;
7053 export interface LDKPersister {
7054 persist_manager (channel_manager: bigint): bigint;
7055 persist_graph (network_graph: bigint): bigint;
7056 persist_scorer (scorer: bigint): bigint;
7060 export function LDKPersister_new(impl: LDKPersister): [bigint, number] {
7061 if(!isWasmInitialized) {
7062 throw new Error("initializeWasm() must be awaited first!");
7064 var new_obj_idx = js_objs.length;
7065 for (var i = 0; i < js_objs.length; i++) {
7066 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7068 js_objs[i] = new WeakRef(impl);
7069 return [wasm.TS_LDKPersister_new(i), i];
7071 // LDKCResult_NoneErrorZ Persister_persist_manager LDKPersister *NONNULL_PTR this_arg, const struct LDKChannelManager *NONNULL_PTR channel_manager
7073 export function Persister_persist_manager(this_arg: bigint, channel_manager: bigint): bigint {
7074 if(!isWasmInitialized) {
7075 throw new Error("initializeWasm() must be awaited first!");
7077 const nativeResponseValue = wasm.TS_Persister_persist_manager(this_arg, channel_manager);
7078 return nativeResponseValue;
7080 // LDKCResult_NoneErrorZ Persister_persist_graph LDKPersister *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR network_graph
7082 export function Persister_persist_graph(this_arg: bigint, network_graph: bigint): bigint {
7083 if(!isWasmInitialized) {
7084 throw new Error("initializeWasm() must be awaited first!");
7086 const nativeResponseValue = wasm.TS_Persister_persist_graph(this_arg, network_graph);
7087 return nativeResponseValue;
7089 // LDKCResult_NoneErrorZ Persister_persist_scorer LDKPersister *NONNULL_PTR this_arg, const struct LDKWriteableScore *NONNULL_PTR scorer
7091 export function Persister_persist_scorer(this_arg: bigint, scorer: bigint): bigint {
7092 if(!isWasmInitialized) {
7093 throw new Error("initializeWasm() must be awaited first!");
7095 const nativeResponseValue = wasm.TS_Persister_persist_scorer(this_arg, scorer);
7096 return nativeResponseValue;
7099 export interface LDKFutureCallback {
7104 export function LDKFutureCallback_new(impl: LDKFutureCallback): [bigint, number] {
7105 if(!isWasmInitialized) {
7106 throw new Error("initializeWasm() must be awaited first!");
7108 var new_obj_idx = js_objs.length;
7109 for (var i = 0; i < js_objs.length; i++) {
7110 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7112 js_objs[i] = new WeakRef(impl);
7113 return [wasm.TS_LDKFutureCallback_new(i), i];
7115 // void FutureCallback_call LDKFutureCallback *NONNULL_PTR this_arg
7117 export function FutureCallback_call(this_arg: bigint): void {
7118 if(!isWasmInitialized) {
7119 throw new Error("initializeWasm() must be awaited first!");
7121 const nativeResponseValue = wasm.TS_FutureCallback_call(this_arg);
7122 // debug statements here
7125 export interface LDKListen {
7126 filtered_block_connected (header: number, txdata: number, height: number): void;
7127 block_connected (block: number, height: number): void;
7128 block_disconnected (header: number, height: number): void;
7132 export function LDKListen_new(impl: LDKListen): [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_LDKListen_new(i), i];
7143 // void Listen_filtered_block_connected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
7145 export function Listen_filtered_block_connected(this_arg: bigint, header: number, txdata: number, height: number): void {
7146 if(!isWasmInitialized) {
7147 throw new Error("initializeWasm() must be awaited first!");
7149 const nativeResponseValue = wasm.TS_Listen_filtered_block_connected(this_arg, header, txdata, height);
7150 // debug statements here
7152 // void Listen_block_connected LDKListen *NONNULL_PTR this_arg, struct LDKu8slice block, uint32_t height
7154 export function Listen_block_connected(this_arg: bigint, block: number, height: number): void {
7155 if(!isWasmInitialized) {
7156 throw new Error("initializeWasm() must be awaited first!");
7158 const nativeResponseValue = wasm.TS_Listen_block_connected(this_arg, block, height);
7159 // debug statements here
7161 // void Listen_block_disconnected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
7163 export function Listen_block_disconnected(this_arg: bigint, header: number, height: number): void {
7164 if(!isWasmInitialized) {
7165 throw new Error("initializeWasm() must be awaited first!");
7167 const nativeResponseValue = wasm.TS_Listen_block_disconnected(this_arg, header, height);
7168 // debug statements here
7171 export interface LDKConfirm {
7172 transactions_confirmed (header: number, txdata: number, height: number): void;
7173 transaction_unconfirmed (txid: number): void;
7174 best_block_updated (header: number, height: number): void;
7175 get_relevant_txids (): number;
7179 export function LDKConfirm_new(impl: LDKConfirm): [bigint, number] {
7180 if(!isWasmInitialized) {
7181 throw new Error("initializeWasm() must be awaited first!");
7183 var new_obj_idx = js_objs.length;
7184 for (var i = 0; i < js_objs.length; i++) {
7185 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7187 js_objs[i] = new WeakRef(impl);
7188 return [wasm.TS_LDKConfirm_new(i), i];
7190 // void Confirm_transactions_confirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
7192 export function Confirm_transactions_confirmed(this_arg: bigint, header: number, txdata: number, height: number): void {
7193 if(!isWasmInitialized) {
7194 throw new Error("initializeWasm() must be awaited first!");
7196 const nativeResponseValue = wasm.TS_Confirm_transactions_confirmed(this_arg, header, txdata, height);
7197 // debug statements here
7199 // void Confirm_transaction_unconfirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*txid)[32]
7201 export function Confirm_transaction_unconfirmed(this_arg: bigint, txid: number): void {
7202 if(!isWasmInitialized) {
7203 throw new Error("initializeWasm() must be awaited first!");
7205 const nativeResponseValue = wasm.TS_Confirm_transaction_unconfirmed(this_arg, txid);
7206 // debug statements here
7208 // void Confirm_best_block_updated LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
7210 export function Confirm_best_block_updated(this_arg: bigint, header: number, height: number): void {
7211 if(!isWasmInitialized) {
7212 throw new Error("initializeWasm() must be awaited first!");
7214 const nativeResponseValue = wasm.TS_Confirm_best_block_updated(this_arg, header, height);
7215 // debug statements here
7217 // LDKCVec_C2Tuple_TxidBlockHashZZ Confirm_get_relevant_txids LDKConfirm *NONNULL_PTR this_arg
7219 export function Confirm_get_relevant_txids(this_arg: bigint): number {
7220 if(!isWasmInitialized) {
7221 throw new Error("initializeWasm() must be awaited first!");
7223 const nativeResponseValue = wasm.TS_Confirm_get_relevant_txids(this_arg);
7224 return nativeResponseValue;
7227 export interface LDKPersist {
7228 persist_new_channel (channel_id: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus;
7229 update_persisted_channel (channel_id: bigint, update: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus;
7233 export function LDKPersist_new(impl: LDKPersist): [bigint, number] {
7234 if(!isWasmInitialized) {
7235 throw new Error("initializeWasm() must be awaited first!");
7237 var new_obj_idx = js_objs.length;
7238 for (var i = 0; i < js_objs.length; i++) {
7239 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7241 js_objs[i] = new WeakRef(impl);
7242 return [wasm.TS_LDKPersist_new(i), i];
7244 // LDKChannelMonitorUpdateStatus Persist_persist_new_channel LDKPersist *NONNULL_PTR this_arg, struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id
7246 export function Persist_persist_new_channel(this_arg: bigint, channel_id: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus {
7247 if(!isWasmInitialized) {
7248 throw new Error("initializeWasm() must be awaited first!");
7250 const nativeResponseValue = wasm.TS_Persist_persist_new_channel(this_arg, channel_id, data, update_id);
7251 return nativeResponseValue;
7253 // LDKChannelMonitorUpdateStatus Persist_update_persisted_channel LDKPersist *NONNULL_PTR this_arg, struct LDKOutPoint channel_id, struct LDKChannelMonitorUpdate update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id
7255 export function Persist_update_persisted_channel(this_arg: bigint, channel_id: bigint, update: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus {
7256 if(!isWasmInitialized) {
7257 throw new Error("initializeWasm() must be awaited first!");
7259 const nativeResponseValue = wasm.TS_Persist_update_persisted_channel(this_arg, channel_id, update, data, update_id);
7260 return nativeResponseValue;
7263 export class LDKRetry {
7264 protected constructor() {}
7267 export function LDKRetry_ty_from_ptr(ptr: bigint): number {
7268 if(!isWasmInitialized) {
7269 throw new Error("initializeWasm() must be awaited first!");
7271 const nativeResponseValue = wasm.TS_LDKRetry_ty_from_ptr(ptr);
7272 return nativeResponseValue;
7275 export function LDKRetry_Attempts_get_attempts(ptr: bigint): number {
7276 if(!isWasmInitialized) {
7277 throw new Error("initializeWasm() must be awaited first!");
7279 const nativeResponseValue = wasm.TS_LDKRetry_Attempts_get_attempts(ptr);
7280 return nativeResponseValue;
7283 export interface LDKChannelMessageHandler {
7284 handle_open_channel (their_node_id: number, msg: bigint): void;
7285 handle_accept_channel (their_node_id: number, msg: bigint): void;
7286 handle_funding_created (their_node_id: number, msg: bigint): void;
7287 handle_funding_signed (their_node_id: number, msg: bigint): void;
7288 handle_channel_ready (their_node_id: number, msg: bigint): void;
7289 handle_shutdown (their_node_id: number, msg: bigint): void;
7290 handle_closing_signed (their_node_id: number, msg: bigint): void;
7291 handle_update_add_htlc (their_node_id: number, msg: bigint): void;
7292 handle_update_fulfill_htlc (their_node_id: number, msg: bigint): void;
7293 handle_update_fail_htlc (their_node_id: number, msg: bigint): void;
7294 handle_update_fail_malformed_htlc (their_node_id: number, msg: bigint): void;
7295 handle_commitment_signed (their_node_id: number, msg: bigint): void;
7296 handle_revoke_and_ack (their_node_id: number, msg: bigint): void;
7297 handle_update_fee (their_node_id: number, msg: bigint): void;
7298 handle_announcement_signatures (their_node_id: number, msg: bigint): void;
7299 peer_disconnected (their_node_id: number): void;
7300 peer_connected (their_node_id: number, msg: bigint, inbound: boolean): bigint;
7301 handle_channel_reestablish (their_node_id: number, msg: bigint): void;
7302 handle_channel_update (their_node_id: number, msg: bigint): void;
7303 handle_error (their_node_id: number, msg: bigint): void;
7304 provided_node_features (): bigint;
7305 provided_init_features (their_node_id: number): bigint;
7309 export function LDKChannelMessageHandler_new(impl: LDKChannelMessageHandler, MessageSendEventsProvider: number): [bigint, number] {
7310 if(!isWasmInitialized) {
7311 throw new Error("initializeWasm() must be awaited first!");
7313 var new_obj_idx = js_objs.length;
7314 for (var i = 0; i < js_objs.length; i++) {
7315 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7317 js_objs[i] = new WeakRef(impl);
7318 return [wasm.TS_LDKChannelMessageHandler_new(i, MessageSendEventsProvider), i];
7320 // void ChannelMessageHandler_handle_open_channel LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKOpenChannel *NONNULL_PTR msg
7322 export function ChannelMessageHandler_handle_open_channel(this_arg: bigint, their_node_id: number, msg: bigint): void {
7323 if(!isWasmInitialized) {
7324 throw new Error("initializeWasm() must be awaited first!");
7326 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_open_channel(this_arg, their_node_id, msg);
7327 // debug statements here
7329 // void ChannelMessageHandler_handle_accept_channel LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAcceptChannel *NONNULL_PTR msg
7331 export function ChannelMessageHandler_handle_accept_channel(this_arg: bigint, their_node_id: number, msg: bigint): void {
7332 if(!isWasmInitialized) {
7333 throw new Error("initializeWasm() must be awaited first!");
7335 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_accept_channel(this_arg, their_node_id, msg);
7336 // debug statements here
7338 // void ChannelMessageHandler_handle_funding_created LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg
7340 export function ChannelMessageHandler_handle_funding_created(this_arg: bigint, their_node_id: number, msg: bigint): void {
7341 if(!isWasmInitialized) {
7342 throw new Error("initializeWasm() must be awaited first!");
7344 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_created(this_arg, their_node_id, msg);
7345 // debug statements here
7347 // void ChannelMessageHandler_handle_funding_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg
7349 export function ChannelMessageHandler_handle_funding_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
7350 if(!isWasmInitialized) {
7351 throw new Error("initializeWasm() must be awaited first!");
7353 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_signed(this_arg, their_node_id, msg);
7354 // debug statements here
7356 // void ChannelMessageHandler_handle_channel_ready LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg
7358 export function ChannelMessageHandler_handle_channel_ready(this_arg: bigint, their_node_id: number, msg: bigint): void {
7359 if(!isWasmInitialized) {
7360 throw new Error("initializeWasm() must be awaited first!");
7362 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_ready(this_arg, their_node_id, msg);
7363 // debug statements here
7365 // void ChannelMessageHandler_handle_shutdown LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKShutdown *NONNULL_PTR msg
7367 export function ChannelMessageHandler_handle_shutdown(this_arg: bigint, their_node_id: number, msg: bigint): void {
7368 if(!isWasmInitialized) {
7369 throw new Error("initializeWasm() must be awaited first!");
7371 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_shutdown(this_arg, their_node_id, msg);
7372 // debug statements here
7374 // void ChannelMessageHandler_handle_closing_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg
7376 export function ChannelMessageHandler_handle_closing_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
7377 if(!isWasmInitialized) {
7378 throw new Error("initializeWasm() must be awaited first!");
7380 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_closing_signed(this_arg, their_node_id, msg);
7381 // debug statements here
7383 // void ChannelMessageHandler_handle_update_add_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg
7385 export function ChannelMessageHandler_handle_update_add_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
7386 if(!isWasmInitialized) {
7387 throw new Error("initializeWasm() must be awaited first!");
7389 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_add_htlc(this_arg, their_node_id, msg);
7390 // debug statements here
7392 // void ChannelMessageHandler_handle_update_fulfill_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg
7394 export function ChannelMessageHandler_handle_update_fulfill_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
7395 if(!isWasmInitialized) {
7396 throw new Error("initializeWasm() must be awaited first!");
7398 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fulfill_htlc(this_arg, their_node_id, msg);
7399 // debug statements here
7401 // void ChannelMessageHandler_handle_update_fail_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg
7403 export function ChannelMessageHandler_handle_update_fail_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
7404 if(!isWasmInitialized) {
7405 throw new Error("initializeWasm() must be awaited first!");
7407 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_htlc(this_arg, their_node_id, msg);
7408 // debug statements here
7410 // void ChannelMessageHandler_handle_update_fail_malformed_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg
7412 export function ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
7413 if(!isWasmInitialized) {
7414 throw new Error("initializeWasm() must be awaited first!");
7416 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg, their_node_id, msg);
7417 // debug statements here
7419 // void ChannelMessageHandler_handle_commitment_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg
7421 export function ChannelMessageHandler_handle_commitment_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
7422 if(!isWasmInitialized) {
7423 throw new Error("initializeWasm() must be awaited first!");
7425 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_commitment_signed(this_arg, their_node_id, msg);
7426 // debug statements here
7428 // void ChannelMessageHandler_handle_revoke_and_ack LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg
7430 export function ChannelMessageHandler_handle_revoke_and_ack(this_arg: bigint, their_node_id: number, msg: bigint): void {
7431 if(!isWasmInitialized) {
7432 throw new Error("initializeWasm() must be awaited first!");
7434 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_revoke_and_ack(this_arg, their_node_id, msg);
7435 // debug statements here
7437 // void ChannelMessageHandler_handle_update_fee LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg
7439 export function ChannelMessageHandler_handle_update_fee(this_arg: bigint, their_node_id: number, msg: bigint): void {
7440 if(!isWasmInitialized) {
7441 throw new Error("initializeWasm() must be awaited first!");
7443 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fee(this_arg, their_node_id, msg);
7444 // debug statements here
7446 // void ChannelMessageHandler_handle_announcement_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg
7448 export function ChannelMessageHandler_handle_announcement_signatures(this_arg: bigint, their_node_id: number, msg: bigint): void {
7449 if(!isWasmInitialized) {
7450 throw new Error("initializeWasm() must be awaited first!");
7452 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_announcement_signatures(this_arg, their_node_id, msg);
7453 // debug statements here
7455 // void ChannelMessageHandler_peer_disconnected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
7457 export function ChannelMessageHandler_peer_disconnected(this_arg: bigint, their_node_id: number): void {
7458 if(!isWasmInitialized) {
7459 throw new Error("initializeWasm() must be awaited first!");
7461 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_disconnected(this_arg, their_node_id);
7462 // debug statements here
7464 // LDKCResult_NoneNoneZ ChannelMessageHandler_peer_connected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound
7466 export function ChannelMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, msg: bigint, inbound: boolean): bigint {
7467 if(!isWasmInitialized) {
7468 throw new Error("initializeWasm() must be awaited first!");
7470 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_connected(this_arg, their_node_id, msg, inbound);
7471 return nativeResponseValue;
7473 // void ChannelMessageHandler_handle_channel_reestablish LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg
7475 export function ChannelMessageHandler_handle_channel_reestablish(this_arg: bigint, their_node_id: number, msg: bigint): void {
7476 if(!isWasmInitialized) {
7477 throw new Error("initializeWasm() must be awaited first!");
7479 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_reestablish(this_arg, their_node_id, msg);
7480 // debug statements here
7482 // void ChannelMessageHandler_handle_channel_update LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg
7484 export function ChannelMessageHandler_handle_channel_update(this_arg: bigint, their_node_id: number, msg: bigint): void {
7485 if(!isWasmInitialized) {
7486 throw new Error("initializeWasm() must be awaited first!");
7488 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_update(this_arg, their_node_id, msg);
7489 // debug statements here
7491 // void ChannelMessageHandler_handle_error LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
7493 export function ChannelMessageHandler_handle_error(this_arg: bigint, their_node_id: number, msg: bigint): void {
7494 if(!isWasmInitialized) {
7495 throw new Error("initializeWasm() must be awaited first!");
7497 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_error(this_arg, their_node_id, msg);
7498 // debug statements here
7500 // LDKNodeFeatures ChannelMessageHandler_provided_node_features LDKChannelMessageHandler *NONNULL_PTR this_arg
7502 export function ChannelMessageHandler_provided_node_features(this_arg: bigint): bigint {
7503 if(!isWasmInitialized) {
7504 throw new Error("initializeWasm() must be awaited first!");
7506 const nativeResponseValue = wasm.TS_ChannelMessageHandler_provided_node_features(this_arg);
7507 return nativeResponseValue;
7509 // LDKInitFeatures ChannelMessageHandler_provided_init_features LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
7511 export function ChannelMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
7512 if(!isWasmInitialized) {
7513 throw new Error("initializeWasm() must be awaited first!");
7515 const nativeResponseValue = wasm.TS_ChannelMessageHandler_provided_init_features(this_arg, their_node_id);
7516 return nativeResponseValue;
7519 export interface LDKRoutingMessageHandler {
7520 handle_node_announcement (msg: bigint): bigint;
7521 handle_channel_announcement (msg: bigint): bigint;
7522 handle_channel_update (msg: bigint): bigint;
7523 get_next_channel_announcement (starting_point: bigint): bigint;
7524 get_next_node_announcement (starting_point: bigint): bigint;
7525 peer_connected (their_node_id: number, init: bigint, inbound: boolean): bigint;
7526 handle_reply_channel_range (their_node_id: number, msg: bigint): bigint;
7527 handle_reply_short_channel_ids_end (their_node_id: number, msg: bigint): bigint;
7528 handle_query_channel_range (their_node_id: number, msg: bigint): bigint;
7529 handle_query_short_channel_ids (their_node_id: number, msg: bigint): bigint;
7530 processing_queue_high (): boolean;
7531 provided_node_features (): bigint;
7532 provided_init_features (their_node_id: number): bigint;
7536 export function LDKRoutingMessageHandler_new(impl: LDKRoutingMessageHandler, MessageSendEventsProvider: number): [bigint, number] {
7537 if(!isWasmInitialized) {
7538 throw new Error("initializeWasm() must be awaited first!");
7540 var new_obj_idx = js_objs.length;
7541 for (var i = 0; i < js_objs.length; i++) {
7542 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7544 js_objs[i] = new WeakRef(impl);
7545 return [wasm.TS_LDKRoutingMessageHandler_new(i, MessageSendEventsProvider), i];
7547 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg
7549 export function RoutingMessageHandler_handle_node_announcement(this_arg: bigint, msg: bigint): bigint {
7550 if(!isWasmInitialized) {
7551 throw new Error("initializeWasm() must be awaited first!");
7553 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_node_announcement(this_arg, msg);
7554 return nativeResponseValue;
7556 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg
7558 export function RoutingMessageHandler_handle_channel_announcement(this_arg: bigint, msg: bigint): bigint {
7559 if(!isWasmInitialized) {
7560 throw new Error("initializeWasm() must be awaited first!");
7562 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_announcement(this_arg, msg);
7563 return nativeResponseValue;
7565 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_update LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg
7567 export function RoutingMessageHandler_handle_channel_update(this_arg: bigint, msg: bigint): bigint {
7568 if(!isWasmInitialized) {
7569 throw new Error("initializeWasm() must be awaited first!");
7571 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_update(this_arg, msg);
7572 return nativeResponseValue;
7574 // LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler_get_next_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, uint64_t starting_point
7576 export function RoutingMessageHandler_get_next_channel_announcement(this_arg: bigint, starting_point: bigint): bigint {
7577 if(!isWasmInitialized) {
7578 throw new Error("initializeWasm() must be awaited first!");
7580 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_channel_announcement(this_arg, starting_point);
7581 return nativeResponseValue;
7583 // LDKNodeAnnouncement RoutingMessageHandler_get_next_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKNodeId starting_point
7585 export function RoutingMessageHandler_get_next_node_announcement(this_arg: bigint, starting_point: bigint): bigint {
7586 if(!isWasmInitialized) {
7587 throw new Error("initializeWasm() must be awaited first!");
7589 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_node_announcement(this_arg, starting_point);
7590 return nativeResponseValue;
7592 // LDKCResult_NoneNoneZ RoutingMessageHandler_peer_connected LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound
7594 export function RoutingMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, init: bigint, inbound: boolean): bigint {
7595 if(!isWasmInitialized) {
7596 throw new Error("initializeWasm() must be awaited first!");
7598 const nativeResponseValue = wasm.TS_RoutingMessageHandler_peer_connected(this_arg, their_node_id, init, inbound);
7599 return nativeResponseValue;
7601 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg
7603 export function RoutingMessageHandler_handle_reply_channel_range(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
7604 if(!isWasmInitialized) {
7605 throw new Error("initializeWasm() must be awaited first!");
7607 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_channel_range(this_arg, their_node_id, msg);
7608 return nativeResponseValue;
7610 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_short_channel_ids_end LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg
7612 export function RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
7613 if(!isWasmInitialized) {
7614 throw new Error("initializeWasm() must be awaited first!");
7616 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg, their_node_id, msg);
7617 return nativeResponseValue;
7619 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg
7621 export function RoutingMessageHandler_handle_query_channel_range(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
7622 if(!isWasmInitialized) {
7623 throw new Error("initializeWasm() must be awaited first!");
7625 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_channel_range(this_arg, their_node_id, msg);
7626 return nativeResponseValue;
7628 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_short_channel_ids LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg
7630 export function RoutingMessageHandler_handle_query_short_channel_ids(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
7631 if(!isWasmInitialized) {
7632 throw new Error("initializeWasm() must be awaited first!");
7634 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_short_channel_ids(this_arg, their_node_id, msg);
7635 return nativeResponseValue;
7637 // bool RoutingMessageHandler_processing_queue_high LDKRoutingMessageHandler *NONNULL_PTR this_arg
7639 export function RoutingMessageHandler_processing_queue_high(this_arg: bigint): boolean {
7640 if(!isWasmInitialized) {
7641 throw new Error("initializeWasm() must be awaited first!");
7643 const nativeResponseValue = wasm.TS_RoutingMessageHandler_processing_queue_high(this_arg);
7644 return nativeResponseValue;
7646 // LDKNodeFeatures RoutingMessageHandler_provided_node_features LDKRoutingMessageHandler *NONNULL_PTR this_arg
7648 export function RoutingMessageHandler_provided_node_features(this_arg: bigint): bigint {
7649 if(!isWasmInitialized) {
7650 throw new Error("initializeWasm() must be awaited first!");
7652 const nativeResponseValue = wasm.TS_RoutingMessageHandler_provided_node_features(this_arg);
7653 return nativeResponseValue;
7655 // LDKInitFeatures RoutingMessageHandler_provided_init_features LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
7657 export function RoutingMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
7658 if(!isWasmInitialized) {
7659 throw new Error("initializeWasm() must be awaited first!");
7661 const nativeResponseValue = wasm.TS_RoutingMessageHandler_provided_init_features(this_arg, their_node_id);
7662 return nativeResponseValue;
7665 export interface LDKOnionMessageHandler {
7666 handle_onion_message (peer_node_id: number, msg: bigint): void;
7667 peer_connected (their_node_id: number, init: bigint, inbound: boolean): bigint;
7668 peer_disconnected (their_node_id: number): void;
7669 provided_node_features (): bigint;
7670 provided_init_features (their_node_id: number): bigint;
7674 export function LDKOnionMessageHandler_new(impl: LDKOnionMessageHandler, OnionMessageProvider: number): [bigint, number] {
7675 if(!isWasmInitialized) {
7676 throw new Error("initializeWasm() must be awaited first!");
7678 var new_obj_idx = js_objs.length;
7679 for (var i = 0; i < js_objs.length; i++) {
7680 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7682 js_objs[i] = new WeakRef(impl);
7683 return [wasm.TS_LDKOnionMessageHandler_new(i, OnionMessageProvider), i];
7685 // void OnionMessageHandler_handle_onion_message LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg
7687 export function OnionMessageHandler_handle_onion_message(this_arg: bigint, peer_node_id: number, msg: bigint): void {
7688 if(!isWasmInitialized) {
7689 throw new Error("initializeWasm() must be awaited first!");
7691 const nativeResponseValue = wasm.TS_OnionMessageHandler_handle_onion_message(this_arg, peer_node_id, msg);
7692 // debug statements here
7694 // LDKCResult_NoneNoneZ OnionMessageHandler_peer_connected LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound
7696 export function OnionMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, init: bigint, inbound: boolean): bigint {
7697 if(!isWasmInitialized) {
7698 throw new Error("initializeWasm() must be awaited first!");
7700 const nativeResponseValue = wasm.TS_OnionMessageHandler_peer_connected(this_arg, their_node_id, init, inbound);
7701 return nativeResponseValue;
7703 // void OnionMessageHandler_peer_disconnected LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
7705 export function OnionMessageHandler_peer_disconnected(this_arg: bigint, their_node_id: number): void {
7706 if(!isWasmInitialized) {
7707 throw new Error("initializeWasm() must be awaited first!");
7709 const nativeResponseValue = wasm.TS_OnionMessageHandler_peer_disconnected(this_arg, their_node_id);
7710 // debug statements here
7712 // LDKNodeFeatures OnionMessageHandler_provided_node_features LDKOnionMessageHandler *NONNULL_PTR this_arg
7714 export function OnionMessageHandler_provided_node_features(this_arg: bigint): bigint {
7715 if(!isWasmInitialized) {
7716 throw new Error("initializeWasm() must be awaited first!");
7718 const nativeResponseValue = wasm.TS_OnionMessageHandler_provided_node_features(this_arg);
7719 return nativeResponseValue;
7721 // LDKInitFeatures OnionMessageHandler_provided_init_features LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
7723 export function OnionMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
7724 if(!isWasmInitialized) {
7725 throw new Error("initializeWasm() must be awaited first!");
7727 const nativeResponseValue = wasm.TS_OnionMessageHandler_provided_init_features(this_arg, their_node_id);
7728 return nativeResponseValue;
7731 export interface LDKCustomMessageReader {
7732 read (message_type: number, buffer: number): bigint;
7736 export function LDKCustomMessageReader_new(impl: LDKCustomMessageReader): [bigint, number] {
7737 if(!isWasmInitialized) {
7738 throw new Error("initializeWasm() must be awaited first!");
7740 var new_obj_idx = js_objs.length;
7741 for (var i = 0; i < js_objs.length; i++) {
7742 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7744 js_objs[i] = new WeakRef(impl);
7745 return [wasm.TS_LDKCustomMessageReader_new(i), i];
7747 // LDKCResult_COption_TypeZDecodeErrorZ CustomMessageReader_read LDKCustomMessageReader *NONNULL_PTR this_arg, uint16_t message_type, struct LDKu8slice buffer
7749 export function CustomMessageReader_read(this_arg: bigint, message_type: number, buffer: number): bigint {
7750 if(!isWasmInitialized) {
7751 throw new Error("initializeWasm() must be awaited first!");
7753 const nativeResponseValue = wasm.TS_CustomMessageReader_read(this_arg, message_type, buffer);
7754 return nativeResponseValue;
7757 export interface LDKCustomMessageHandler {
7758 handle_custom_message (msg: bigint, sender_node_id: number): bigint;
7759 get_and_clear_pending_msg (): number;
7763 export function LDKCustomMessageHandler_new(impl: LDKCustomMessageHandler, CustomMessageReader: number): [bigint, number] {
7764 if(!isWasmInitialized) {
7765 throw new Error("initializeWasm() must be awaited first!");
7767 var new_obj_idx = js_objs.length;
7768 for (var i = 0; i < js_objs.length; i++) {
7769 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7771 js_objs[i] = new WeakRef(impl);
7772 return [wasm.TS_LDKCustomMessageHandler_new(i, CustomMessageReader), i];
7774 // LDKCResult_NoneLightningErrorZ CustomMessageHandler_handle_custom_message LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKType msg, struct LDKPublicKey sender_node_id
7776 export function CustomMessageHandler_handle_custom_message(this_arg: bigint, msg: bigint, sender_node_id: number): bigint {
7777 if(!isWasmInitialized) {
7778 throw new Error("initializeWasm() must be awaited first!");
7780 const nativeResponseValue = wasm.TS_CustomMessageHandler_handle_custom_message(this_arg, msg, sender_node_id);
7781 return nativeResponseValue;
7783 // LDKCVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler_get_and_clear_pending_msg LDKCustomMessageHandler *NONNULL_PTR this_arg
7785 export function CustomMessageHandler_get_and_clear_pending_msg(this_arg: bigint): number {
7786 if(!isWasmInitialized) {
7787 throw new Error("initializeWasm() must be awaited first!");
7789 const nativeResponseValue = wasm.TS_CustomMessageHandler_get_and_clear_pending_msg(this_arg);
7790 return nativeResponseValue;
7793 export interface LDKCustomOnionMessageHandler {
7794 handle_custom_message (msg: bigint): void;
7795 read_custom_message (message_type: bigint, buffer: number): bigint;
7799 export function LDKCustomOnionMessageHandler_new(impl: LDKCustomOnionMessageHandler): [bigint, number] {
7800 if(!isWasmInitialized) {
7801 throw new Error("initializeWasm() must be awaited first!");
7803 var new_obj_idx = js_objs.length;
7804 for (var i = 0; i < js_objs.length; i++) {
7805 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7807 js_objs[i] = new WeakRef(impl);
7808 return [wasm.TS_LDKCustomOnionMessageHandler_new(i), i];
7810 // void CustomOnionMessageHandler_handle_custom_message LDKCustomOnionMessageHandler *NONNULL_PTR this_arg, struct LDKCustomOnionMessageContents msg
7812 export function CustomOnionMessageHandler_handle_custom_message(this_arg: bigint, msg: bigint): void {
7813 if(!isWasmInitialized) {
7814 throw new Error("initializeWasm() must be awaited first!");
7816 const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_handle_custom_message(this_arg, msg);
7817 // debug statements here
7819 // LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ CustomOnionMessageHandler_read_custom_message LDKCustomOnionMessageHandler *NONNULL_PTR this_arg, uint64_t message_type, struct LDKu8slice buffer
7821 export function CustomOnionMessageHandler_read_custom_message(this_arg: bigint, message_type: bigint, buffer: number): bigint {
7822 if(!isWasmInitialized) {
7823 throw new Error("initializeWasm() must be awaited first!");
7825 const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_read_custom_message(this_arg, message_type, buffer);
7826 return nativeResponseValue;
7829 export interface LDKSocketDescriptor {
7830 send_data (data: number, resume_read: boolean): number;
7831 disconnect_socket (): void;
7832 eq (other_arg: bigint): boolean;
7837 export function LDKSocketDescriptor_new(impl: LDKSocketDescriptor): [bigint, number] {
7838 if(!isWasmInitialized) {
7839 throw new Error("initializeWasm() must be awaited first!");
7841 var new_obj_idx = js_objs.length;
7842 for (var i = 0; i < js_objs.length; i++) {
7843 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7845 js_objs[i] = new WeakRef(impl);
7846 return [wasm.TS_LDKSocketDescriptor_new(i), i];
7848 // uintptr_t SocketDescriptor_send_data LDKSocketDescriptor *NONNULL_PTR this_arg, struct LDKu8slice data, bool resume_read
7850 export function SocketDescriptor_send_data(this_arg: bigint, data: number, resume_read: boolean): number {
7851 if(!isWasmInitialized) {
7852 throw new Error("initializeWasm() must be awaited first!");
7854 const nativeResponseValue = wasm.TS_SocketDescriptor_send_data(this_arg, data, resume_read);
7855 return nativeResponseValue;
7857 // void SocketDescriptor_disconnect_socket LDKSocketDescriptor *NONNULL_PTR this_arg
7859 export function SocketDescriptor_disconnect_socket(this_arg: bigint): void {
7860 if(!isWasmInitialized) {
7861 throw new Error("initializeWasm() must be awaited first!");
7863 const nativeResponseValue = wasm.TS_SocketDescriptor_disconnect_socket(this_arg);
7864 // debug statements here
7866 // uint64_t SocketDescriptor_hash LDKSocketDescriptor *NONNULL_PTR this_arg
7868 export function SocketDescriptor_hash(this_arg: bigint): bigint {
7869 if(!isWasmInitialized) {
7870 throw new Error("initializeWasm() must be awaited first!");
7872 const nativeResponseValue = wasm.TS_SocketDescriptor_hash(this_arg);
7873 return nativeResponseValue;
7876 export class LDKEffectiveCapacity {
7877 protected constructor() {}
7880 export function LDKEffectiveCapacity_ty_from_ptr(ptr: bigint): number {
7881 if(!isWasmInitialized) {
7882 throw new Error("initializeWasm() must be awaited first!");
7884 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ty_from_ptr(ptr);
7885 return nativeResponseValue;
7888 export function LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr: bigint): bigint {
7889 if(!isWasmInitialized) {
7890 throw new Error("initializeWasm() must be awaited first!");
7892 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr);
7893 return nativeResponseValue;
7896 export function LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr: bigint): bigint {
7897 if(!isWasmInitialized) {
7898 throw new Error("initializeWasm() must be awaited first!");
7900 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr);
7901 return nativeResponseValue;
7904 export function LDKEffectiveCapacity_Total_get_capacity_msat(ptr: bigint): bigint {
7905 if(!isWasmInitialized) {
7906 throw new Error("initializeWasm() must be awaited first!");
7908 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_capacity_msat(ptr);
7909 return nativeResponseValue;
7912 export function LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr: bigint): bigint {
7913 if(!isWasmInitialized) {
7914 throw new Error("initializeWasm() must be awaited first!");
7916 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr);
7917 return nativeResponseValue;
7920 export class LDKDestination {
7921 protected constructor() {}
7924 export function LDKDestination_ty_from_ptr(ptr: bigint): number {
7925 if(!isWasmInitialized) {
7926 throw new Error("initializeWasm() must be awaited first!");
7928 const nativeResponseValue = wasm.TS_LDKDestination_ty_from_ptr(ptr);
7929 return nativeResponseValue;
7932 export function LDKDestination_Node_get_node(ptr: bigint): number {
7933 if(!isWasmInitialized) {
7934 throw new Error("initializeWasm() must be awaited first!");
7936 const nativeResponseValue = wasm.TS_LDKDestination_Node_get_node(ptr);
7937 return nativeResponseValue;
7940 export function LDKDestination_BlindedPath_get_blinded_path(ptr: bigint): bigint {
7941 if(!isWasmInitialized) {
7942 throw new Error("initializeWasm() must be awaited first!");
7944 const nativeResponseValue = wasm.TS_LDKDestination_BlindedPath_get_blinded_path(ptr);
7945 return nativeResponseValue;
7948 export class LDKOnionMessageContents {
7949 protected constructor() {}
7952 export function LDKOnionMessageContents_ty_from_ptr(ptr: bigint): number {
7953 if(!isWasmInitialized) {
7954 throw new Error("initializeWasm() must be awaited first!");
7956 const nativeResponseValue = wasm.TS_LDKOnionMessageContents_ty_from_ptr(ptr);
7957 return nativeResponseValue;
7960 export function LDKOnionMessageContents_Custom_get_custom(ptr: bigint): bigint {
7961 if(!isWasmInitialized) {
7962 throw new Error("initializeWasm() must be awaited first!");
7964 const nativeResponseValue = wasm.TS_LDKOnionMessageContents_Custom_get_custom(ptr);
7965 return nativeResponseValue;
7968 export class LDKGossipSync {
7969 protected constructor() {}
7972 export function LDKGossipSync_ty_from_ptr(ptr: bigint): number {
7973 if(!isWasmInitialized) {
7974 throw new Error("initializeWasm() must be awaited first!");
7976 const nativeResponseValue = wasm.TS_LDKGossipSync_ty_from_ptr(ptr);
7977 return nativeResponseValue;
7980 export function LDKGossipSync_P2P_get_p2p(ptr: bigint): bigint {
7981 if(!isWasmInitialized) {
7982 throw new Error("initializeWasm() must be awaited first!");
7984 const nativeResponseValue = wasm.TS_LDKGossipSync_P2P_get_p2p(ptr);
7985 return nativeResponseValue;
7988 export function LDKGossipSync_Rapid_get_rapid(ptr: bigint): bigint {
7989 if(!isWasmInitialized) {
7990 throw new Error("initializeWasm() must be awaited first!");
7992 const nativeResponseValue = wasm.TS_LDKGossipSync_Rapid_get_rapid(ptr);
7993 return nativeResponseValue;
7996 export class LDKFallback {
7997 protected constructor() {}
8000 export function LDKFallback_ty_from_ptr(ptr: bigint): number {
8001 if(!isWasmInitialized) {
8002 throw new Error("initializeWasm() must be awaited first!");
8004 const nativeResponseValue = wasm.TS_LDKFallback_ty_from_ptr(ptr);
8005 return nativeResponseValue;
8008 export function LDKFallback_SegWitProgram_get_version(ptr: bigint): number {
8009 if(!isWasmInitialized) {
8010 throw new Error("initializeWasm() must be awaited first!");
8012 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_version(ptr);
8013 return nativeResponseValue;
8016 export function LDKFallback_SegWitProgram_get_program(ptr: bigint): number {
8017 if(!isWasmInitialized) {
8018 throw new Error("initializeWasm() must be awaited first!");
8020 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_program(ptr);
8021 return nativeResponseValue;
8024 export function LDKFallback_PubKeyHash_get_pub_key_hash(ptr: bigint): number {
8025 if(!isWasmInitialized) {
8026 throw new Error("initializeWasm() must be awaited first!");
8028 const nativeResponseValue = wasm.TS_LDKFallback_PubKeyHash_get_pub_key_hash(ptr);
8029 return nativeResponseValue;
8032 export function LDKFallback_ScriptHash_get_script_hash(ptr: bigint): number {
8033 if(!isWasmInitialized) {
8034 throw new Error("initializeWasm() must be awaited first!");
8036 const nativeResponseValue = wasm.TS_LDKFallback_ScriptHash_get_script_hash(ptr);
8037 return nativeResponseValue;
8039 // struct LDKStr _ldk_get_compiled_version(void);
8041 export function _ldk_get_compiled_version(): number {
8042 if(!isWasmInitialized) {
8043 throw new Error("initializeWasm() must be awaited first!");
8045 const nativeResponseValue = wasm.TS__ldk_get_compiled_version();
8046 return nativeResponseValue;
8048 // struct LDKStr _ldk_c_bindings_get_compiled_version(void);
8050 export function _ldk_c_bindings_get_compiled_version(): number {
8051 if(!isWasmInitialized) {
8052 throw new Error("initializeWasm() must be awaited first!");
8054 const nativeResponseValue = wasm.TS__ldk_c_bindings_get_compiled_version();
8055 return nativeResponseValue;
8057 // struct LDKSixteenBytes U128_le_bytes(struct LDKU128 val);
8059 export function U128_le_bytes(val: number): number {
8060 if(!isWasmInitialized) {
8061 throw new Error("initializeWasm() must be awaited first!");
8063 const nativeResponseValue = wasm.TS_U128_le_bytes(val);
8064 return nativeResponseValue;
8066 // struct LDKU128 U128_new(struct LDKSixteenBytes le_bytes);
8068 export function U128_new(le_bytes: number): number {
8069 if(!isWasmInitialized) {
8070 throw new Error("initializeWasm() must be awaited first!");
8072 const nativeResponseValue = wasm.TS_U128_new(le_bytes);
8073 return nativeResponseValue;
8075 // struct LDKBigEndianScalar BigEndianScalar_new(struct LDKThirtyTwoBytes big_endian_bytes);
8077 export function BigEndianScalar_new(big_endian_bytes: number): bigint {
8078 if(!isWasmInitialized) {
8079 throw new Error("initializeWasm() must be awaited first!");
8081 const nativeResponseValue = wasm.TS_BigEndianScalar_new(big_endian_bytes);
8082 return nativeResponseValue;
8084 // uint64_t Bech32Error_clone_ptr(LDKBech32Error *NONNULL_PTR arg);
8086 export function Bech32Error_clone_ptr(arg: bigint): bigint {
8087 if(!isWasmInitialized) {
8088 throw new Error("initializeWasm() must be awaited first!");
8090 const nativeResponseValue = wasm.TS_Bech32Error_clone_ptr(arg);
8091 return nativeResponseValue;
8093 // struct LDKBech32Error Bech32Error_clone(const struct LDKBech32Error *NONNULL_PTR orig);
8095 export function Bech32Error_clone(orig: bigint): bigint {
8096 if(!isWasmInitialized) {
8097 throw new Error("initializeWasm() must be awaited first!");
8099 const nativeResponseValue = wasm.TS_Bech32Error_clone(orig);
8100 return nativeResponseValue;
8102 // void Bech32Error_free(struct LDKBech32Error o);
8104 export function Bech32Error_free(o: bigint): void {
8105 if(!isWasmInitialized) {
8106 throw new Error("initializeWasm() must be awaited first!");
8108 const nativeResponseValue = wasm.TS_Bech32Error_free(o);
8109 // debug statements here
8111 // void Transaction_free(struct LDKTransaction _res);
8113 export function Transaction_free(_res: number): void {
8114 if(!isWasmInitialized) {
8115 throw new Error("initializeWasm() must be awaited first!");
8117 const nativeResponseValue = wasm.TS_Transaction_free(_res);
8118 // debug statements here
8120 // void Witness_free(struct LDKWitness _res);
8122 export function Witness_free(_res: number): void {
8123 if(!isWasmInitialized) {
8124 throw new Error("initializeWasm() must be awaited first!");
8126 const nativeResponseValue = wasm.TS_Witness_free(_res);
8127 // debug statements here
8129 // struct LDKTxOut TxOut_new(struct LDKCVec_u8Z script_pubkey, uint64_t value);
8131 export function TxOut_new(script_pubkey: number, value: bigint): bigint {
8132 if(!isWasmInitialized) {
8133 throw new Error("initializeWasm() must be awaited first!");
8135 const nativeResponseValue = wasm.TS_TxOut_new(script_pubkey, value);
8136 return nativeResponseValue;
8138 // void TxOut_free(struct LDKTxOut _res);
8140 export function TxOut_free(_res: bigint): void {
8141 if(!isWasmInitialized) {
8142 throw new Error("initializeWasm() must be awaited first!");
8144 const nativeResponseValue = wasm.TS_TxOut_free(_res);
8145 // debug statements here
8147 // uint64_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg);
8149 export function TxOut_clone_ptr(arg: bigint): bigint {
8150 if(!isWasmInitialized) {
8151 throw new Error("initializeWasm() must be awaited first!");
8153 const nativeResponseValue = wasm.TS_TxOut_clone_ptr(arg);
8154 return nativeResponseValue;
8156 // struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
8158 export function TxOut_clone(orig: bigint): bigint {
8159 if(!isWasmInitialized) {
8160 throw new Error("initializeWasm() must be awaited first!");
8162 const nativeResponseValue = wasm.TS_TxOut_clone(orig);
8163 return nativeResponseValue;
8165 // void Str_free(struct LDKStr _res);
8167 export function Str_free(_res: number): void {
8168 if(!isWasmInitialized) {
8169 throw new Error("initializeWasm() must be awaited first!");
8171 const nativeResponseValue = wasm.TS_Str_free(_res);
8172 // debug statements here
8174 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
8176 export function CResult_NoneAPIErrorZ_ok(): bigint {
8177 if(!isWasmInitialized) {
8178 throw new Error("initializeWasm() must be awaited first!");
8180 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_ok();
8181 return nativeResponseValue;
8183 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
8185 export function CResult_NoneAPIErrorZ_err(e: bigint): bigint {
8186 if(!isWasmInitialized) {
8187 throw new Error("initializeWasm() must be awaited first!");
8189 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_err(e);
8190 return nativeResponseValue;
8192 // bool CResult_NoneAPIErrorZ_is_ok(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR o);
8194 export function CResult_NoneAPIErrorZ_is_ok(o: bigint): boolean {
8195 if(!isWasmInitialized) {
8196 throw new Error("initializeWasm() must be awaited first!");
8198 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_is_ok(o);
8199 return nativeResponseValue;
8201 // void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
8203 export function CResult_NoneAPIErrorZ_free(_res: bigint): void {
8204 if(!isWasmInitialized) {
8205 throw new Error("initializeWasm() must be awaited first!");
8207 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_free(_res);
8208 // debug statements here
8210 // uint64_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg);
8212 export function CResult_NoneAPIErrorZ_clone_ptr(arg: bigint): bigint {
8213 if(!isWasmInitialized) {
8214 throw new Error("initializeWasm() must be awaited first!");
8216 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone_ptr(arg);
8217 return nativeResponseValue;
8219 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
8221 export function CResult_NoneAPIErrorZ_clone(orig: bigint): bigint {
8222 if(!isWasmInitialized) {
8223 throw new Error("initializeWasm() must be awaited first!");
8225 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone(orig);
8226 return nativeResponseValue;
8228 // void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
8230 export function CVec_CResult_NoneAPIErrorZZ_free(_res: number): void {
8231 if(!isWasmInitialized) {
8232 throw new Error("initializeWasm() must be awaited first!");
8234 const nativeResponseValue = wasm.TS_CVec_CResult_NoneAPIErrorZZ_free(_res);
8235 // debug statements here
8237 // void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
8239 export function CVec_APIErrorZ_free(_res: number): void {
8240 if(!isWasmInitialized) {
8241 throw new Error("initializeWasm() must be awaited first!");
8243 const nativeResponseValue = wasm.TS_CVec_APIErrorZ_free(_res);
8244 // debug statements here
8246 // struct LDKCOption_HTLCClaimZ COption_HTLCClaimZ_some(enum LDKHTLCClaim o);
8248 export function COption_HTLCClaimZ_some(o: HTLCClaim): bigint {
8249 if(!isWasmInitialized) {
8250 throw new Error("initializeWasm() must be awaited first!");
8252 const nativeResponseValue = wasm.TS_COption_HTLCClaimZ_some(o);
8253 return nativeResponseValue;
8255 // struct LDKCOption_HTLCClaimZ COption_HTLCClaimZ_none(void);
8257 export function COption_HTLCClaimZ_none(): bigint {
8258 if(!isWasmInitialized) {
8259 throw new Error("initializeWasm() must be awaited first!");
8261 const nativeResponseValue = wasm.TS_COption_HTLCClaimZ_none();
8262 return nativeResponseValue;
8264 // void COption_HTLCClaimZ_free(struct LDKCOption_HTLCClaimZ _res);
8266 export function COption_HTLCClaimZ_free(_res: bigint): void {
8267 if(!isWasmInitialized) {
8268 throw new Error("initializeWasm() must be awaited first!");
8270 const nativeResponseValue = wasm.TS_COption_HTLCClaimZ_free(_res);
8271 // debug statements here
8273 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_ok(void);
8275 export function CResult_NoneNoneZ_ok(): bigint {
8276 if(!isWasmInitialized) {
8277 throw new Error("initializeWasm() must be awaited first!");
8279 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_ok();
8280 return nativeResponseValue;
8282 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_err(void);
8284 export function CResult_NoneNoneZ_err(): bigint {
8285 if(!isWasmInitialized) {
8286 throw new Error("initializeWasm() must be awaited first!");
8288 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_err();
8289 return nativeResponseValue;
8291 // bool CResult_NoneNoneZ_is_ok(const struct LDKCResult_NoneNoneZ *NONNULL_PTR o);
8293 export function CResult_NoneNoneZ_is_ok(o: bigint): boolean {
8294 if(!isWasmInitialized) {
8295 throw new Error("initializeWasm() must be awaited first!");
8297 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_is_ok(o);
8298 return nativeResponseValue;
8300 // void CResult_NoneNoneZ_free(struct LDKCResult_NoneNoneZ _res);
8302 export function CResult_NoneNoneZ_free(_res: bigint): void {
8303 if(!isWasmInitialized) {
8304 throw new Error("initializeWasm() must be awaited first!");
8306 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_free(_res);
8307 // debug statements here
8309 // uint64_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg);
8311 export function CResult_NoneNoneZ_clone_ptr(arg: bigint): bigint {
8312 if(!isWasmInitialized) {
8313 throw new Error("initializeWasm() must be awaited first!");
8315 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone_ptr(arg);
8316 return nativeResponseValue;
8318 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_clone(const struct LDKCResult_NoneNoneZ *NONNULL_PTR orig);
8320 export function CResult_NoneNoneZ_clone(orig: bigint): bigint {
8321 if(!isWasmInitialized) {
8322 throw new Error("initializeWasm() must be awaited first!");
8324 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone(orig);
8325 return nativeResponseValue;
8327 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(struct LDKCounterpartyCommitmentSecrets o);
8329 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o: bigint): bigint {
8330 if(!isWasmInitialized) {
8331 throw new Error("initializeWasm() must be awaited first!");
8333 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o);
8334 return nativeResponseValue;
8336 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(struct LDKDecodeError e);
8338 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e: bigint): bigint {
8339 if(!isWasmInitialized) {
8340 throw new Error("initializeWasm() must be awaited first!");
8342 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e);
8343 return nativeResponseValue;
8345 // bool CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR o);
8347 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o: bigint): boolean {
8348 if(!isWasmInitialized) {
8349 throw new Error("initializeWasm() must be awaited first!");
8351 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o);
8352 return nativeResponseValue;
8354 // void CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ _res);
8356 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res: bigint): void {
8357 if(!isWasmInitialized) {
8358 throw new Error("initializeWasm() must be awaited first!");
8360 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res);
8361 // debug statements here
8363 // uint64_t CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR arg);
8365 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8366 if(!isWasmInitialized) {
8367 throw new Error("initializeWasm() must be awaited first!");
8369 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg);
8370 return nativeResponseValue;
8372 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR orig);
8374 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig: bigint): bigint {
8375 if(!isWasmInitialized) {
8376 throw new Error("initializeWasm() must be awaited first!");
8378 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig);
8379 return nativeResponseValue;
8381 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_ok(struct LDKTxCreationKeys o);
8383 export function CResult_TxCreationKeysDecodeErrorZ_ok(o: bigint): bigint {
8384 if(!isWasmInitialized) {
8385 throw new Error("initializeWasm() must be awaited first!");
8387 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_ok(o);
8388 return nativeResponseValue;
8390 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_err(struct LDKDecodeError e);
8392 export function CResult_TxCreationKeysDecodeErrorZ_err(e: bigint): bigint {
8393 if(!isWasmInitialized) {
8394 throw new Error("initializeWasm() must be awaited first!");
8396 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_err(e);
8397 return nativeResponseValue;
8399 // bool CResult_TxCreationKeysDecodeErrorZ_is_ok(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR o);
8401 export function CResult_TxCreationKeysDecodeErrorZ_is_ok(o: bigint): boolean {
8402 if(!isWasmInitialized) {
8403 throw new Error("initializeWasm() must be awaited first!");
8405 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(o);
8406 return nativeResponseValue;
8408 // void CResult_TxCreationKeysDecodeErrorZ_free(struct LDKCResult_TxCreationKeysDecodeErrorZ _res);
8410 export function CResult_TxCreationKeysDecodeErrorZ_free(_res: bigint): void {
8411 if(!isWasmInitialized) {
8412 throw new Error("initializeWasm() must be awaited first!");
8414 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_free(_res);
8415 // debug statements here
8417 // uint64_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg);
8419 export function CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8420 if(!isWasmInitialized) {
8421 throw new Error("initializeWasm() must be awaited first!");
8423 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg);
8424 return nativeResponseValue;
8426 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_clone(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR orig);
8428 export function CResult_TxCreationKeysDecodeErrorZ_clone(orig: bigint): bigint {
8429 if(!isWasmInitialized) {
8430 throw new Error("initializeWasm() must be awaited first!");
8432 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone(orig);
8433 return nativeResponseValue;
8435 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_ok(struct LDKChannelPublicKeys o);
8437 export function CResult_ChannelPublicKeysDecodeErrorZ_ok(o: bigint): bigint {
8438 if(!isWasmInitialized) {
8439 throw new Error("initializeWasm() must be awaited first!");
8441 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_ok(o);
8442 return nativeResponseValue;
8444 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_err(struct LDKDecodeError e);
8446 export function CResult_ChannelPublicKeysDecodeErrorZ_err(e: bigint): bigint {
8447 if(!isWasmInitialized) {
8448 throw new Error("initializeWasm() must be awaited first!");
8450 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_err(e);
8451 return nativeResponseValue;
8453 // bool CResult_ChannelPublicKeysDecodeErrorZ_is_ok(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR o);
8455 export function CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o: bigint): boolean {
8456 if(!isWasmInitialized) {
8457 throw new Error("initializeWasm() must be awaited first!");
8459 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o);
8460 return nativeResponseValue;
8462 // void CResult_ChannelPublicKeysDecodeErrorZ_free(struct LDKCResult_ChannelPublicKeysDecodeErrorZ _res);
8464 export function CResult_ChannelPublicKeysDecodeErrorZ_free(_res: bigint): void {
8465 if(!isWasmInitialized) {
8466 throw new Error("initializeWasm() must be awaited first!");
8468 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_free(_res);
8469 // debug statements here
8471 // uint64_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg);
8473 export function CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8474 if(!isWasmInitialized) {
8475 throw new Error("initializeWasm() must be awaited first!");
8477 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg);
8478 return nativeResponseValue;
8480 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_clone(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR orig);
8482 export function CResult_ChannelPublicKeysDecodeErrorZ_clone(orig: bigint): bigint {
8483 if(!isWasmInitialized) {
8484 throw new Error("initializeWasm() must be awaited first!");
8486 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(orig);
8487 return nativeResponseValue;
8489 // struct LDKCOption_u32Z COption_u32Z_some(uint32_t o);
8491 export function COption_u32Z_some(o: number): bigint {
8492 if(!isWasmInitialized) {
8493 throw new Error("initializeWasm() must be awaited first!");
8495 const nativeResponseValue = wasm.TS_COption_u32Z_some(o);
8496 return nativeResponseValue;
8498 // struct LDKCOption_u32Z COption_u32Z_none(void);
8500 export function COption_u32Z_none(): bigint {
8501 if(!isWasmInitialized) {
8502 throw new Error("initializeWasm() must be awaited first!");
8504 const nativeResponseValue = wasm.TS_COption_u32Z_none();
8505 return nativeResponseValue;
8507 // void COption_u32Z_free(struct LDKCOption_u32Z _res);
8509 export function COption_u32Z_free(_res: bigint): void {
8510 if(!isWasmInitialized) {
8511 throw new Error("initializeWasm() must be awaited first!");
8513 const nativeResponseValue = wasm.TS_COption_u32Z_free(_res);
8514 // debug statements here
8516 // uint64_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg);
8518 export function COption_u32Z_clone_ptr(arg: bigint): bigint {
8519 if(!isWasmInitialized) {
8520 throw new Error("initializeWasm() must be awaited first!");
8522 const nativeResponseValue = wasm.TS_COption_u32Z_clone_ptr(arg);
8523 return nativeResponseValue;
8525 // struct LDKCOption_u32Z COption_u32Z_clone(const struct LDKCOption_u32Z *NONNULL_PTR orig);
8527 export function COption_u32Z_clone(orig: bigint): bigint {
8528 if(!isWasmInitialized) {
8529 throw new Error("initializeWasm() must be awaited first!");
8531 const nativeResponseValue = wasm.TS_COption_u32Z_clone(orig);
8532 return nativeResponseValue;
8534 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(struct LDKHTLCOutputInCommitment o);
8536 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o: bigint): bigint {
8537 if(!isWasmInitialized) {
8538 throw new Error("initializeWasm() must be awaited first!");
8540 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o);
8541 return nativeResponseValue;
8543 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_err(struct LDKDecodeError e);
8545 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e: bigint): bigint {
8546 if(!isWasmInitialized) {
8547 throw new Error("initializeWasm() must be awaited first!");
8549 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e);
8550 return nativeResponseValue;
8552 // bool CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR o);
8554 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o: bigint): boolean {
8555 if(!isWasmInitialized) {
8556 throw new Error("initializeWasm() must be awaited first!");
8558 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o);
8559 return nativeResponseValue;
8561 // void CResult_HTLCOutputInCommitmentDecodeErrorZ_free(struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res);
8563 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res: bigint): void {
8564 if(!isWasmInitialized) {
8565 throw new Error("initializeWasm() must be awaited first!");
8567 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res);
8568 // debug statements here
8570 // uint64_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg);
8572 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8573 if(!isWasmInitialized) {
8574 throw new Error("initializeWasm() must be awaited first!");
8576 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg);
8577 return nativeResponseValue;
8579 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR orig);
8581 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig: bigint): bigint {
8582 if(!isWasmInitialized) {
8583 throw new Error("initializeWasm() must be awaited first!");
8585 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig);
8586 return nativeResponseValue;
8588 // enum LDKCOption_NoneZ COption_NoneZ_some(void);
8590 export function COption_NoneZ_some(): COption_NoneZ {
8591 if(!isWasmInitialized) {
8592 throw new Error("initializeWasm() must be awaited first!");
8594 const nativeResponseValue = wasm.TS_COption_NoneZ_some();
8595 return nativeResponseValue;
8597 // enum LDKCOption_NoneZ COption_NoneZ_none(void);
8599 export function COption_NoneZ_none(): COption_NoneZ {
8600 if(!isWasmInitialized) {
8601 throw new Error("initializeWasm() must be awaited first!");
8603 const nativeResponseValue = wasm.TS_COption_NoneZ_none();
8604 return nativeResponseValue;
8606 // void COption_NoneZ_free(enum LDKCOption_NoneZ _res);
8608 export function COption_NoneZ_free(_res: COption_NoneZ): void {
8609 if(!isWasmInitialized) {
8610 throw new Error("initializeWasm() must be awaited first!");
8612 const nativeResponseValue = wasm.TS_COption_NoneZ_free(_res);
8613 // debug statements here
8615 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(struct LDKCounterpartyChannelTransactionParameters o);
8617 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o: bigint): bigint {
8618 if(!isWasmInitialized) {
8619 throw new Error("initializeWasm() must be awaited first!");
8621 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o);
8622 return nativeResponseValue;
8624 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
8626 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e: bigint): bigint {
8627 if(!isWasmInitialized) {
8628 throw new Error("initializeWasm() must be awaited first!");
8630 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e);
8631 return nativeResponseValue;
8633 // bool CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
8635 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o: bigint): boolean {
8636 if(!isWasmInitialized) {
8637 throw new Error("initializeWasm() must be awaited first!");
8639 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o);
8640 return nativeResponseValue;
8642 // void CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res);
8644 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res: bigint): void {
8645 if(!isWasmInitialized) {
8646 throw new Error("initializeWasm() must be awaited first!");
8648 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res);
8649 // debug statements here
8651 // uint64_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
8653 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8654 if(!isWasmInitialized) {
8655 throw new Error("initializeWasm() must be awaited first!");
8657 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
8658 return nativeResponseValue;
8660 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
8662 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig: bigint): bigint {
8663 if(!isWasmInitialized) {
8664 throw new Error("initializeWasm() must be awaited first!");
8666 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig);
8667 return nativeResponseValue;
8669 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_ok(struct LDKChannelTransactionParameters o);
8671 export function CResult_ChannelTransactionParametersDecodeErrorZ_ok(o: bigint): bigint {
8672 if(!isWasmInitialized) {
8673 throw new Error("initializeWasm() must be awaited first!");
8675 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok(o);
8676 return nativeResponseValue;
8678 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
8680 export function CResult_ChannelTransactionParametersDecodeErrorZ_err(e: bigint): bigint {
8681 if(!isWasmInitialized) {
8682 throw new Error("initializeWasm() must be awaited first!");
8684 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_err(e);
8685 return nativeResponseValue;
8687 // bool CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
8689 export function CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o: bigint): boolean {
8690 if(!isWasmInitialized) {
8691 throw new Error("initializeWasm() must be awaited first!");
8693 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o);
8694 return nativeResponseValue;
8696 // void CResult_ChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_ChannelTransactionParametersDecodeErrorZ _res);
8698 export function CResult_ChannelTransactionParametersDecodeErrorZ_free(_res: bigint): void {
8699 if(!isWasmInitialized) {
8700 throw new Error("initializeWasm() must be awaited first!");
8702 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(_res);
8703 // debug statements here
8705 // uint64_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
8707 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8708 if(!isWasmInitialized) {
8709 throw new Error("initializeWasm() must be awaited first!");
8711 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
8712 return nativeResponseValue;
8714 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
8716 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig: bigint): bigint {
8717 if(!isWasmInitialized) {
8718 throw new Error("initializeWasm() must be awaited first!");
8720 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig);
8721 return nativeResponseValue;
8723 // void CVec_SignatureZ_free(struct LDKCVec_SignatureZ _res);
8725 export function CVec_SignatureZ_free(_res: number): void {
8726 if(!isWasmInitialized) {
8727 throw new Error("initializeWasm() must be awaited first!");
8729 const nativeResponseValue = wasm.TS_CVec_SignatureZ_free(_res);
8730 // debug statements here
8732 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_ok(struct LDKHolderCommitmentTransaction o);
8734 export function CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
8735 if(!isWasmInitialized) {
8736 throw new Error("initializeWasm() must be awaited first!");
8738 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o);
8739 return nativeResponseValue;
8741 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
8743 export function CResult_HolderCommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
8744 if(!isWasmInitialized) {
8745 throw new Error("initializeWasm() must be awaited first!");
8747 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err(e);
8748 return nativeResponseValue;
8750 // bool CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
8752 export function CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
8753 if(!isWasmInitialized) {
8754 throw new Error("initializeWasm() must be awaited first!");
8756 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o);
8757 return nativeResponseValue;
8759 // void CResult_HolderCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res);
8761 export function CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
8762 if(!isWasmInitialized) {
8763 throw new Error("initializeWasm() must be awaited first!");
8765 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res);
8766 // debug statements here
8768 // uint64_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
8770 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8771 if(!isWasmInitialized) {
8772 throw new Error("initializeWasm() must be awaited first!");
8774 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
8775 return nativeResponseValue;
8777 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
8779 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
8780 if(!isWasmInitialized) {
8781 throw new Error("initializeWasm() must be awaited first!");
8783 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig);
8784 return nativeResponseValue;
8786 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(struct LDKBuiltCommitmentTransaction o);
8788 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
8789 if(!isWasmInitialized) {
8790 throw new Error("initializeWasm() must be awaited first!");
8792 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o);
8793 return nativeResponseValue;
8795 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
8797 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
8798 if(!isWasmInitialized) {
8799 throw new Error("initializeWasm() must be awaited first!");
8801 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e);
8802 return nativeResponseValue;
8804 // bool CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
8806 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
8807 if(!isWasmInitialized) {
8808 throw new Error("initializeWasm() must be awaited first!");
8810 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o);
8811 return nativeResponseValue;
8813 // void CResult_BuiltCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res);
8815 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
8816 if(!isWasmInitialized) {
8817 throw new Error("initializeWasm() must be awaited first!");
8819 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res);
8820 // debug statements here
8822 // uint64_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
8824 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8825 if(!isWasmInitialized) {
8826 throw new Error("initializeWasm() must be awaited first!");
8828 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
8829 return nativeResponseValue;
8831 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
8833 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
8834 if(!isWasmInitialized) {
8835 throw new Error("initializeWasm() must be awaited first!");
8837 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig);
8838 return nativeResponseValue;
8840 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_ok(struct LDKTrustedClosingTransaction o);
8842 export function CResult_TrustedClosingTransactionNoneZ_ok(o: bigint): bigint {
8843 if(!isWasmInitialized) {
8844 throw new Error("initializeWasm() must be awaited first!");
8846 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_ok(o);
8847 return nativeResponseValue;
8849 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_err(void);
8851 export function CResult_TrustedClosingTransactionNoneZ_err(): bigint {
8852 if(!isWasmInitialized) {
8853 throw new Error("initializeWasm() must be awaited first!");
8855 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_err();
8856 return nativeResponseValue;
8858 // bool CResult_TrustedClosingTransactionNoneZ_is_ok(const struct LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR o);
8860 export function CResult_TrustedClosingTransactionNoneZ_is_ok(o: bigint): boolean {
8861 if(!isWasmInitialized) {
8862 throw new Error("initializeWasm() must be awaited first!");
8864 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_is_ok(o);
8865 return nativeResponseValue;
8867 // void CResult_TrustedClosingTransactionNoneZ_free(struct LDKCResult_TrustedClosingTransactionNoneZ _res);
8869 export function CResult_TrustedClosingTransactionNoneZ_free(_res: bigint): void {
8870 if(!isWasmInitialized) {
8871 throw new Error("initializeWasm() must be awaited first!");
8873 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_free(_res);
8874 // debug statements here
8876 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_ok(struct LDKCommitmentTransaction o);
8878 export function CResult_CommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
8879 if(!isWasmInitialized) {
8880 throw new Error("initializeWasm() must be awaited first!");
8882 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_ok(o);
8883 return nativeResponseValue;
8885 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
8887 export function CResult_CommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
8888 if(!isWasmInitialized) {
8889 throw new Error("initializeWasm() must be awaited first!");
8891 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_err(e);
8892 return nativeResponseValue;
8894 // bool CResult_CommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
8896 export function CResult_CommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
8897 if(!isWasmInitialized) {
8898 throw new Error("initializeWasm() must be awaited first!");
8900 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(o);
8901 return nativeResponseValue;
8903 // void CResult_CommitmentTransactionDecodeErrorZ_free(struct LDKCResult_CommitmentTransactionDecodeErrorZ _res);
8905 export function CResult_CommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
8906 if(!isWasmInitialized) {
8907 throw new Error("initializeWasm() must be awaited first!");
8909 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_free(_res);
8910 // debug statements here
8912 // uint64_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
8914 export function CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8915 if(!isWasmInitialized) {
8916 throw new Error("initializeWasm() must be awaited first!");
8918 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg);
8919 return nativeResponseValue;
8921 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
8923 export function CResult_CommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
8924 if(!isWasmInitialized) {
8925 throw new Error("initializeWasm() must be awaited first!");
8927 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone(orig);
8928 return nativeResponseValue;
8930 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_ok(struct LDKTrustedCommitmentTransaction o);
8932 export function CResult_TrustedCommitmentTransactionNoneZ_ok(o: bigint): bigint {
8933 if(!isWasmInitialized) {
8934 throw new Error("initializeWasm() must be awaited first!");
8936 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_ok(o);
8937 return nativeResponseValue;
8939 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_err(void);
8941 export function CResult_TrustedCommitmentTransactionNoneZ_err(): bigint {
8942 if(!isWasmInitialized) {
8943 throw new Error("initializeWasm() must be awaited first!");
8945 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_err();
8946 return nativeResponseValue;
8948 // bool CResult_TrustedCommitmentTransactionNoneZ_is_ok(const struct LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR o);
8950 export function CResult_TrustedCommitmentTransactionNoneZ_is_ok(o: bigint): boolean {
8951 if(!isWasmInitialized) {
8952 throw new Error("initializeWasm() must be awaited first!");
8954 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(o);
8955 return nativeResponseValue;
8957 // void CResult_TrustedCommitmentTransactionNoneZ_free(struct LDKCResult_TrustedCommitmentTransactionNoneZ _res);
8959 export function CResult_TrustedCommitmentTransactionNoneZ_free(_res: bigint): void {
8960 if(!isWasmInitialized) {
8961 throw new Error("initializeWasm() must be awaited first!");
8963 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_free(_res);
8964 // debug statements here
8966 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_ok(struct LDKCVec_SignatureZ o);
8968 export function CResult_CVec_SignatureZNoneZ_ok(o: number): bigint {
8969 if(!isWasmInitialized) {
8970 throw new Error("initializeWasm() must be awaited first!");
8972 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_ok(o);
8973 return nativeResponseValue;
8975 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_err(void);
8977 export function CResult_CVec_SignatureZNoneZ_err(): bigint {
8978 if(!isWasmInitialized) {
8979 throw new Error("initializeWasm() must be awaited first!");
8981 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_err();
8982 return nativeResponseValue;
8984 // bool CResult_CVec_SignatureZNoneZ_is_ok(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR o);
8986 export function CResult_CVec_SignatureZNoneZ_is_ok(o: bigint): boolean {
8987 if(!isWasmInitialized) {
8988 throw new Error("initializeWasm() must be awaited first!");
8990 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_is_ok(o);
8991 return nativeResponseValue;
8993 // void CResult_CVec_SignatureZNoneZ_free(struct LDKCResult_CVec_SignatureZNoneZ _res);
8995 export function CResult_CVec_SignatureZNoneZ_free(_res: bigint): void {
8996 if(!isWasmInitialized) {
8997 throw new Error("initializeWasm() must be awaited first!");
8999 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_free(_res);
9000 // debug statements here
9002 // uint64_t CResult_CVec_SignatureZNoneZ_clone_ptr(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR arg);
9004 export function CResult_CVec_SignatureZNoneZ_clone_ptr(arg: bigint): bigint {
9005 if(!isWasmInitialized) {
9006 throw new Error("initializeWasm() must be awaited first!");
9008 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone_ptr(arg);
9009 return nativeResponseValue;
9011 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_clone(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR orig);
9013 export function CResult_CVec_SignatureZNoneZ_clone(orig: bigint): bigint {
9014 if(!isWasmInitialized) {
9015 throw new Error("initializeWasm() must be awaited first!");
9017 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone(orig);
9018 return nativeResponseValue;
9020 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_ok(struct LDKShutdownScript o);
9022 export function CResult_ShutdownScriptDecodeErrorZ_ok(o: bigint): bigint {
9023 if(!isWasmInitialized) {
9024 throw new Error("initializeWasm() must be awaited first!");
9026 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_ok(o);
9027 return nativeResponseValue;
9029 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_err(struct LDKDecodeError e);
9031 export function CResult_ShutdownScriptDecodeErrorZ_err(e: bigint): bigint {
9032 if(!isWasmInitialized) {
9033 throw new Error("initializeWasm() must be awaited first!");
9035 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_err(e);
9036 return nativeResponseValue;
9038 // bool CResult_ShutdownScriptDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR o);
9040 export function CResult_ShutdownScriptDecodeErrorZ_is_ok(o: bigint): boolean {
9041 if(!isWasmInitialized) {
9042 throw new Error("initializeWasm() must be awaited first!");
9044 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(o);
9045 return nativeResponseValue;
9047 // void CResult_ShutdownScriptDecodeErrorZ_free(struct LDKCResult_ShutdownScriptDecodeErrorZ _res);
9049 export function CResult_ShutdownScriptDecodeErrorZ_free(_res: bigint): void {
9050 if(!isWasmInitialized) {
9051 throw new Error("initializeWasm() must be awaited first!");
9053 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_free(_res);
9054 // debug statements here
9056 // uint64_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg);
9058 export function CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9059 if(!isWasmInitialized) {
9060 throw new Error("initializeWasm() must be awaited first!");
9062 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg);
9063 return nativeResponseValue;
9065 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_clone(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR orig);
9067 export function CResult_ShutdownScriptDecodeErrorZ_clone(orig: bigint): bigint {
9068 if(!isWasmInitialized) {
9069 throw new Error("initializeWasm() must be awaited first!");
9071 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone(orig);
9072 return nativeResponseValue;
9074 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_ok(struct LDKShutdownScript o);
9076 export function CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o: bigint): bigint {
9077 if(!isWasmInitialized) {
9078 throw new Error("initializeWasm() must be awaited first!");
9080 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o);
9081 return nativeResponseValue;
9083 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_err(struct LDKInvalidShutdownScript e);
9085 export function CResult_ShutdownScriptInvalidShutdownScriptZ_err(e: bigint): bigint {
9086 if(!isWasmInitialized) {
9087 throw new Error("initializeWasm() must be awaited first!");
9089 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err(e);
9090 return nativeResponseValue;
9092 // bool CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR o);
9094 export function CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o: bigint): boolean {
9095 if(!isWasmInitialized) {
9096 throw new Error("initializeWasm() must be awaited first!");
9098 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o);
9099 return nativeResponseValue;
9101 // void CResult_ShutdownScriptInvalidShutdownScriptZ_free(struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res);
9103 export function CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res: bigint): void {
9104 if(!isWasmInitialized) {
9105 throw new Error("initializeWasm() must be awaited first!");
9107 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res);
9108 // debug statements here
9110 // uint64_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg);
9112 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg: bigint): bigint {
9113 if(!isWasmInitialized) {
9114 throw new Error("initializeWasm() must be awaited first!");
9116 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg);
9117 return nativeResponseValue;
9119 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_clone(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR orig);
9121 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig: bigint): bigint {
9122 if(!isWasmInitialized) {
9123 throw new Error("initializeWasm() must be awaited first!");
9125 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig);
9126 return nativeResponseValue;
9128 // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
9130 export function CVec_PublicKeyZ_free(_res: number): void {
9131 if(!isWasmInitialized) {
9132 throw new Error("initializeWasm() must be awaited first!");
9134 const nativeResponseValue = wasm.TS_CVec_PublicKeyZ_free(_res);
9135 // debug statements here
9137 // struct LDKCResult_BlindedPathNoneZ CResult_BlindedPathNoneZ_ok(struct LDKBlindedPath o);
9139 export function CResult_BlindedPathNoneZ_ok(o: bigint): bigint {
9140 if(!isWasmInitialized) {
9141 throw new Error("initializeWasm() must be awaited first!");
9143 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_ok(o);
9144 return nativeResponseValue;
9146 // struct LDKCResult_BlindedPathNoneZ CResult_BlindedPathNoneZ_err(void);
9148 export function CResult_BlindedPathNoneZ_err(): bigint {
9149 if(!isWasmInitialized) {
9150 throw new Error("initializeWasm() must be awaited first!");
9152 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_err();
9153 return nativeResponseValue;
9155 // bool CResult_BlindedPathNoneZ_is_ok(const struct LDKCResult_BlindedPathNoneZ *NONNULL_PTR o);
9157 export function CResult_BlindedPathNoneZ_is_ok(o: bigint): boolean {
9158 if(!isWasmInitialized) {
9159 throw new Error("initializeWasm() must be awaited first!");
9161 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_is_ok(o);
9162 return nativeResponseValue;
9164 // void CResult_BlindedPathNoneZ_free(struct LDKCResult_BlindedPathNoneZ _res);
9166 export function CResult_BlindedPathNoneZ_free(_res: bigint): void {
9167 if(!isWasmInitialized) {
9168 throw new Error("initializeWasm() must be awaited first!");
9170 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_free(_res);
9171 // debug statements here
9173 // uint64_t CResult_BlindedPathNoneZ_clone_ptr(LDKCResult_BlindedPathNoneZ *NONNULL_PTR arg);
9175 export function CResult_BlindedPathNoneZ_clone_ptr(arg: bigint): bigint {
9176 if(!isWasmInitialized) {
9177 throw new Error("initializeWasm() must be awaited first!");
9179 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_clone_ptr(arg);
9180 return nativeResponseValue;
9182 // struct LDKCResult_BlindedPathNoneZ CResult_BlindedPathNoneZ_clone(const struct LDKCResult_BlindedPathNoneZ *NONNULL_PTR orig);
9184 export function CResult_BlindedPathNoneZ_clone(orig: bigint): bigint {
9185 if(!isWasmInitialized) {
9186 throw new Error("initializeWasm() must be awaited first!");
9188 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_clone(orig);
9189 return nativeResponseValue;
9191 // struct LDKCResult_BlindedPathDecodeErrorZ CResult_BlindedPathDecodeErrorZ_ok(struct LDKBlindedPath o);
9193 export function CResult_BlindedPathDecodeErrorZ_ok(o: bigint): bigint {
9194 if(!isWasmInitialized) {
9195 throw new Error("initializeWasm() must be awaited first!");
9197 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_ok(o);
9198 return nativeResponseValue;
9200 // struct LDKCResult_BlindedPathDecodeErrorZ CResult_BlindedPathDecodeErrorZ_err(struct LDKDecodeError e);
9202 export function CResult_BlindedPathDecodeErrorZ_err(e: bigint): bigint {
9203 if(!isWasmInitialized) {
9204 throw new Error("initializeWasm() must be awaited first!");
9206 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_err(e);
9207 return nativeResponseValue;
9209 // bool CResult_BlindedPathDecodeErrorZ_is_ok(const struct LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR o);
9211 export function CResult_BlindedPathDecodeErrorZ_is_ok(o: bigint): boolean {
9212 if(!isWasmInitialized) {
9213 throw new Error("initializeWasm() must be awaited first!");
9215 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_is_ok(o);
9216 return nativeResponseValue;
9218 // void CResult_BlindedPathDecodeErrorZ_free(struct LDKCResult_BlindedPathDecodeErrorZ _res);
9220 export function CResult_BlindedPathDecodeErrorZ_free(_res: bigint): void {
9221 if(!isWasmInitialized) {
9222 throw new Error("initializeWasm() must be awaited first!");
9224 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_free(_res);
9225 // debug statements here
9227 // uint64_t CResult_BlindedPathDecodeErrorZ_clone_ptr(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR arg);
9229 export function CResult_BlindedPathDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9230 if(!isWasmInitialized) {
9231 throw new Error("initializeWasm() must be awaited first!");
9233 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_clone_ptr(arg);
9234 return nativeResponseValue;
9236 // struct LDKCResult_BlindedPathDecodeErrorZ CResult_BlindedPathDecodeErrorZ_clone(const struct LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR orig);
9238 export function CResult_BlindedPathDecodeErrorZ_clone(orig: bigint): bigint {
9239 if(!isWasmInitialized) {
9240 throw new Error("initializeWasm() must be awaited first!");
9242 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_clone(orig);
9243 return nativeResponseValue;
9245 // struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_ok(struct LDKBlindedHop o);
9247 export function CResult_BlindedHopDecodeErrorZ_ok(o: bigint): bigint {
9248 if(!isWasmInitialized) {
9249 throw new Error("initializeWasm() must be awaited first!");
9251 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_ok(o);
9252 return nativeResponseValue;
9254 // struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_err(struct LDKDecodeError e);
9256 export function CResult_BlindedHopDecodeErrorZ_err(e: bigint): bigint {
9257 if(!isWasmInitialized) {
9258 throw new Error("initializeWasm() must be awaited first!");
9260 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_err(e);
9261 return nativeResponseValue;
9263 // bool CResult_BlindedHopDecodeErrorZ_is_ok(const struct LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR o);
9265 export function CResult_BlindedHopDecodeErrorZ_is_ok(o: bigint): boolean {
9266 if(!isWasmInitialized) {
9267 throw new Error("initializeWasm() must be awaited first!");
9269 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_is_ok(o);
9270 return nativeResponseValue;
9272 // void CResult_BlindedHopDecodeErrorZ_free(struct LDKCResult_BlindedHopDecodeErrorZ _res);
9274 export function CResult_BlindedHopDecodeErrorZ_free(_res: bigint): void {
9275 if(!isWasmInitialized) {
9276 throw new Error("initializeWasm() must be awaited first!");
9278 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_free(_res);
9279 // debug statements here
9281 // uint64_t CResult_BlindedHopDecodeErrorZ_clone_ptr(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR arg);
9283 export function CResult_BlindedHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9284 if(!isWasmInitialized) {
9285 throw new Error("initializeWasm() must be awaited first!");
9287 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_clone_ptr(arg);
9288 return nativeResponseValue;
9290 // struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_clone(const struct LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR orig);
9292 export function CResult_BlindedHopDecodeErrorZ_clone(orig: bigint): bigint {
9293 if(!isWasmInitialized) {
9294 throw new Error("initializeWasm() must be awaited first!");
9296 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_clone(orig);
9297 return nativeResponseValue;
9299 // void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
9301 export function CVec_ChannelDetailsZ_free(_res: number): void {
9302 if(!isWasmInitialized) {
9303 throw new Error("initializeWasm() must be awaited first!");
9305 const nativeResponseValue = wasm.TS_CVec_ChannelDetailsZ_free(_res);
9306 // debug statements here
9308 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
9310 export function CResult_RouteLightningErrorZ_ok(o: bigint): bigint {
9311 if(!isWasmInitialized) {
9312 throw new Error("initializeWasm() must be awaited first!");
9314 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_ok(o);
9315 return nativeResponseValue;
9317 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
9319 export function CResult_RouteLightningErrorZ_err(e: bigint): bigint {
9320 if(!isWasmInitialized) {
9321 throw new Error("initializeWasm() must be awaited first!");
9323 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_err(e);
9324 return nativeResponseValue;
9326 // bool CResult_RouteLightningErrorZ_is_ok(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR o);
9328 export function CResult_RouteLightningErrorZ_is_ok(o: bigint): boolean {
9329 if(!isWasmInitialized) {
9330 throw new Error("initializeWasm() must be awaited first!");
9332 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_is_ok(o);
9333 return nativeResponseValue;
9335 // void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
9337 export function CResult_RouteLightningErrorZ_free(_res: bigint): void {
9338 if(!isWasmInitialized) {
9339 throw new Error("initializeWasm() must be awaited first!");
9341 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_free(_res);
9342 // debug statements here
9344 // uint64_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg);
9346 export function CResult_RouteLightningErrorZ_clone_ptr(arg: bigint): bigint {
9347 if(!isWasmInitialized) {
9348 throw new Error("initializeWasm() must be awaited first!");
9350 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone_ptr(arg);
9351 return nativeResponseValue;
9353 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
9355 export function CResult_RouteLightningErrorZ_clone(orig: bigint): bigint {
9356 if(!isWasmInitialized) {
9357 throw new Error("initializeWasm() must be awaited first!");
9359 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone(orig);
9360 return nativeResponseValue;
9362 // void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
9364 export function CVec_RouteHopZ_free(_res: number): void {
9365 if(!isWasmInitialized) {
9366 throw new Error("initializeWasm() must be awaited first!");
9368 const nativeResponseValue = wasm.TS_CVec_RouteHopZ_free(_res);
9369 // debug statements here
9371 // struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
9373 export function COption_u64Z_some(o: bigint): bigint {
9374 if(!isWasmInitialized) {
9375 throw new Error("initializeWasm() must be awaited first!");
9377 const nativeResponseValue = wasm.TS_COption_u64Z_some(o);
9378 return nativeResponseValue;
9380 // struct LDKCOption_u64Z COption_u64Z_none(void);
9382 export function COption_u64Z_none(): bigint {
9383 if(!isWasmInitialized) {
9384 throw new Error("initializeWasm() must be awaited first!");
9386 const nativeResponseValue = wasm.TS_COption_u64Z_none();
9387 return nativeResponseValue;
9389 // void COption_u64Z_free(struct LDKCOption_u64Z _res);
9391 export function COption_u64Z_free(_res: bigint): void {
9392 if(!isWasmInitialized) {
9393 throw new Error("initializeWasm() must be awaited first!");
9395 const nativeResponseValue = wasm.TS_COption_u64Z_free(_res);
9396 // debug statements here
9398 // uint64_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg);
9400 export function COption_u64Z_clone_ptr(arg: bigint): bigint {
9401 if(!isWasmInitialized) {
9402 throw new Error("initializeWasm() must be awaited first!");
9404 const nativeResponseValue = wasm.TS_COption_u64Z_clone_ptr(arg);
9405 return nativeResponseValue;
9407 // struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
9409 export function COption_u64Z_clone(orig: bigint): bigint {
9410 if(!isWasmInitialized) {
9411 throw new Error("initializeWasm() must be awaited first!");
9413 const nativeResponseValue = wasm.TS_COption_u64Z_clone(orig);
9414 return nativeResponseValue;
9416 // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_ok(struct LDKInFlightHtlcs o);
9418 export function CResult_InFlightHtlcsDecodeErrorZ_ok(o: bigint): bigint {
9419 if(!isWasmInitialized) {
9420 throw new Error("initializeWasm() must be awaited first!");
9422 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_ok(o);
9423 return nativeResponseValue;
9425 // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_err(struct LDKDecodeError e);
9427 export function CResult_InFlightHtlcsDecodeErrorZ_err(e: bigint): bigint {
9428 if(!isWasmInitialized) {
9429 throw new Error("initializeWasm() must be awaited first!");
9431 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_err(e);
9432 return nativeResponseValue;
9434 // bool CResult_InFlightHtlcsDecodeErrorZ_is_ok(const struct LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR o);
9436 export function CResult_InFlightHtlcsDecodeErrorZ_is_ok(o: bigint): boolean {
9437 if(!isWasmInitialized) {
9438 throw new Error("initializeWasm() must be awaited first!");
9440 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_is_ok(o);
9441 return nativeResponseValue;
9443 // void CResult_InFlightHtlcsDecodeErrorZ_free(struct LDKCResult_InFlightHtlcsDecodeErrorZ _res);
9445 export function CResult_InFlightHtlcsDecodeErrorZ_free(_res: bigint): void {
9446 if(!isWasmInitialized) {
9447 throw new Error("initializeWasm() must be awaited first!");
9449 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_free(_res);
9450 // debug statements here
9452 // uint64_t CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR arg);
9454 export function CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9455 if(!isWasmInitialized) {
9456 throw new Error("initializeWasm() must be awaited first!");
9458 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(arg);
9459 return nativeResponseValue;
9461 // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_clone(const struct LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR orig);
9463 export function CResult_InFlightHtlcsDecodeErrorZ_clone(orig: bigint): bigint {
9464 if(!isWasmInitialized) {
9465 throw new Error("initializeWasm() must be awaited first!");
9467 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_clone(orig);
9468 return nativeResponseValue;
9470 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_ok(struct LDKRouteHop o);
9472 export function CResult_RouteHopDecodeErrorZ_ok(o: bigint): bigint {
9473 if(!isWasmInitialized) {
9474 throw new Error("initializeWasm() must be awaited first!");
9476 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_ok(o);
9477 return nativeResponseValue;
9479 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_err(struct LDKDecodeError e);
9481 export function CResult_RouteHopDecodeErrorZ_err(e: bigint): bigint {
9482 if(!isWasmInitialized) {
9483 throw new Error("initializeWasm() must be awaited first!");
9485 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_err(e);
9486 return nativeResponseValue;
9488 // bool CResult_RouteHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR o);
9490 export function CResult_RouteHopDecodeErrorZ_is_ok(o: bigint): boolean {
9491 if(!isWasmInitialized) {
9492 throw new Error("initializeWasm() must be awaited first!");
9494 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_is_ok(o);
9495 return nativeResponseValue;
9497 // void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
9499 export function CResult_RouteHopDecodeErrorZ_free(_res: bigint): void {
9500 if(!isWasmInitialized) {
9501 throw new Error("initializeWasm() must be awaited first!");
9503 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_free(_res);
9504 // debug statements here
9506 // uint64_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg);
9508 export function CResult_RouteHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9509 if(!isWasmInitialized) {
9510 throw new Error("initializeWasm() must be awaited first!");
9512 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone_ptr(arg);
9513 return nativeResponseValue;
9515 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
9517 export function CResult_RouteHopDecodeErrorZ_clone(orig: bigint): bigint {
9518 if(!isWasmInitialized) {
9519 throw new Error("initializeWasm() must be awaited first!");
9521 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone(orig);
9522 return nativeResponseValue;
9524 // void CVec_CVec_RouteHopZZ_free(struct LDKCVec_CVec_RouteHopZZ _res);
9526 export function CVec_CVec_RouteHopZZ_free(_res: number): void {
9527 if(!isWasmInitialized) {
9528 throw new Error("initializeWasm() must be awaited first!");
9530 const nativeResponseValue = wasm.TS_CVec_CVec_RouteHopZZ_free(_res);
9531 // debug statements here
9533 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
9535 export function CResult_RouteDecodeErrorZ_ok(o: bigint): bigint {
9536 if(!isWasmInitialized) {
9537 throw new Error("initializeWasm() must be awaited first!");
9539 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_ok(o);
9540 return nativeResponseValue;
9542 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
9544 export function CResult_RouteDecodeErrorZ_err(e: bigint): bigint {
9545 if(!isWasmInitialized) {
9546 throw new Error("initializeWasm() must be awaited first!");
9548 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_err(e);
9549 return nativeResponseValue;
9551 // bool CResult_RouteDecodeErrorZ_is_ok(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR o);
9553 export function CResult_RouteDecodeErrorZ_is_ok(o: bigint): boolean {
9554 if(!isWasmInitialized) {
9555 throw new Error("initializeWasm() must be awaited first!");
9557 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_is_ok(o);
9558 return nativeResponseValue;
9560 // void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
9562 export function CResult_RouteDecodeErrorZ_free(_res: bigint): void {
9563 if(!isWasmInitialized) {
9564 throw new Error("initializeWasm() must be awaited first!");
9566 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_free(_res);
9567 // debug statements here
9569 // uint64_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg);
9571 export function CResult_RouteDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9572 if(!isWasmInitialized) {
9573 throw new Error("initializeWasm() must be awaited first!");
9575 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone_ptr(arg);
9576 return nativeResponseValue;
9578 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
9580 export function CResult_RouteDecodeErrorZ_clone(orig: bigint): bigint {
9581 if(!isWasmInitialized) {
9582 throw new Error("initializeWasm() must be awaited first!");
9584 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone(orig);
9585 return nativeResponseValue;
9587 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_ok(struct LDKRouteParameters o);
9589 export function CResult_RouteParametersDecodeErrorZ_ok(o: bigint): bigint {
9590 if(!isWasmInitialized) {
9591 throw new Error("initializeWasm() must be awaited first!");
9593 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_ok(o);
9594 return nativeResponseValue;
9596 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_err(struct LDKDecodeError e);
9598 export function CResult_RouteParametersDecodeErrorZ_err(e: bigint): bigint {
9599 if(!isWasmInitialized) {
9600 throw new Error("initializeWasm() must be awaited first!");
9602 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_err(e);
9603 return nativeResponseValue;
9605 // bool CResult_RouteParametersDecodeErrorZ_is_ok(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR o);
9607 export function CResult_RouteParametersDecodeErrorZ_is_ok(o: bigint): boolean {
9608 if(!isWasmInitialized) {
9609 throw new Error("initializeWasm() must be awaited first!");
9611 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_is_ok(o);
9612 return nativeResponseValue;
9614 // void CResult_RouteParametersDecodeErrorZ_free(struct LDKCResult_RouteParametersDecodeErrorZ _res);
9616 export function CResult_RouteParametersDecodeErrorZ_free(_res: bigint): void {
9617 if(!isWasmInitialized) {
9618 throw new Error("initializeWasm() must be awaited first!");
9620 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_free(_res);
9621 // debug statements here
9623 // uint64_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg);
9625 export function CResult_RouteParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9626 if(!isWasmInitialized) {
9627 throw new Error("initializeWasm() must be awaited first!");
9629 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(arg);
9630 return nativeResponseValue;
9632 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_clone(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR orig);
9634 export function CResult_RouteParametersDecodeErrorZ_clone(orig: bigint): bigint {
9635 if(!isWasmInitialized) {
9636 throw new Error("initializeWasm() must be awaited first!");
9638 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone(orig);
9639 return nativeResponseValue;
9641 // void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
9643 export function CVec_RouteHintZ_free(_res: number): void {
9644 if(!isWasmInitialized) {
9645 throw new Error("initializeWasm() must be awaited first!");
9647 const nativeResponseValue = wasm.TS_CVec_RouteHintZ_free(_res);
9648 // debug statements here
9650 // void CVec_u64Z_free(struct LDKCVec_u64Z _res);
9652 export function CVec_u64Z_free(_res: number): void {
9653 if(!isWasmInitialized) {
9654 throw new Error("initializeWasm() must be awaited first!");
9656 const nativeResponseValue = wasm.TS_CVec_u64Z_free(_res);
9657 // debug statements here
9659 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_ok(struct LDKPaymentParameters o);
9661 export function CResult_PaymentParametersDecodeErrorZ_ok(o: bigint): bigint {
9662 if(!isWasmInitialized) {
9663 throw new Error("initializeWasm() must be awaited first!");
9665 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_ok(o);
9666 return nativeResponseValue;
9668 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_err(struct LDKDecodeError e);
9670 export function CResult_PaymentParametersDecodeErrorZ_err(e: bigint): bigint {
9671 if(!isWasmInitialized) {
9672 throw new Error("initializeWasm() must be awaited first!");
9674 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_err(e);
9675 return nativeResponseValue;
9677 // bool CResult_PaymentParametersDecodeErrorZ_is_ok(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR o);
9679 export function CResult_PaymentParametersDecodeErrorZ_is_ok(o: bigint): boolean {
9680 if(!isWasmInitialized) {
9681 throw new Error("initializeWasm() must be awaited first!");
9683 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_is_ok(o);
9684 return nativeResponseValue;
9686 // void CResult_PaymentParametersDecodeErrorZ_free(struct LDKCResult_PaymentParametersDecodeErrorZ _res);
9688 export function CResult_PaymentParametersDecodeErrorZ_free(_res: bigint): void {
9689 if(!isWasmInitialized) {
9690 throw new Error("initializeWasm() must be awaited first!");
9692 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_free(_res);
9693 // debug statements here
9695 // uint64_t CResult_PaymentParametersDecodeErrorZ_clone_ptr(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR arg);
9697 export function CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9698 if(!isWasmInitialized) {
9699 throw new Error("initializeWasm() must be awaited first!");
9701 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg);
9702 return nativeResponseValue;
9704 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_clone(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR orig);
9706 export function CResult_PaymentParametersDecodeErrorZ_clone(orig: bigint): bigint {
9707 if(!isWasmInitialized) {
9708 throw new Error("initializeWasm() must be awaited first!");
9710 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone(orig);
9711 return nativeResponseValue;
9713 // void CVec_RouteHintHopZ_free(struct LDKCVec_RouteHintHopZ _res);
9715 export function CVec_RouteHintHopZ_free(_res: number): void {
9716 if(!isWasmInitialized) {
9717 throw new Error("initializeWasm() must be awaited first!");
9719 const nativeResponseValue = wasm.TS_CVec_RouteHintHopZ_free(_res);
9720 // debug statements here
9722 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_ok(struct LDKRouteHint o);
9724 export function CResult_RouteHintDecodeErrorZ_ok(o: bigint): bigint {
9725 if(!isWasmInitialized) {
9726 throw new Error("initializeWasm() must be awaited first!");
9728 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_ok(o);
9729 return nativeResponseValue;
9731 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_err(struct LDKDecodeError e);
9733 export function CResult_RouteHintDecodeErrorZ_err(e: bigint): bigint {
9734 if(!isWasmInitialized) {
9735 throw new Error("initializeWasm() must be awaited first!");
9737 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_err(e);
9738 return nativeResponseValue;
9740 // bool CResult_RouteHintDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR o);
9742 export function CResult_RouteHintDecodeErrorZ_is_ok(o: bigint): boolean {
9743 if(!isWasmInitialized) {
9744 throw new Error("initializeWasm() must be awaited first!");
9746 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_is_ok(o);
9747 return nativeResponseValue;
9749 // void CResult_RouteHintDecodeErrorZ_free(struct LDKCResult_RouteHintDecodeErrorZ _res);
9751 export function CResult_RouteHintDecodeErrorZ_free(_res: bigint): void {
9752 if(!isWasmInitialized) {
9753 throw new Error("initializeWasm() must be awaited first!");
9755 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_free(_res);
9756 // debug statements here
9758 // uint64_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg);
9760 export function CResult_RouteHintDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9761 if(!isWasmInitialized) {
9762 throw new Error("initializeWasm() must be awaited first!");
9764 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone_ptr(arg);
9765 return nativeResponseValue;
9767 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_clone(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR orig);
9769 export function CResult_RouteHintDecodeErrorZ_clone(orig: bigint): bigint {
9770 if(!isWasmInitialized) {
9771 throw new Error("initializeWasm() must be awaited first!");
9773 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone(orig);
9774 return nativeResponseValue;
9776 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_ok(struct LDKRouteHintHop o);
9778 export function CResult_RouteHintHopDecodeErrorZ_ok(o: bigint): bigint {
9779 if(!isWasmInitialized) {
9780 throw new Error("initializeWasm() must be awaited first!");
9782 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_ok(o);
9783 return nativeResponseValue;
9785 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_err(struct LDKDecodeError e);
9787 export function CResult_RouteHintHopDecodeErrorZ_err(e: bigint): bigint {
9788 if(!isWasmInitialized) {
9789 throw new Error("initializeWasm() must be awaited first!");
9791 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_err(e);
9792 return nativeResponseValue;
9794 // bool CResult_RouteHintHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR o);
9796 export function CResult_RouteHintHopDecodeErrorZ_is_ok(o: bigint): boolean {
9797 if(!isWasmInitialized) {
9798 throw new Error("initializeWasm() must be awaited first!");
9800 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_is_ok(o);
9801 return nativeResponseValue;
9803 // void CResult_RouteHintHopDecodeErrorZ_free(struct LDKCResult_RouteHintHopDecodeErrorZ _res);
9805 export function CResult_RouteHintHopDecodeErrorZ_free(_res: bigint): void {
9806 if(!isWasmInitialized) {
9807 throw new Error("initializeWasm() must be awaited first!");
9809 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_free(_res);
9810 // debug statements here
9812 // uint64_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg);
9814 export function CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9815 if(!isWasmInitialized) {
9816 throw new Error("initializeWasm() must be awaited first!");
9818 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg);
9819 return nativeResponseValue;
9821 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_clone(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR orig);
9823 export function CResult_RouteHintHopDecodeErrorZ_clone(orig: bigint): bigint {
9824 if(!isWasmInitialized) {
9825 throw new Error("initializeWasm() must be awaited first!");
9827 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone(orig);
9828 return nativeResponseValue;
9830 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_ok(struct LDKPaymentPurpose o);
9832 export function CResult_PaymentPurposeDecodeErrorZ_ok(o: bigint): bigint {
9833 if(!isWasmInitialized) {
9834 throw new Error("initializeWasm() must be awaited first!");
9836 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_ok(o);
9837 return nativeResponseValue;
9839 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_err(struct LDKDecodeError e);
9841 export function CResult_PaymentPurposeDecodeErrorZ_err(e: bigint): bigint {
9842 if(!isWasmInitialized) {
9843 throw new Error("initializeWasm() must be awaited first!");
9845 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_err(e);
9846 return nativeResponseValue;
9848 // bool CResult_PaymentPurposeDecodeErrorZ_is_ok(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR o);
9850 export function CResult_PaymentPurposeDecodeErrorZ_is_ok(o: bigint): boolean {
9851 if(!isWasmInitialized) {
9852 throw new Error("initializeWasm() must be awaited first!");
9854 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_is_ok(o);
9855 return nativeResponseValue;
9857 // void CResult_PaymentPurposeDecodeErrorZ_free(struct LDKCResult_PaymentPurposeDecodeErrorZ _res);
9859 export function CResult_PaymentPurposeDecodeErrorZ_free(_res: bigint): void {
9860 if(!isWasmInitialized) {
9861 throw new Error("initializeWasm() must be awaited first!");
9863 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_free(_res);
9864 // debug statements here
9866 // uint64_t CResult_PaymentPurposeDecodeErrorZ_clone_ptr(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR arg);
9868 export function CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9869 if(!isWasmInitialized) {
9870 throw new Error("initializeWasm() must be awaited first!");
9872 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg);
9873 return nativeResponseValue;
9875 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_clone(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR orig);
9877 export function CResult_PaymentPurposeDecodeErrorZ_clone(orig: bigint): bigint {
9878 if(!isWasmInitialized) {
9879 throw new Error("initializeWasm() must be awaited first!");
9881 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone(orig);
9882 return nativeResponseValue;
9884 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_some(struct LDKNetworkUpdate o);
9886 export function COption_NetworkUpdateZ_some(o: bigint): bigint {
9887 if(!isWasmInitialized) {
9888 throw new Error("initializeWasm() must be awaited first!");
9890 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_some(o);
9891 return nativeResponseValue;
9893 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_none(void);
9895 export function COption_NetworkUpdateZ_none(): bigint {
9896 if(!isWasmInitialized) {
9897 throw new Error("initializeWasm() must be awaited first!");
9899 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_none();
9900 return nativeResponseValue;
9902 // void COption_NetworkUpdateZ_free(struct LDKCOption_NetworkUpdateZ _res);
9904 export function COption_NetworkUpdateZ_free(_res: bigint): void {
9905 if(!isWasmInitialized) {
9906 throw new Error("initializeWasm() must be awaited first!");
9908 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_free(_res);
9909 // debug statements here
9911 // uint64_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg);
9913 export function COption_NetworkUpdateZ_clone_ptr(arg: bigint): bigint {
9914 if(!isWasmInitialized) {
9915 throw new Error("initializeWasm() must be awaited first!");
9917 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone_ptr(arg);
9918 return nativeResponseValue;
9920 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_clone(const struct LDKCOption_NetworkUpdateZ *NONNULL_PTR orig);
9922 export function COption_NetworkUpdateZ_clone(orig: bigint): bigint {
9923 if(!isWasmInitialized) {
9924 throw new Error("initializeWasm() must be awaited first!");
9926 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone(orig);
9927 return nativeResponseValue;
9929 // struct LDKCOption_PathFailureZ COption_PathFailureZ_some(struct LDKPathFailure o);
9931 export function COption_PathFailureZ_some(o: bigint): bigint {
9932 if(!isWasmInitialized) {
9933 throw new Error("initializeWasm() must be awaited first!");
9935 const nativeResponseValue = wasm.TS_COption_PathFailureZ_some(o);
9936 return nativeResponseValue;
9938 // struct LDKCOption_PathFailureZ COption_PathFailureZ_none(void);
9940 export function COption_PathFailureZ_none(): bigint {
9941 if(!isWasmInitialized) {
9942 throw new Error("initializeWasm() must be awaited first!");
9944 const nativeResponseValue = wasm.TS_COption_PathFailureZ_none();
9945 return nativeResponseValue;
9947 // void COption_PathFailureZ_free(struct LDKCOption_PathFailureZ _res);
9949 export function COption_PathFailureZ_free(_res: bigint): void {
9950 if(!isWasmInitialized) {
9951 throw new Error("initializeWasm() must be awaited first!");
9953 const nativeResponseValue = wasm.TS_COption_PathFailureZ_free(_res);
9954 // debug statements here
9956 // uint64_t COption_PathFailureZ_clone_ptr(LDKCOption_PathFailureZ *NONNULL_PTR arg);
9958 export function COption_PathFailureZ_clone_ptr(arg: bigint): bigint {
9959 if(!isWasmInitialized) {
9960 throw new Error("initializeWasm() must be awaited first!");
9962 const nativeResponseValue = wasm.TS_COption_PathFailureZ_clone_ptr(arg);
9963 return nativeResponseValue;
9965 // struct LDKCOption_PathFailureZ COption_PathFailureZ_clone(const struct LDKCOption_PathFailureZ *NONNULL_PTR orig);
9967 export function COption_PathFailureZ_clone(orig: bigint): bigint {
9968 if(!isWasmInitialized) {
9969 throw new Error("initializeWasm() must be awaited first!");
9971 const nativeResponseValue = wasm.TS_COption_PathFailureZ_clone(orig);
9972 return nativeResponseValue;
9974 // struct LDKCResult_COption_PathFailureZDecodeErrorZ CResult_COption_PathFailureZDecodeErrorZ_ok(struct LDKCOption_PathFailureZ o);
9976 export function CResult_COption_PathFailureZDecodeErrorZ_ok(o: bigint): bigint {
9977 if(!isWasmInitialized) {
9978 throw new Error("initializeWasm() must be awaited first!");
9980 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_ok(o);
9981 return nativeResponseValue;
9983 // struct LDKCResult_COption_PathFailureZDecodeErrorZ CResult_COption_PathFailureZDecodeErrorZ_err(struct LDKDecodeError e);
9985 export function CResult_COption_PathFailureZDecodeErrorZ_err(e: bigint): bigint {
9986 if(!isWasmInitialized) {
9987 throw new Error("initializeWasm() must be awaited first!");
9989 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_err(e);
9990 return nativeResponseValue;
9992 // bool CResult_COption_PathFailureZDecodeErrorZ_is_ok(const struct LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR o);
9994 export function CResult_COption_PathFailureZDecodeErrorZ_is_ok(o: bigint): boolean {
9995 if(!isWasmInitialized) {
9996 throw new Error("initializeWasm() must be awaited first!");
9998 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_is_ok(o);
9999 return nativeResponseValue;
10001 // void CResult_COption_PathFailureZDecodeErrorZ_free(struct LDKCResult_COption_PathFailureZDecodeErrorZ _res);
10003 export function CResult_COption_PathFailureZDecodeErrorZ_free(_res: bigint): void {
10004 if(!isWasmInitialized) {
10005 throw new Error("initializeWasm() must be awaited first!");
10007 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_free(_res);
10008 // debug statements here
10010 // uint64_t CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR arg);
10012 export function CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10013 if(!isWasmInitialized) {
10014 throw new Error("initializeWasm() must be awaited first!");
10016 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(arg);
10017 return nativeResponseValue;
10019 // struct LDKCResult_COption_PathFailureZDecodeErrorZ CResult_COption_PathFailureZDecodeErrorZ_clone(const struct LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR orig);
10021 export function CResult_COption_PathFailureZDecodeErrorZ_clone(orig: bigint): bigint {
10022 if(!isWasmInitialized) {
10023 throw new Error("initializeWasm() must be awaited first!");
10025 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_clone(orig);
10026 return nativeResponseValue;
10028 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_some(struct LDKClosureReason o);
10030 export function COption_ClosureReasonZ_some(o: bigint): bigint {
10031 if(!isWasmInitialized) {
10032 throw new Error("initializeWasm() must be awaited first!");
10034 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_some(o);
10035 return nativeResponseValue;
10037 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_none(void);
10039 export function COption_ClosureReasonZ_none(): bigint {
10040 if(!isWasmInitialized) {
10041 throw new Error("initializeWasm() must be awaited first!");
10043 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_none();
10044 return nativeResponseValue;
10046 // void COption_ClosureReasonZ_free(struct LDKCOption_ClosureReasonZ _res);
10048 export function COption_ClosureReasonZ_free(_res: bigint): void {
10049 if(!isWasmInitialized) {
10050 throw new Error("initializeWasm() must be awaited first!");
10052 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_free(_res);
10053 // debug statements here
10055 // uint64_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg);
10057 export function COption_ClosureReasonZ_clone_ptr(arg: bigint): bigint {
10058 if(!isWasmInitialized) {
10059 throw new Error("initializeWasm() must be awaited first!");
10061 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone_ptr(arg);
10062 return nativeResponseValue;
10064 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_clone(const struct LDKCOption_ClosureReasonZ *NONNULL_PTR orig);
10066 export function COption_ClosureReasonZ_clone(orig: bigint): bigint {
10067 if(!isWasmInitialized) {
10068 throw new Error("initializeWasm() must be awaited first!");
10070 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone(orig);
10071 return nativeResponseValue;
10073 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_ok(struct LDKCOption_ClosureReasonZ o);
10075 export function CResult_COption_ClosureReasonZDecodeErrorZ_ok(o: bigint): bigint {
10076 if(!isWasmInitialized) {
10077 throw new Error("initializeWasm() must be awaited first!");
10079 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(o);
10080 return nativeResponseValue;
10082 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_err(struct LDKDecodeError e);
10084 export function CResult_COption_ClosureReasonZDecodeErrorZ_err(e: bigint): bigint {
10085 if(!isWasmInitialized) {
10086 throw new Error("initializeWasm() must be awaited first!");
10088 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(e);
10089 return nativeResponseValue;
10091 // bool CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR o);
10093 export function CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o: bigint): boolean {
10094 if(!isWasmInitialized) {
10095 throw new Error("initializeWasm() must be awaited first!");
10097 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o);
10098 return nativeResponseValue;
10100 // void CResult_COption_ClosureReasonZDecodeErrorZ_free(struct LDKCResult_COption_ClosureReasonZDecodeErrorZ _res);
10102 export function CResult_COption_ClosureReasonZDecodeErrorZ_free(_res: bigint): void {
10103 if(!isWasmInitialized) {
10104 throw new Error("initializeWasm() must be awaited first!");
10106 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(_res);
10107 // debug statements here
10109 // uint64_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg);
10111 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10112 if(!isWasmInitialized) {
10113 throw new Error("initializeWasm() must be awaited first!");
10115 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg);
10116 return nativeResponseValue;
10118 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_clone(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR orig);
10120 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig: bigint): bigint {
10121 if(!isWasmInitialized) {
10122 throw new Error("initializeWasm() must be awaited first!");
10124 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig);
10125 return nativeResponseValue;
10127 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_some(struct LDKHTLCDestination o);
10129 export function COption_HTLCDestinationZ_some(o: bigint): bigint {
10130 if(!isWasmInitialized) {
10131 throw new Error("initializeWasm() must be awaited first!");
10133 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_some(o);
10134 return nativeResponseValue;
10136 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_none(void);
10138 export function COption_HTLCDestinationZ_none(): bigint {
10139 if(!isWasmInitialized) {
10140 throw new Error("initializeWasm() must be awaited first!");
10142 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_none();
10143 return nativeResponseValue;
10145 // void COption_HTLCDestinationZ_free(struct LDKCOption_HTLCDestinationZ _res);
10147 export function COption_HTLCDestinationZ_free(_res: bigint): void {
10148 if(!isWasmInitialized) {
10149 throw new Error("initializeWasm() must be awaited first!");
10151 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_free(_res);
10152 // debug statements here
10154 // uint64_t COption_HTLCDestinationZ_clone_ptr(LDKCOption_HTLCDestinationZ *NONNULL_PTR arg);
10156 export function COption_HTLCDestinationZ_clone_ptr(arg: bigint): bigint {
10157 if(!isWasmInitialized) {
10158 throw new Error("initializeWasm() must be awaited first!");
10160 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone_ptr(arg);
10161 return nativeResponseValue;
10163 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_clone(const struct LDKCOption_HTLCDestinationZ *NONNULL_PTR orig);
10165 export function COption_HTLCDestinationZ_clone(orig: bigint): bigint {
10166 if(!isWasmInitialized) {
10167 throw new Error("initializeWasm() must be awaited first!");
10169 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone(orig);
10170 return nativeResponseValue;
10172 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_ok(struct LDKCOption_HTLCDestinationZ o);
10174 export function CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o: bigint): bigint {
10175 if(!isWasmInitialized) {
10176 throw new Error("initializeWasm() must be awaited first!");
10178 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o);
10179 return nativeResponseValue;
10181 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_err(struct LDKDecodeError e);
10183 export function CResult_COption_HTLCDestinationZDecodeErrorZ_err(e: bigint): bigint {
10184 if(!isWasmInitialized) {
10185 throw new Error("initializeWasm() must be awaited first!");
10187 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_err(e);
10188 return nativeResponseValue;
10190 // bool CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR o);
10192 export function CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o: bigint): boolean {
10193 if(!isWasmInitialized) {
10194 throw new Error("initializeWasm() must be awaited first!");
10196 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o);
10197 return nativeResponseValue;
10199 // void CResult_COption_HTLCDestinationZDecodeErrorZ_free(struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ _res);
10201 export function CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res: bigint): void {
10202 if(!isWasmInitialized) {
10203 throw new Error("initializeWasm() must be awaited first!");
10205 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res);
10206 // debug statements here
10208 // uint64_t CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR arg);
10210 export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10211 if(!isWasmInitialized) {
10212 throw new Error("initializeWasm() must be awaited first!");
10214 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg);
10215 return nativeResponseValue;
10217 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_clone(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR orig);
10219 export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig: bigint): bigint {
10220 if(!isWasmInitialized) {
10221 throw new Error("initializeWasm() must be awaited first!");
10223 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig);
10224 return nativeResponseValue;
10226 // struct LDKCOption_u128Z COption_u128Z_some(struct LDKU128 o);
10228 export function COption_u128Z_some(o: number): bigint {
10229 if(!isWasmInitialized) {
10230 throw new Error("initializeWasm() must be awaited first!");
10232 const nativeResponseValue = wasm.TS_COption_u128Z_some(o);
10233 return nativeResponseValue;
10235 // struct LDKCOption_u128Z COption_u128Z_none(void);
10237 export function COption_u128Z_none(): bigint {
10238 if(!isWasmInitialized) {
10239 throw new Error("initializeWasm() must be awaited first!");
10241 const nativeResponseValue = wasm.TS_COption_u128Z_none();
10242 return nativeResponseValue;
10244 // void COption_u128Z_free(struct LDKCOption_u128Z _res);
10246 export function COption_u128Z_free(_res: bigint): void {
10247 if(!isWasmInitialized) {
10248 throw new Error("initializeWasm() must be awaited first!");
10250 const nativeResponseValue = wasm.TS_COption_u128Z_free(_res);
10251 // debug statements here
10253 // uint64_t COption_u128Z_clone_ptr(LDKCOption_u128Z *NONNULL_PTR arg);
10255 export function COption_u128Z_clone_ptr(arg: bigint): bigint {
10256 if(!isWasmInitialized) {
10257 throw new Error("initializeWasm() must be awaited first!");
10259 const nativeResponseValue = wasm.TS_COption_u128Z_clone_ptr(arg);
10260 return nativeResponseValue;
10262 // struct LDKCOption_u128Z COption_u128Z_clone(const struct LDKCOption_u128Z *NONNULL_PTR orig);
10264 export function COption_u128Z_clone(orig: bigint): bigint {
10265 if(!isWasmInitialized) {
10266 throw new Error("initializeWasm() must be awaited first!");
10268 const nativeResponseValue = wasm.TS_COption_u128Z_clone(orig);
10269 return nativeResponseValue;
10271 // void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
10273 export function CVec_SpendableOutputDescriptorZ_free(_res: number): void {
10274 if(!isWasmInitialized) {
10275 throw new Error("initializeWasm() must be awaited first!");
10277 const nativeResponseValue = wasm.TS_CVec_SpendableOutputDescriptorZ_free(_res);
10278 // debug statements here
10280 // struct LDKCOption_EventZ COption_EventZ_some(struct LDKEvent o);
10282 export function COption_EventZ_some(o: bigint): bigint {
10283 if(!isWasmInitialized) {
10284 throw new Error("initializeWasm() must be awaited first!");
10286 const nativeResponseValue = wasm.TS_COption_EventZ_some(o);
10287 return nativeResponseValue;
10289 // struct LDKCOption_EventZ COption_EventZ_none(void);
10291 export function COption_EventZ_none(): bigint {
10292 if(!isWasmInitialized) {
10293 throw new Error("initializeWasm() must be awaited first!");
10295 const nativeResponseValue = wasm.TS_COption_EventZ_none();
10296 return nativeResponseValue;
10298 // void COption_EventZ_free(struct LDKCOption_EventZ _res);
10300 export function COption_EventZ_free(_res: bigint): void {
10301 if(!isWasmInitialized) {
10302 throw new Error("initializeWasm() must be awaited first!");
10304 const nativeResponseValue = wasm.TS_COption_EventZ_free(_res);
10305 // debug statements here
10307 // uint64_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg);
10309 export function COption_EventZ_clone_ptr(arg: bigint): bigint {
10310 if(!isWasmInitialized) {
10311 throw new Error("initializeWasm() must be awaited first!");
10313 const nativeResponseValue = wasm.TS_COption_EventZ_clone_ptr(arg);
10314 return nativeResponseValue;
10316 // struct LDKCOption_EventZ COption_EventZ_clone(const struct LDKCOption_EventZ *NONNULL_PTR orig);
10318 export function COption_EventZ_clone(orig: bigint): bigint {
10319 if(!isWasmInitialized) {
10320 throw new Error("initializeWasm() must be awaited first!");
10322 const nativeResponseValue = wasm.TS_COption_EventZ_clone(orig);
10323 return nativeResponseValue;
10325 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_ok(struct LDKCOption_EventZ o);
10327 export function CResult_COption_EventZDecodeErrorZ_ok(o: bigint): bigint {
10328 if(!isWasmInitialized) {
10329 throw new Error("initializeWasm() must be awaited first!");
10331 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_ok(o);
10332 return nativeResponseValue;
10334 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_err(struct LDKDecodeError e);
10336 export function CResult_COption_EventZDecodeErrorZ_err(e: bigint): bigint {
10337 if(!isWasmInitialized) {
10338 throw new Error("initializeWasm() must be awaited first!");
10340 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_err(e);
10341 return nativeResponseValue;
10343 // bool CResult_COption_EventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR o);
10345 export function CResult_COption_EventZDecodeErrorZ_is_ok(o: bigint): boolean {
10346 if(!isWasmInitialized) {
10347 throw new Error("initializeWasm() must be awaited first!");
10349 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_is_ok(o);
10350 return nativeResponseValue;
10352 // void CResult_COption_EventZDecodeErrorZ_free(struct LDKCResult_COption_EventZDecodeErrorZ _res);
10354 export function CResult_COption_EventZDecodeErrorZ_free(_res: bigint): void {
10355 if(!isWasmInitialized) {
10356 throw new Error("initializeWasm() must be awaited first!");
10358 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_free(_res);
10359 // debug statements here
10361 // uint64_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg);
10363 export function CResult_COption_EventZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10364 if(!isWasmInitialized) {
10365 throw new Error("initializeWasm() must be awaited first!");
10367 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(arg);
10368 return nativeResponseValue;
10370 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_clone(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR orig);
10372 export function CResult_COption_EventZDecodeErrorZ_clone(orig: bigint): bigint {
10373 if(!isWasmInitialized) {
10374 throw new Error("initializeWasm() must be awaited first!");
10376 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone(orig);
10377 return nativeResponseValue;
10379 // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
10381 export function CVec_MessageSendEventZ_free(_res: number): void {
10382 if(!isWasmInitialized) {
10383 throw new Error("initializeWasm() must be awaited first!");
10385 const nativeResponseValue = wasm.TS_CVec_MessageSendEventZ_free(_res);
10386 // debug statements here
10388 // uint64_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg);
10390 export function C2Tuple_usizeTransactionZ_clone_ptr(arg: bigint): bigint {
10391 if(!isWasmInitialized) {
10392 throw new Error("initializeWasm() must be awaited first!");
10394 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone_ptr(arg);
10395 return nativeResponseValue;
10397 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_clone(const struct LDKC2Tuple_usizeTransactionZ *NONNULL_PTR orig);
10399 export function C2Tuple_usizeTransactionZ_clone(orig: bigint): bigint {
10400 if(!isWasmInitialized) {
10401 throw new Error("initializeWasm() must be awaited first!");
10403 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone(orig);
10404 return nativeResponseValue;
10406 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
10408 export function C2Tuple_usizeTransactionZ_new(a: number, b: number): bigint {
10409 if(!isWasmInitialized) {
10410 throw new Error("initializeWasm() must be awaited first!");
10412 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_new(a, b);
10413 return nativeResponseValue;
10415 // void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
10417 export function C2Tuple_usizeTransactionZ_free(_res: bigint): void {
10418 if(!isWasmInitialized) {
10419 throw new Error("initializeWasm() must be awaited first!");
10421 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_free(_res);
10422 // debug statements here
10424 // void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
10426 export function CVec_C2Tuple_usizeTransactionZZ_free(_res: number): void {
10427 if(!isWasmInitialized) {
10428 throw new Error("initializeWasm() must be awaited first!");
10430 const nativeResponseValue = wasm.TS_CVec_C2Tuple_usizeTransactionZZ_free(_res);
10431 // debug statements here
10433 // uint64_t C2Tuple_TxidBlockHashZ_clone_ptr(LDKC2Tuple_TxidBlockHashZ *NONNULL_PTR arg);
10435 export function C2Tuple_TxidBlockHashZ_clone_ptr(arg: bigint): bigint {
10436 if(!isWasmInitialized) {
10437 throw new Error("initializeWasm() must be awaited first!");
10439 const nativeResponseValue = wasm.TS_C2Tuple_TxidBlockHashZ_clone_ptr(arg);
10440 return nativeResponseValue;
10442 // struct LDKC2Tuple_TxidBlockHashZ C2Tuple_TxidBlockHashZ_clone(const struct LDKC2Tuple_TxidBlockHashZ *NONNULL_PTR orig);
10444 export function C2Tuple_TxidBlockHashZ_clone(orig: bigint): bigint {
10445 if(!isWasmInitialized) {
10446 throw new Error("initializeWasm() must be awaited first!");
10448 const nativeResponseValue = wasm.TS_C2Tuple_TxidBlockHashZ_clone(orig);
10449 return nativeResponseValue;
10451 // struct LDKC2Tuple_TxidBlockHashZ C2Tuple_TxidBlockHashZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
10453 export function C2Tuple_TxidBlockHashZ_new(a: number, b: number): bigint {
10454 if(!isWasmInitialized) {
10455 throw new Error("initializeWasm() must be awaited first!");
10457 const nativeResponseValue = wasm.TS_C2Tuple_TxidBlockHashZ_new(a, b);
10458 return nativeResponseValue;
10460 // void C2Tuple_TxidBlockHashZ_free(struct LDKC2Tuple_TxidBlockHashZ _res);
10462 export function C2Tuple_TxidBlockHashZ_free(_res: bigint): void {
10463 if(!isWasmInitialized) {
10464 throw new Error("initializeWasm() must be awaited first!");
10466 const nativeResponseValue = wasm.TS_C2Tuple_TxidBlockHashZ_free(_res);
10467 // debug statements here
10469 // void CVec_C2Tuple_TxidBlockHashZZ_free(struct LDKCVec_C2Tuple_TxidBlockHashZZ _res);
10471 export function CVec_C2Tuple_TxidBlockHashZZ_free(_res: number): void {
10472 if(!isWasmInitialized) {
10473 throw new Error("initializeWasm() must be awaited first!");
10475 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidBlockHashZZ_free(_res);
10476 // debug statements here
10478 // void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
10480 export function CVec_MonitorEventZ_free(_res: number): void {
10481 if(!isWasmInitialized) {
10482 throw new Error("initializeWasm() must be awaited first!");
10484 const nativeResponseValue = wasm.TS_CVec_MonitorEventZ_free(_res);
10485 // debug statements here
10487 // uint64_t C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR arg);
10489 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg: bigint): bigint {
10490 if(!isWasmInitialized) {
10491 throw new Error("initializeWasm() must be awaited first!");
10493 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg);
10494 return nativeResponseValue;
10496 // struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(const struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR orig);
10498 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig: bigint): bigint {
10499 if(!isWasmInitialized) {
10500 throw new Error("initializeWasm() must be awaited first!");
10502 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig);
10503 return nativeResponseValue;
10505 // struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(struct LDKOutPoint a, struct LDKCVec_MonitorEventZ b, struct LDKPublicKey c);
10507 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a: bigint, b: number, c: number): bigint {
10508 if(!isWasmInitialized) {
10509 throw new Error("initializeWasm() must be awaited first!");
10511 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a, b, c);
10512 return nativeResponseValue;
10514 // void C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ _res);
10516 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res: bigint): void {
10517 if(!isWasmInitialized) {
10518 throw new Error("initializeWasm() must be awaited first!");
10520 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res);
10521 // debug statements here
10523 // void CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(struct LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ _res);
10525 export function CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res: number): void {
10526 if(!isWasmInitialized) {
10527 throw new Error("initializeWasm() must be awaited first!");
10529 const nativeResponseValue = wasm.TS_CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res);
10530 // debug statements here
10532 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_ok(struct LDKFixedPenaltyScorer o);
10534 export function CResult_FixedPenaltyScorerDecodeErrorZ_ok(o: bigint): bigint {
10535 if(!isWasmInitialized) {
10536 throw new Error("initializeWasm() must be awaited first!");
10538 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok(o);
10539 return nativeResponseValue;
10541 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_err(struct LDKDecodeError e);
10543 export function CResult_FixedPenaltyScorerDecodeErrorZ_err(e: bigint): bigint {
10544 if(!isWasmInitialized) {
10545 throw new Error("initializeWasm() must be awaited first!");
10547 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_err(e);
10548 return nativeResponseValue;
10550 // bool CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR o);
10552 export function CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o: bigint): boolean {
10553 if(!isWasmInitialized) {
10554 throw new Error("initializeWasm() must be awaited first!");
10556 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o);
10557 return nativeResponseValue;
10559 // void CResult_FixedPenaltyScorerDecodeErrorZ_free(struct LDKCResult_FixedPenaltyScorerDecodeErrorZ _res);
10561 export function CResult_FixedPenaltyScorerDecodeErrorZ_free(_res: bigint): void {
10562 if(!isWasmInitialized) {
10563 throw new Error("initializeWasm() must be awaited first!");
10565 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_free(_res);
10566 // debug statements here
10568 // uint64_t CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR arg);
10570 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10571 if(!isWasmInitialized) {
10572 throw new Error("initializeWasm() must be awaited first!");
10574 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg);
10575 return nativeResponseValue;
10577 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_clone(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR orig);
10579 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig: bigint): bigint {
10580 if(!isWasmInitialized) {
10581 throw new Error("initializeWasm() must be awaited first!");
10583 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig);
10584 return nativeResponseValue;
10586 // uint64_t C2Tuple_u64u64Z_clone_ptr(LDKC2Tuple_u64u64Z *NONNULL_PTR arg);
10588 export function C2Tuple_u64u64Z_clone_ptr(arg: bigint): bigint {
10589 if(!isWasmInitialized) {
10590 throw new Error("initializeWasm() must be awaited first!");
10592 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone_ptr(arg);
10593 return nativeResponseValue;
10595 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_clone(const struct LDKC2Tuple_u64u64Z *NONNULL_PTR orig);
10597 export function C2Tuple_u64u64Z_clone(orig: bigint): bigint {
10598 if(!isWasmInitialized) {
10599 throw new Error("initializeWasm() must be awaited first!");
10601 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone(orig);
10602 return nativeResponseValue;
10604 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_new(uint64_t a, uint64_t b);
10606 export function C2Tuple_u64u64Z_new(a: bigint, b: bigint): bigint {
10607 if(!isWasmInitialized) {
10608 throw new Error("initializeWasm() must be awaited first!");
10610 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_new(a, b);
10611 return nativeResponseValue;
10613 // void C2Tuple_u64u64Z_free(struct LDKC2Tuple_u64u64Z _res);
10615 export function C2Tuple_u64u64Z_free(_res: bigint): void {
10616 if(!isWasmInitialized) {
10617 throw new Error("initializeWasm() must be awaited first!");
10619 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_free(_res);
10620 // debug statements here
10622 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_some(struct LDKC2Tuple_u64u64Z o);
10624 export function COption_C2Tuple_u64u64ZZ_some(o: bigint): bigint {
10625 if(!isWasmInitialized) {
10626 throw new Error("initializeWasm() must be awaited first!");
10628 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_some(o);
10629 return nativeResponseValue;
10631 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_none(void);
10633 export function COption_C2Tuple_u64u64ZZ_none(): bigint {
10634 if(!isWasmInitialized) {
10635 throw new Error("initializeWasm() must be awaited first!");
10637 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_none();
10638 return nativeResponseValue;
10640 // void COption_C2Tuple_u64u64ZZ_free(struct LDKCOption_C2Tuple_u64u64ZZ _res);
10642 export function COption_C2Tuple_u64u64ZZ_free(_res: bigint): void {
10643 if(!isWasmInitialized) {
10644 throw new Error("initializeWasm() must be awaited first!");
10646 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_free(_res);
10647 // debug statements here
10649 // uint64_t COption_C2Tuple_u64u64ZZ_clone_ptr(LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR arg);
10651 export function COption_C2Tuple_u64u64ZZ_clone_ptr(arg: bigint): bigint {
10652 if(!isWasmInitialized) {
10653 throw new Error("initializeWasm() must be awaited first!");
10655 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone_ptr(arg);
10656 return nativeResponseValue;
10658 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_clone(const struct LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR orig);
10660 export function COption_C2Tuple_u64u64ZZ_clone(orig: bigint): bigint {
10661 if(!isWasmInitialized) {
10662 throw new Error("initializeWasm() must be awaited first!");
10664 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone(orig);
10665 return nativeResponseValue;
10667 // uint64_t C2Tuple_Z_clone_ptr(LDKC2Tuple_Z *NONNULL_PTR arg);
10669 export function C2Tuple_Z_clone_ptr(arg: bigint): bigint {
10670 if(!isWasmInitialized) {
10671 throw new Error("initializeWasm() must be awaited first!");
10673 const nativeResponseValue = wasm.TS_C2Tuple_Z_clone_ptr(arg);
10674 return nativeResponseValue;
10676 // struct LDKC2Tuple_Z C2Tuple_Z_clone(const struct LDKC2Tuple_Z *NONNULL_PTR orig);
10678 export function C2Tuple_Z_clone(orig: bigint): bigint {
10679 if(!isWasmInitialized) {
10680 throw new Error("initializeWasm() must be awaited first!");
10682 const nativeResponseValue = wasm.TS_C2Tuple_Z_clone(orig);
10683 return nativeResponseValue;
10685 // struct LDKC2Tuple_Z C2Tuple_Z_new(struct LDKEightU16s a, struct LDKEightU16s b);
10687 export function C2Tuple_Z_new(a: number, b: number): bigint {
10688 if(!isWasmInitialized) {
10689 throw new Error("initializeWasm() must be awaited first!");
10691 const nativeResponseValue = wasm.TS_C2Tuple_Z_new(a, b);
10692 return nativeResponseValue;
10694 // void C2Tuple_Z_free(struct LDKC2Tuple_Z _res);
10696 export function C2Tuple_Z_free(_res: bigint): void {
10697 if(!isWasmInitialized) {
10698 throw new Error("initializeWasm() must be awaited first!");
10700 const nativeResponseValue = wasm.TS_C2Tuple_Z_free(_res);
10701 // debug statements here
10703 // uint64_t C2Tuple__u168_u168Z_clone_ptr(LDKC2Tuple__u168_u168Z *NONNULL_PTR arg);
10705 export function C2Tuple__u168_u168Z_clone_ptr(arg: bigint): bigint {
10706 if(!isWasmInitialized) {
10707 throw new Error("initializeWasm() must be awaited first!");
10709 const nativeResponseValue = wasm.TS_C2Tuple__u168_u168Z_clone_ptr(arg);
10710 return nativeResponseValue;
10712 // struct LDKC2Tuple__u168_u168Z C2Tuple__u168_u168Z_clone(const struct LDKC2Tuple__u168_u168Z *NONNULL_PTR orig);
10714 export function C2Tuple__u168_u168Z_clone(orig: bigint): bigint {
10715 if(!isWasmInitialized) {
10716 throw new Error("initializeWasm() must be awaited first!");
10718 const nativeResponseValue = wasm.TS_C2Tuple__u168_u168Z_clone(orig);
10719 return nativeResponseValue;
10721 // struct LDKC2Tuple__u168_u168Z C2Tuple__u168_u168Z_new(struct LDKEightU16s a, struct LDKEightU16s b);
10723 export function C2Tuple__u168_u168Z_new(a: number, b: number): bigint {
10724 if(!isWasmInitialized) {
10725 throw new Error("initializeWasm() must be awaited first!");
10727 const nativeResponseValue = wasm.TS_C2Tuple__u168_u168Z_new(a, b);
10728 return nativeResponseValue;
10730 // void C2Tuple__u168_u168Z_free(struct LDKC2Tuple__u168_u168Z _res);
10732 export function C2Tuple__u168_u168Z_free(_res: bigint): void {
10733 if(!isWasmInitialized) {
10734 throw new Error("initializeWasm() must be awaited first!");
10736 const nativeResponseValue = wasm.TS_C2Tuple__u168_u168Z_free(_res);
10737 // debug statements here
10739 // struct LDKCOption_C2Tuple_EightU16sEightU16sZZ COption_C2Tuple_EightU16sEightU16sZZ_some(struct LDKC2Tuple__u168_u168Z o);
10741 export function COption_C2Tuple_EightU16sEightU16sZZ_some(o: bigint): bigint {
10742 if(!isWasmInitialized) {
10743 throw new Error("initializeWasm() must be awaited first!");
10745 const nativeResponseValue = wasm.TS_COption_C2Tuple_EightU16sEightU16sZZ_some(o);
10746 return nativeResponseValue;
10748 // struct LDKCOption_C2Tuple_EightU16sEightU16sZZ COption_C2Tuple_EightU16sEightU16sZZ_none(void);
10750 export function COption_C2Tuple_EightU16sEightU16sZZ_none(): bigint {
10751 if(!isWasmInitialized) {
10752 throw new Error("initializeWasm() must be awaited first!");
10754 const nativeResponseValue = wasm.TS_COption_C2Tuple_EightU16sEightU16sZZ_none();
10755 return nativeResponseValue;
10757 // void COption_C2Tuple_EightU16sEightU16sZZ_free(struct LDKCOption_C2Tuple_EightU16sEightU16sZZ _res);
10759 export function COption_C2Tuple_EightU16sEightU16sZZ_free(_res: bigint): void {
10760 if(!isWasmInitialized) {
10761 throw new Error("initializeWasm() must be awaited first!");
10763 const nativeResponseValue = wasm.TS_COption_C2Tuple_EightU16sEightU16sZZ_free(_res);
10764 // debug statements here
10766 // uint64_t COption_C2Tuple_EightU16sEightU16sZZ_clone_ptr(LDKCOption_C2Tuple_EightU16sEightU16sZZ *NONNULL_PTR arg);
10768 export function COption_C2Tuple_EightU16sEightU16sZZ_clone_ptr(arg: bigint): bigint {
10769 if(!isWasmInitialized) {
10770 throw new Error("initializeWasm() must be awaited first!");
10772 const nativeResponseValue = wasm.TS_COption_C2Tuple_EightU16sEightU16sZZ_clone_ptr(arg);
10773 return nativeResponseValue;
10775 // struct LDKCOption_C2Tuple_EightU16sEightU16sZZ COption_C2Tuple_EightU16sEightU16sZZ_clone(const struct LDKCOption_C2Tuple_EightU16sEightU16sZZ *NONNULL_PTR orig);
10777 export function COption_C2Tuple_EightU16sEightU16sZZ_clone(orig: bigint): bigint {
10778 if(!isWasmInitialized) {
10779 throw new Error("initializeWasm() must be awaited first!");
10781 const nativeResponseValue = wasm.TS_COption_C2Tuple_EightU16sEightU16sZZ_clone(orig);
10782 return nativeResponseValue;
10784 // void CVec_NodeIdZ_free(struct LDKCVec_NodeIdZ _res);
10786 export function CVec_NodeIdZ_free(_res: number): void {
10787 if(!isWasmInitialized) {
10788 throw new Error("initializeWasm() must be awaited first!");
10790 const nativeResponseValue = wasm.TS_CVec_NodeIdZ_free(_res);
10791 // debug statements here
10793 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_ok(struct LDKProbabilisticScorer o);
10795 export function CResult_ProbabilisticScorerDecodeErrorZ_ok(o: bigint): bigint {
10796 if(!isWasmInitialized) {
10797 throw new Error("initializeWasm() must be awaited first!");
10799 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_ok(o);
10800 return nativeResponseValue;
10802 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_err(struct LDKDecodeError e);
10804 export function CResult_ProbabilisticScorerDecodeErrorZ_err(e: bigint): bigint {
10805 if(!isWasmInitialized) {
10806 throw new Error("initializeWasm() must be awaited first!");
10808 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_err(e);
10809 return nativeResponseValue;
10811 // bool CResult_ProbabilisticScorerDecodeErrorZ_is_ok(const struct LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR o);
10813 export function CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o: bigint): boolean {
10814 if(!isWasmInitialized) {
10815 throw new Error("initializeWasm() must be awaited first!");
10817 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o);
10818 return nativeResponseValue;
10820 // void CResult_ProbabilisticScorerDecodeErrorZ_free(struct LDKCResult_ProbabilisticScorerDecodeErrorZ _res);
10822 export function CResult_ProbabilisticScorerDecodeErrorZ_free(_res: bigint): void {
10823 if(!isWasmInitialized) {
10824 throw new Error("initializeWasm() must be awaited first!");
10826 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_free(_res);
10827 // debug statements here
10829 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
10831 export function CResult_InitFeaturesDecodeErrorZ_ok(o: bigint): bigint {
10832 if(!isWasmInitialized) {
10833 throw new Error("initializeWasm() must be awaited first!");
10835 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_ok(o);
10836 return nativeResponseValue;
10838 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
10840 export function CResult_InitFeaturesDecodeErrorZ_err(e: bigint): bigint {
10841 if(!isWasmInitialized) {
10842 throw new Error("initializeWasm() must be awaited first!");
10844 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_err(e);
10845 return nativeResponseValue;
10847 // bool CResult_InitFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR o);
10849 export function CResult_InitFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
10850 if(!isWasmInitialized) {
10851 throw new Error("initializeWasm() must be awaited first!");
10853 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_is_ok(o);
10854 return nativeResponseValue;
10856 // void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
10858 export function CResult_InitFeaturesDecodeErrorZ_free(_res: bigint): void {
10859 if(!isWasmInitialized) {
10860 throw new Error("initializeWasm() must be awaited first!");
10862 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_free(_res);
10863 // debug statements here
10865 // uint64_t CResult_InitFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR arg);
10867 export function CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10868 if(!isWasmInitialized) {
10869 throw new Error("initializeWasm() must be awaited first!");
10871 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg);
10872 return nativeResponseValue;
10874 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_clone(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR orig);
10876 export function CResult_InitFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
10877 if(!isWasmInitialized) {
10878 throw new Error("initializeWasm() must be awaited first!");
10880 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone(orig);
10881 return nativeResponseValue;
10883 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
10885 export function CResult_ChannelFeaturesDecodeErrorZ_ok(o: bigint): bigint {
10886 if(!isWasmInitialized) {
10887 throw new Error("initializeWasm() must be awaited first!");
10889 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_ok(o);
10890 return nativeResponseValue;
10892 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
10894 export function CResult_ChannelFeaturesDecodeErrorZ_err(e: bigint): bigint {
10895 if(!isWasmInitialized) {
10896 throw new Error("initializeWasm() must be awaited first!");
10898 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_err(e);
10899 return nativeResponseValue;
10901 // bool CResult_ChannelFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR o);
10903 export function CResult_ChannelFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
10904 if(!isWasmInitialized) {
10905 throw new Error("initializeWasm() must be awaited first!");
10907 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(o);
10908 return nativeResponseValue;
10910 // void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
10912 export function CResult_ChannelFeaturesDecodeErrorZ_free(_res: bigint): void {
10913 if(!isWasmInitialized) {
10914 throw new Error("initializeWasm() must be awaited first!");
10916 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_free(_res);
10917 // debug statements here
10919 // uint64_t CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR arg);
10921 export function CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10922 if(!isWasmInitialized) {
10923 throw new Error("initializeWasm() must be awaited first!");
10925 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg);
10926 return nativeResponseValue;
10928 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR orig);
10930 export function CResult_ChannelFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
10931 if(!isWasmInitialized) {
10932 throw new Error("initializeWasm() must be awaited first!");
10934 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone(orig);
10935 return nativeResponseValue;
10937 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
10939 export function CResult_NodeFeaturesDecodeErrorZ_ok(o: bigint): bigint {
10940 if(!isWasmInitialized) {
10941 throw new Error("initializeWasm() must be awaited first!");
10943 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_ok(o);
10944 return nativeResponseValue;
10946 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
10948 export function CResult_NodeFeaturesDecodeErrorZ_err(e: bigint): bigint {
10949 if(!isWasmInitialized) {
10950 throw new Error("initializeWasm() must be awaited first!");
10952 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_err(e);
10953 return nativeResponseValue;
10955 // bool CResult_NodeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR o);
10957 export function CResult_NodeFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
10958 if(!isWasmInitialized) {
10959 throw new Error("initializeWasm() must be awaited first!");
10961 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(o);
10962 return nativeResponseValue;
10964 // void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
10966 export function CResult_NodeFeaturesDecodeErrorZ_free(_res: bigint): void {
10967 if(!isWasmInitialized) {
10968 throw new Error("initializeWasm() must be awaited first!");
10970 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_free(_res);
10971 // debug statements here
10973 // uint64_t CResult_NodeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR arg);
10975 export function CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10976 if(!isWasmInitialized) {
10977 throw new Error("initializeWasm() must be awaited first!");
10979 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg);
10980 return nativeResponseValue;
10982 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_clone(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR orig);
10984 export function CResult_NodeFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
10985 if(!isWasmInitialized) {
10986 throw new Error("initializeWasm() must be awaited first!");
10988 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone(orig);
10989 return nativeResponseValue;
10991 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_ok(struct LDKInvoiceFeatures o);
10993 export function CResult_InvoiceFeaturesDecodeErrorZ_ok(o: bigint): bigint {
10994 if(!isWasmInitialized) {
10995 throw new Error("initializeWasm() must be awaited first!");
10997 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_ok(o);
10998 return nativeResponseValue;
11000 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
11002 export function CResult_InvoiceFeaturesDecodeErrorZ_err(e: bigint): bigint {
11003 if(!isWasmInitialized) {
11004 throw new Error("initializeWasm() must be awaited first!");
11006 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_err(e);
11007 return nativeResponseValue;
11009 // bool CResult_InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
11011 export function CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
11012 if(!isWasmInitialized) {
11013 throw new Error("initializeWasm() must be awaited first!");
11015 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o);
11016 return nativeResponseValue;
11018 // void CResult_InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_InvoiceFeaturesDecodeErrorZ _res);
11020 export function CResult_InvoiceFeaturesDecodeErrorZ_free(_res: bigint): void {
11021 if(!isWasmInitialized) {
11022 throw new Error("initializeWasm() must be awaited first!");
11024 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_free(_res);
11025 // debug statements here
11027 // uint64_t CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg);
11029 export function CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11030 if(!isWasmInitialized) {
11031 throw new Error("initializeWasm() must be awaited first!");
11033 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg);
11034 return nativeResponseValue;
11036 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_clone(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR orig);
11038 export function CResult_InvoiceFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
11039 if(!isWasmInitialized) {
11040 throw new Error("initializeWasm() must be awaited first!");
11042 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_clone(orig);
11043 return nativeResponseValue;
11045 // struct LDKCResult_BlindedHopFeaturesDecodeErrorZ CResult_BlindedHopFeaturesDecodeErrorZ_ok(struct LDKBlindedHopFeatures o);
11047 export function CResult_BlindedHopFeaturesDecodeErrorZ_ok(o: bigint): bigint {
11048 if(!isWasmInitialized) {
11049 throw new Error("initializeWasm() must be awaited first!");
11051 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_ok(o);
11052 return nativeResponseValue;
11054 // struct LDKCResult_BlindedHopFeaturesDecodeErrorZ CResult_BlindedHopFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
11056 export function CResult_BlindedHopFeaturesDecodeErrorZ_err(e: bigint): bigint {
11057 if(!isWasmInitialized) {
11058 throw new Error("initializeWasm() must be awaited first!");
11060 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_err(e);
11061 return nativeResponseValue;
11063 // bool CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR o);
11065 export function CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
11066 if(!isWasmInitialized) {
11067 throw new Error("initializeWasm() must be awaited first!");
11069 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(o);
11070 return nativeResponseValue;
11072 // void CResult_BlindedHopFeaturesDecodeErrorZ_free(struct LDKCResult_BlindedHopFeaturesDecodeErrorZ _res);
11074 export function CResult_BlindedHopFeaturesDecodeErrorZ_free(_res: bigint): void {
11075 if(!isWasmInitialized) {
11076 throw new Error("initializeWasm() must be awaited first!");
11078 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_free(_res);
11079 // debug statements here
11081 // uint64_t CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR arg);
11083 export function CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11084 if(!isWasmInitialized) {
11085 throw new Error("initializeWasm() must be awaited first!");
11087 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(arg);
11088 return nativeResponseValue;
11090 // struct LDKCResult_BlindedHopFeaturesDecodeErrorZ CResult_BlindedHopFeaturesDecodeErrorZ_clone(const struct LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR orig);
11092 export function CResult_BlindedHopFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
11093 if(!isWasmInitialized) {
11094 throw new Error("initializeWasm() must be awaited first!");
11096 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone(orig);
11097 return nativeResponseValue;
11099 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_ok(struct LDKChannelTypeFeatures o);
11101 export function CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o: bigint): bigint {
11102 if(!isWasmInitialized) {
11103 throw new Error("initializeWasm() must be awaited first!");
11105 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o);
11106 return nativeResponseValue;
11108 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
11110 export function CResult_ChannelTypeFeaturesDecodeErrorZ_err(e: bigint): bigint {
11111 if(!isWasmInitialized) {
11112 throw new Error("initializeWasm() must be awaited first!");
11114 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(e);
11115 return nativeResponseValue;
11117 // bool CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR o);
11119 export function CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
11120 if(!isWasmInitialized) {
11121 throw new Error("initializeWasm() must be awaited first!");
11123 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o);
11124 return nativeResponseValue;
11126 // void CResult_ChannelTypeFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res);
11128 export function CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res: bigint): void {
11129 if(!isWasmInitialized) {
11130 throw new Error("initializeWasm() must be awaited first!");
11132 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res);
11133 // debug statements here
11135 // uint64_t CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR arg);
11137 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11138 if(!isWasmInitialized) {
11139 throw new Error("initializeWasm() must be awaited first!");
11141 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg);
11142 return nativeResponseValue;
11144 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR orig);
11146 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
11147 if(!isWasmInitialized) {
11148 throw new Error("initializeWasm() must be awaited first!");
11150 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig);
11151 return nativeResponseValue;
11153 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_ok(struct LDKNodeId o);
11155 export function CResult_NodeIdDecodeErrorZ_ok(o: bigint): bigint {
11156 if(!isWasmInitialized) {
11157 throw new Error("initializeWasm() must be awaited first!");
11159 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_ok(o);
11160 return nativeResponseValue;
11162 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_err(struct LDKDecodeError e);
11164 export function CResult_NodeIdDecodeErrorZ_err(e: bigint): bigint {
11165 if(!isWasmInitialized) {
11166 throw new Error("initializeWasm() must be awaited first!");
11168 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_err(e);
11169 return nativeResponseValue;
11171 // bool CResult_NodeIdDecodeErrorZ_is_ok(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR o);
11173 export function CResult_NodeIdDecodeErrorZ_is_ok(o: bigint): boolean {
11174 if(!isWasmInitialized) {
11175 throw new Error("initializeWasm() must be awaited first!");
11177 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_is_ok(o);
11178 return nativeResponseValue;
11180 // void CResult_NodeIdDecodeErrorZ_free(struct LDKCResult_NodeIdDecodeErrorZ _res);
11182 export function CResult_NodeIdDecodeErrorZ_free(_res: bigint): void {
11183 if(!isWasmInitialized) {
11184 throw new Error("initializeWasm() must be awaited first!");
11186 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_free(_res);
11187 // debug statements here
11189 // uint64_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg);
11191 export function CResult_NodeIdDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11192 if(!isWasmInitialized) {
11193 throw new Error("initializeWasm() must be awaited first!");
11195 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone_ptr(arg);
11196 return nativeResponseValue;
11198 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_clone(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR orig);
11200 export function CResult_NodeIdDecodeErrorZ_clone(orig: bigint): bigint {
11201 if(!isWasmInitialized) {
11202 throw new Error("initializeWasm() must be awaited first!");
11204 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone(orig);
11205 return nativeResponseValue;
11207 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_ok(struct LDKCOption_NetworkUpdateZ o);
11209 export function CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o: bigint): bigint {
11210 if(!isWasmInitialized) {
11211 throw new Error("initializeWasm() must be awaited first!");
11213 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o);
11214 return nativeResponseValue;
11216 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_err(struct LDKDecodeError e);
11218 export function CResult_COption_NetworkUpdateZDecodeErrorZ_err(e: bigint): bigint {
11219 if(!isWasmInitialized) {
11220 throw new Error("initializeWasm() must be awaited first!");
11222 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(e);
11223 return nativeResponseValue;
11225 // bool CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR o);
11227 export function CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o: bigint): boolean {
11228 if(!isWasmInitialized) {
11229 throw new Error("initializeWasm() must be awaited first!");
11231 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o);
11232 return nativeResponseValue;
11234 // void CResult_COption_NetworkUpdateZDecodeErrorZ_free(struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res);
11236 export function CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res: bigint): void {
11237 if(!isWasmInitialized) {
11238 throw new Error("initializeWasm() must be awaited first!");
11240 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res);
11241 // debug statements here
11243 // uint64_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg);
11245 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11246 if(!isWasmInitialized) {
11247 throw new Error("initializeWasm() must be awaited first!");
11249 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg);
11250 return nativeResponseValue;
11252 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_clone(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR orig);
11254 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig: bigint): bigint {
11255 if(!isWasmInitialized) {
11256 throw new Error("initializeWasm() must be awaited first!");
11258 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig);
11259 return nativeResponseValue;
11261 // struct LDKCOption_UtxoLookupZ COption_UtxoLookupZ_some(struct LDKUtxoLookup o);
11263 export function COption_UtxoLookupZ_some(o: bigint): bigint {
11264 if(!isWasmInitialized) {
11265 throw new Error("initializeWasm() must be awaited first!");
11267 const nativeResponseValue = wasm.TS_COption_UtxoLookupZ_some(o);
11268 return nativeResponseValue;
11270 // struct LDKCOption_UtxoLookupZ COption_UtxoLookupZ_none(void);
11272 export function COption_UtxoLookupZ_none(): bigint {
11273 if(!isWasmInitialized) {
11274 throw new Error("initializeWasm() must be awaited first!");
11276 const nativeResponseValue = wasm.TS_COption_UtxoLookupZ_none();
11277 return nativeResponseValue;
11279 // void COption_UtxoLookupZ_free(struct LDKCOption_UtxoLookupZ _res);
11281 export function COption_UtxoLookupZ_free(_res: bigint): void {
11282 if(!isWasmInitialized) {
11283 throw new Error("initializeWasm() must be awaited first!");
11285 const nativeResponseValue = wasm.TS_COption_UtxoLookupZ_free(_res);
11286 // debug statements here
11288 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
11290 export function CResult_boolLightningErrorZ_ok(o: boolean): bigint {
11291 if(!isWasmInitialized) {
11292 throw new Error("initializeWasm() must be awaited first!");
11294 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_ok(o);
11295 return nativeResponseValue;
11297 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
11299 export function CResult_boolLightningErrorZ_err(e: bigint): bigint {
11300 if(!isWasmInitialized) {
11301 throw new Error("initializeWasm() must be awaited first!");
11303 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_err(e);
11304 return nativeResponseValue;
11306 // bool CResult_boolLightningErrorZ_is_ok(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR o);
11308 export function CResult_boolLightningErrorZ_is_ok(o: bigint): boolean {
11309 if(!isWasmInitialized) {
11310 throw new Error("initializeWasm() must be awaited first!");
11312 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_is_ok(o);
11313 return nativeResponseValue;
11315 // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
11317 export function CResult_boolLightningErrorZ_free(_res: bigint): void {
11318 if(!isWasmInitialized) {
11319 throw new Error("initializeWasm() must be awaited first!");
11321 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_free(_res);
11322 // debug statements here
11324 // uint64_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg);
11326 export function CResult_boolLightningErrorZ_clone_ptr(arg: bigint): bigint {
11327 if(!isWasmInitialized) {
11328 throw new Error("initializeWasm() must be awaited first!");
11330 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone_ptr(arg);
11331 return nativeResponseValue;
11333 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
11335 export function CResult_boolLightningErrorZ_clone(orig: bigint): bigint {
11336 if(!isWasmInitialized) {
11337 throw new Error("initializeWasm() must be awaited first!");
11339 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone(orig);
11340 return nativeResponseValue;
11342 // uint64_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg);
11344 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg: bigint): bigint {
11345 if(!isWasmInitialized) {
11346 throw new Error("initializeWasm() must be awaited first!");
11348 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg);
11349 return nativeResponseValue;
11351 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
11353 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: bigint): bigint {
11354 if(!isWasmInitialized) {
11355 throw new Error("initializeWasm() must be awaited first!");
11357 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig);
11358 return nativeResponseValue;
11360 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
11362 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: bigint, b: bigint, c: bigint): bigint {
11363 if(!isWasmInitialized) {
11364 throw new Error("initializeWasm() must be awaited first!");
11366 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c);
11367 return nativeResponseValue;
11369 // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
11371 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: bigint): void {
11372 if(!isWasmInitialized) {
11373 throw new Error("initializeWasm() must be awaited first!");
11375 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res);
11376 // debug statements here
11378 // struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ o);
11380 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(o: bigint): bigint {
11381 if(!isWasmInitialized) {
11382 throw new Error("initializeWasm() must be awaited first!");
11384 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(o);
11385 return nativeResponseValue;
11387 // struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none(void);
11389 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none(): bigint {
11390 if(!isWasmInitialized) {
11391 throw new Error("initializeWasm() must be awaited first!");
11393 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none();
11394 return nativeResponseValue;
11396 // void COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
11398 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: bigint): void {
11399 if(!isWasmInitialized) {
11400 throw new Error("initializeWasm() must be awaited first!");
11402 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res);
11403 // debug statements here
11405 // uint64_t COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *NONNULL_PTR arg);
11407 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(arg: bigint): bigint {
11408 if(!isWasmInitialized) {
11409 throw new Error("initializeWasm() must be awaited first!");
11411 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(arg);
11412 return nativeResponseValue;
11414 // struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(const struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *NONNULL_PTR orig);
11416 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(orig: bigint): bigint {
11417 if(!isWasmInitialized) {
11418 throw new Error("initializeWasm() must be awaited first!");
11420 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(orig);
11421 return nativeResponseValue;
11423 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
11425 export function CResult_NoneLightningErrorZ_ok(): bigint {
11426 if(!isWasmInitialized) {
11427 throw new Error("initializeWasm() must be awaited first!");
11429 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_ok();
11430 return nativeResponseValue;
11432 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
11434 export function CResult_NoneLightningErrorZ_err(e: bigint): bigint {
11435 if(!isWasmInitialized) {
11436 throw new Error("initializeWasm() must be awaited first!");
11438 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_err(e);
11439 return nativeResponseValue;
11441 // bool CResult_NoneLightningErrorZ_is_ok(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR o);
11443 export function CResult_NoneLightningErrorZ_is_ok(o: bigint): boolean {
11444 if(!isWasmInitialized) {
11445 throw new Error("initializeWasm() must be awaited first!");
11447 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_is_ok(o);
11448 return nativeResponseValue;
11450 // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
11452 export function CResult_NoneLightningErrorZ_free(_res: bigint): void {
11453 if(!isWasmInitialized) {
11454 throw new Error("initializeWasm() must be awaited first!");
11456 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_free(_res);
11457 // debug statements here
11459 // uint64_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg);
11461 export function CResult_NoneLightningErrorZ_clone_ptr(arg: bigint): bigint {
11462 if(!isWasmInitialized) {
11463 throw new Error("initializeWasm() must be awaited first!");
11465 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone_ptr(arg);
11466 return nativeResponseValue;
11468 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
11470 export function CResult_NoneLightningErrorZ_clone(orig: bigint): bigint {
11471 if(!isWasmInitialized) {
11472 throw new Error("initializeWasm() must be awaited first!");
11474 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone(orig);
11475 return nativeResponseValue;
11477 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_ok(struct LDKChannelUpdateInfo o);
11479 export function CResult_ChannelUpdateInfoDecodeErrorZ_ok(o: bigint): bigint {
11480 if(!isWasmInitialized) {
11481 throw new Error("initializeWasm() must be awaited first!");
11483 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok(o);
11484 return nativeResponseValue;
11486 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_err(struct LDKDecodeError e);
11488 export function CResult_ChannelUpdateInfoDecodeErrorZ_err(e: bigint): bigint {
11489 if(!isWasmInitialized) {
11490 throw new Error("initializeWasm() must be awaited first!");
11492 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_err(e);
11493 return nativeResponseValue;
11495 // bool CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR o);
11497 export function CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o: bigint): boolean {
11498 if(!isWasmInitialized) {
11499 throw new Error("initializeWasm() must be awaited first!");
11501 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o);
11502 return nativeResponseValue;
11504 // void CResult_ChannelUpdateInfoDecodeErrorZ_free(struct LDKCResult_ChannelUpdateInfoDecodeErrorZ _res);
11506 export function CResult_ChannelUpdateInfoDecodeErrorZ_free(_res: bigint): void {
11507 if(!isWasmInitialized) {
11508 throw new Error("initializeWasm() must be awaited first!");
11510 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_free(_res);
11511 // debug statements here
11513 // uint64_t CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR arg);
11515 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11516 if(!isWasmInitialized) {
11517 throw new Error("initializeWasm() must be awaited first!");
11519 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg);
11520 return nativeResponseValue;
11522 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR orig);
11524 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig: bigint): bigint {
11525 if(!isWasmInitialized) {
11526 throw new Error("initializeWasm() must be awaited first!");
11528 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig);
11529 return nativeResponseValue;
11531 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
11533 export function CResult_ChannelInfoDecodeErrorZ_ok(o: bigint): bigint {
11534 if(!isWasmInitialized) {
11535 throw new Error("initializeWasm() must be awaited first!");
11537 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_ok(o);
11538 return nativeResponseValue;
11540 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
11542 export function CResult_ChannelInfoDecodeErrorZ_err(e: bigint): bigint {
11543 if(!isWasmInitialized) {
11544 throw new Error("initializeWasm() must be awaited first!");
11546 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_err(e);
11547 return nativeResponseValue;
11549 // bool CResult_ChannelInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR o);
11551 export function CResult_ChannelInfoDecodeErrorZ_is_ok(o: bigint): boolean {
11552 if(!isWasmInitialized) {
11553 throw new Error("initializeWasm() must be awaited first!");
11555 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_is_ok(o);
11556 return nativeResponseValue;
11558 // void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
11560 export function CResult_ChannelInfoDecodeErrorZ_free(_res: bigint): void {
11561 if(!isWasmInitialized) {
11562 throw new Error("initializeWasm() must be awaited first!");
11564 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_free(_res);
11565 // debug statements here
11567 // uint64_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg);
11569 export function CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11570 if(!isWasmInitialized) {
11571 throw new Error("initializeWasm() must be awaited first!");
11573 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg);
11574 return nativeResponseValue;
11576 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
11578 export function CResult_ChannelInfoDecodeErrorZ_clone(orig: bigint): bigint {
11579 if(!isWasmInitialized) {
11580 throw new Error("initializeWasm() must be awaited first!");
11582 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone(orig);
11583 return nativeResponseValue;
11585 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
11587 export function CResult_RoutingFeesDecodeErrorZ_ok(o: bigint): bigint {
11588 if(!isWasmInitialized) {
11589 throw new Error("initializeWasm() must be awaited first!");
11591 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_ok(o);
11592 return nativeResponseValue;
11594 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
11596 export function CResult_RoutingFeesDecodeErrorZ_err(e: bigint): bigint {
11597 if(!isWasmInitialized) {
11598 throw new Error("initializeWasm() must be awaited first!");
11600 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_err(e);
11601 return nativeResponseValue;
11603 // bool CResult_RoutingFeesDecodeErrorZ_is_ok(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR o);
11605 export function CResult_RoutingFeesDecodeErrorZ_is_ok(o: bigint): boolean {
11606 if(!isWasmInitialized) {
11607 throw new Error("initializeWasm() must be awaited first!");
11609 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_is_ok(o);
11610 return nativeResponseValue;
11612 // void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
11614 export function CResult_RoutingFeesDecodeErrorZ_free(_res: bigint): void {
11615 if(!isWasmInitialized) {
11616 throw new Error("initializeWasm() must be awaited first!");
11618 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_free(_res);
11619 // debug statements here
11621 // uint64_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg);
11623 export function CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11624 if(!isWasmInitialized) {
11625 throw new Error("initializeWasm() must be awaited first!");
11627 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg);
11628 return nativeResponseValue;
11630 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
11632 export function CResult_RoutingFeesDecodeErrorZ_clone(orig: bigint): bigint {
11633 if(!isWasmInitialized) {
11634 throw new Error("initializeWasm() must be awaited first!");
11636 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone(orig);
11637 return nativeResponseValue;
11639 // void CVec_NetAddressZ_free(struct LDKCVec_NetAddressZ _res);
11641 export function CVec_NetAddressZ_free(_res: number): void {
11642 if(!isWasmInitialized) {
11643 throw new Error("initializeWasm() must be awaited first!");
11645 const nativeResponseValue = wasm.TS_CVec_NetAddressZ_free(_res);
11646 // debug statements here
11648 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
11650 export function CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o: bigint): bigint {
11651 if(!isWasmInitialized) {
11652 throw new Error("initializeWasm() must be awaited first!");
11654 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o);
11655 return nativeResponseValue;
11657 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
11659 export function CResult_NodeAnnouncementInfoDecodeErrorZ_err(e: bigint): bigint {
11660 if(!isWasmInitialized) {
11661 throw new Error("initializeWasm() must be awaited first!");
11663 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(e);
11664 return nativeResponseValue;
11666 // bool CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR o);
11668 export function CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o: bigint): boolean {
11669 if(!isWasmInitialized) {
11670 throw new Error("initializeWasm() must be awaited first!");
11672 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o);
11673 return nativeResponseValue;
11675 // void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
11677 export function CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res: bigint): void {
11678 if(!isWasmInitialized) {
11679 throw new Error("initializeWasm() must be awaited first!");
11681 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res);
11682 // debug statements here
11684 // uint64_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg);
11686 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11687 if(!isWasmInitialized) {
11688 throw new Error("initializeWasm() must be awaited first!");
11690 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg);
11691 return nativeResponseValue;
11693 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
11695 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: bigint): bigint {
11696 if(!isWasmInitialized) {
11697 throw new Error("initializeWasm() must be awaited first!");
11699 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig);
11700 return nativeResponseValue;
11702 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_ok(struct LDKNodeAlias o);
11704 export function CResult_NodeAliasDecodeErrorZ_ok(o: bigint): bigint {
11705 if(!isWasmInitialized) {
11706 throw new Error("initializeWasm() must be awaited first!");
11708 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_ok(o);
11709 return nativeResponseValue;
11711 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_err(struct LDKDecodeError e);
11713 export function CResult_NodeAliasDecodeErrorZ_err(e: bigint): bigint {
11714 if(!isWasmInitialized) {
11715 throw new Error("initializeWasm() must be awaited first!");
11717 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_err(e);
11718 return nativeResponseValue;
11720 // bool CResult_NodeAliasDecodeErrorZ_is_ok(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR o);
11722 export function CResult_NodeAliasDecodeErrorZ_is_ok(o: bigint): boolean {
11723 if(!isWasmInitialized) {
11724 throw new Error("initializeWasm() must be awaited first!");
11726 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_is_ok(o);
11727 return nativeResponseValue;
11729 // void CResult_NodeAliasDecodeErrorZ_free(struct LDKCResult_NodeAliasDecodeErrorZ _res);
11731 export function CResult_NodeAliasDecodeErrorZ_free(_res: bigint): void {
11732 if(!isWasmInitialized) {
11733 throw new Error("initializeWasm() must be awaited first!");
11735 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_free(_res);
11736 // debug statements here
11738 // uint64_t CResult_NodeAliasDecodeErrorZ_clone_ptr(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR arg);
11740 export function CResult_NodeAliasDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11741 if(!isWasmInitialized) {
11742 throw new Error("initializeWasm() must be awaited first!");
11744 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone_ptr(arg);
11745 return nativeResponseValue;
11747 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_clone(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR orig);
11749 export function CResult_NodeAliasDecodeErrorZ_clone(orig: bigint): bigint {
11750 if(!isWasmInitialized) {
11751 throw new Error("initializeWasm() must be awaited first!");
11753 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone(orig);
11754 return nativeResponseValue;
11756 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_ok(struct LDKNodeInfo o);
11758 export function CResult_NodeInfoDecodeErrorZ_ok(o: bigint): bigint {
11759 if(!isWasmInitialized) {
11760 throw new Error("initializeWasm() must be awaited first!");
11762 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_ok(o);
11763 return nativeResponseValue;
11765 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
11767 export function CResult_NodeInfoDecodeErrorZ_err(e: bigint): bigint {
11768 if(!isWasmInitialized) {
11769 throw new Error("initializeWasm() must be awaited first!");
11771 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_err(e);
11772 return nativeResponseValue;
11774 // bool CResult_NodeInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR o);
11776 export function CResult_NodeInfoDecodeErrorZ_is_ok(o: bigint): boolean {
11777 if(!isWasmInitialized) {
11778 throw new Error("initializeWasm() must be awaited first!");
11780 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_is_ok(o);
11781 return nativeResponseValue;
11783 // void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
11785 export function CResult_NodeInfoDecodeErrorZ_free(_res: bigint): void {
11786 if(!isWasmInitialized) {
11787 throw new Error("initializeWasm() must be awaited first!");
11789 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_free(_res);
11790 // debug statements here
11792 // uint64_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg);
11794 export function CResult_NodeInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11795 if(!isWasmInitialized) {
11796 throw new Error("initializeWasm() must be awaited first!");
11798 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(arg);
11799 return nativeResponseValue;
11801 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
11803 export function CResult_NodeInfoDecodeErrorZ_clone(orig: bigint): bigint {
11804 if(!isWasmInitialized) {
11805 throw new Error("initializeWasm() must be awaited first!");
11807 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone(orig);
11808 return nativeResponseValue;
11810 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
11812 export function CResult_NetworkGraphDecodeErrorZ_ok(o: bigint): bigint {
11813 if(!isWasmInitialized) {
11814 throw new Error("initializeWasm() must be awaited first!");
11816 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_ok(o);
11817 return nativeResponseValue;
11819 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
11821 export function CResult_NetworkGraphDecodeErrorZ_err(e: bigint): bigint {
11822 if(!isWasmInitialized) {
11823 throw new Error("initializeWasm() must be awaited first!");
11825 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_err(e);
11826 return nativeResponseValue;
11828 // bool CResult_NetworkGraphDecodeErrorZ_is_ok(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR o);
11830 export function CResult_NetworkGraphDecodeErrorZ_is_ok(o: bigint): boolean {
11831 if(!isWasmInitialized) {
11832 throw new Error("initializeWasm() must be awaited first!");
11834 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_is_ok(o);
11835 return nativeResponseValue;
11837 // void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
11839 export function CResult_NetworkGraphDecodeErrorZ_free(_res: bigint): void {
11840 if(!isWasmInitialized) {
11841 throw new Error("initializeWasm() must be awaited first!");
11843 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_free(_res);
11844 // debug statements here
11846 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_some(struct LDKCVec_NetAddressZ o);
11848 export function COption_CVec_NetAddressZZ_some(o: number): bigint {
11849 if(!isWasmInitialized) {
11850 throw new Error("initializeWasm() must be awaited first!");
11852 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_some(o);
11853 return nativeResponseValue;
11855 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_none(void);
11857 export function COption_CVec_NetAddressZZ_none(): bigint {
11858 if(!isWasmInitialized) {
11859 throw new Error("initializeWasm() must be awaited first!");
11861 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_none();
11862 return nativeResponseValue;
11864 // void COption_CVec_NetAddressZZ_free(struct LDKCOption_CVec_NetAddressZZ _res);
11866 export function COption_CVec_NetAddressZZ_free(_res: bigint): void {
11867 if(!isWasmInitialized) {
11868 throw new Error("initializeWasm() must be awaited first!");
11870 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_free(_res);
11871 // debug statements here
11873 // uint64_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg);
11875 export function COption_CVec_NetAddressZZ_clone_ptr(arg: bigint): bigint {
11876 if(!isWasmInitialized) {
11877 throw new Error("initializeWasm() must be awaited first!");
11879 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone_ptr(arg);
11880 return nativeResponseValue;
11882 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_clone(const struct LDKCOption_CVec_NetAddressZZ *NONNULL_PTR orig);
11884 export function COption_CVec_NetAddressZZ_clone(orig: bigint): bigint {
11885 if(!isWasmInitialized) {
11886 throw new Error("initializeWasm() must be awaited first!");
11888 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone(orig);
11889 return nativeResponseValue;
11891 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKDelayedPaymentOutputDescriptor o);
11893 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
11894 if(!isWasmInitialized) {
11895 throw new Error("initializeWasm() must be awaited first!");
11897 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o);
11898 return nativeResponseValue;
11900 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
11902 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
11903 if(!isWasmInitialized) {
11904 throw new Error("initializeWasm() must be awaited first!");
11906 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e);
11907 return nativeResponseValue;
11909 // bool CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
11911 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
11912 if(!isWasmInitialized) {
11913 throw new Error("initializeWasm() must be awaited first!");
11915 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
11916 return nativeResponseValue;
11918 // void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res);
11920 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
11921 if(!isWasmInitialized) {
11922 throw new Error("initializeWasm() must be awaited first!");
11924 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res);
11925 // debug statements here
11927 // uint64_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
11929 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11930 if(!isWasmInitialized) {
11931 throw new Error("initializeWasm() must be awaited first!");
11933 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
11934 return nativeResponseValue;
11936 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
11938 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
11939 if(!isWasmInitialized) {
11940 throw new Error("initializeWasm() must be awaited first!");
11942 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig);
11943 return nativeResponseValue;
11945 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKStaticPaymentOutputDescriptor o);
11947 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
11948 if(!isWasmInitialized) {
11949 throw new Error("initializeWasm() must be awaited first!");
11951 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o);
11952 return nativeResponseValue;
11954 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
11956 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
11957 if(!isWasmInitialized) {
11958 throw new Error("initializeWasm() must be awaited first!");
11960 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e);
11961 return nativeResponseValue;
11963 // bool CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
11965 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
11966 if(!isWasmInitialized) {
11967 throw new Error("initializeWasm() must be awaited first!");
11969 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
11970 return nativeResponseValue;
11972 // void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res);
11974 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
11975 if(!isWasmInitialized) {
11976 throw new Error("initializeWasm() must be awaited first!");
11978 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res);
11979 // debug statements here
11981 // uint64_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
11983 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11984 if(!isWasmInitialized) {
11985 throw new Error("initializeWasm() must be awaited first!");
11987 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
11988 return nativeResponseValue;
11990 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
11992 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
11993 if(!isWasmInitialized) {
11994 throw new Error("initializeWasm() must be awaited first!");
11996 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig);
11997 return nativeResponseValue;
11999 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
12001 export function CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
12002 if(!isWasmInitialized) {
12003 throw new Error("initializeWasm() must be awaited first!");
12005 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o);
12006 return nativeResponseValue;
12008 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
12010 export function CResult_SpendableOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
12011 if(!isWasmInitialized) {
12012 throw new Error("initializeWasm() must be awaited first!");
12014 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(e);
12015 return nativeResponseValue;
12017 // bool CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
12019 export function CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
12020 if(!isWasmInitialized) {
12021 throw new Error("initializeWasm() must be awaited first!");
12023 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o);
12024 return nativeResponseValue;
12026 // void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
12028 export function CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
12029 if(!isWasmInitialized) {
12030 throw new Error("initializeWasm() must be awaited first!");
12032 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res);
12033 // debug statements here
12035 // uint64_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
12037 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12038 if(!isWasmInitialized) {
12039 throw new Error("initializeWasm() must be awaited first!");
12041 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg);
12042 return nativeResponseValue;
12044 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
12046 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
12047 if(!isWasmInitialized) {
12048 throw new Error("initializeWasm() must be awaited first!");
12050 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig);
12051 return nativeResponseValue;
12053 // void CVec_PaymentPreimageZ_free(struct LDKCVec_PaymentPreimageZ _res);
12055 export function CVec_PaymentPreimageZ_free(_res: number): void {
12056 if(!isWasmInitialized) {
12057 throw new Error("initializeWasm() must be awaited first!");
12059 const nativeResponseValue = wasm.TS_CVec_PaymentPreimageZ_free(_res);
12060 // debug statements here
12062 // uint64_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg);
12064 export function C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg: bigint): bigint {
12065 if(!isWasmInitialized) {
12066 throw new Error("initializeWasm() must be awaited first!");
12068 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg);
12069 return nativeResponseValue;
12071 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_clone(const struct LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR orig);
12073 export function C2Tuple_SignatureCVec_SignatureZZ_clone(orig: bigint): bigint {
12074 if(!isWasmInitialized) {
12075 throw new Error("initializeWasm() must be awaited first!");
12077 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone(orig);
12078 return nativeResponseValue;
12080 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_new(struct LDKSignature a, struct LDKCVec_SignatureZ b);
12082 export function C2Tuple_SignatureCVec_SignatureZZ_new(a: number, b: number): bigint {
12083 if(!isWasmInitialized) {
12084 throw new Error("initializeWasm() must be awaited first!");
12086 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_new(a, b);
12087 return nativeResponseValue;
12089 // void C2Tuple_SignatureCVec_SignatureZZ_free(struct LDKC2Tuple_SignatureCVec_SignatureZZ _res);
12091 export function C2Tuple_SignatureCVec_SignatureZZ_free(_res: bigint): void {
12092 if(!isWasmInitialized) {
12093 throw new Error("initializeWasm() must be awaited first!");
12095 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_free(_res);
12096 // debug statements here
12098 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(struct LDKC2Tuple_SignatureCVec_SignatureZZ o);
12100 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o: bigint): bigint {
12101 if(!isWasmInitialized) {
12102 throw new Error("initializeWasm() must be awaited first!");
12104 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o);
12105 return nativeResponseValue;
12107 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(void);
12109 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(): bigint {
12110 if(!isWasmInitialized) {
12111 throw new Error("initializeWasm() must be awaited first!");
12113 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
12114 return nativeResponseValue;
12116 // bool CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR o);
12118 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o: bigint): boolean {
12119 if(!isWasmInitialized) {
12120 throw new Error("initializeWasm() must be awaited first!");
12122 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o);
12123 return nativeResponseValue;
12125 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res);
12127 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res: bigint): void {
12128 if(!isWasmInitialized) {
12129 throw new Error("initializeWasm() must be awaited first!");
12131 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res);
12132 // debug statements here
12134 // uint64_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg);
12136 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg: bigint): bigint {
12137 if(!isWasmInitialized) {
12138 throw new Error("initializeWasm() must be awaited first!");
12140 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg);
12141 return nativeResponseValue;
12143 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR orig);
12145 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig: bigint): bigint {
12146 if(!isWasmInitialized) {
12147 throw new Error("initializeWasm() must be awaited first!");
12149 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig);
12150 return nativeResponseValue;
12152 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_ok(struct LDKSignature o);
12154 export function CResult_SignatureNoneZ_ok(o: number): bigint {
12155 if(!isWasmInitialized) {
12156 throw new Error("initializeWasm() must be awaited first!");
12158 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_ok(o);
12159 return nativeResponseValue;
12161 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_err(void);
12163 export function CResult_SignatureNoneZ_err(): bigint {
12164 if(!isWasmInitialized) {
12165 throw new Error("initializeWasm() must be awaited first!");
12167 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_err();
12168 return nativeResponseValue;
12170 // bool CResult_SignatureNoneZ_is_ok(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR o);
12172 export function CResult_SignatureNoneZ_is_ok(o: bigint): boolean {
12173 if(!isWasmInitialized) {
12174 throw new Error("initializeWasm() must be awaited first!");
12176 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_is_ok(o);
12177 return nativeResponseValue;
12179 // void CResult_SignatureNoneZ_free(struct LDKCResult_SignatureNoneZ _res);
12181 export function CResult_SignatureNoneZ_free(_res: bigint): void {
12182 if(!isWasmInitialized) {
12183 throw new Error("initializeWasm() must be awaited first!");
12185 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_free(_res);
12186 // debug statements here
12188 // uint64_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg);
12190 export function CResult_SignatureNoneZ_clone_ptr(arg: bigint): bigint {
12191 if(!isWasmInitialized) {
12192 throw new Error("initializeWasm() must be awaited first!");
12194 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone_ptr(arg);
12195 return nativeResponseValue;
12197 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_clone(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR orig);
12199 export function CResult_SignatureNoneZ_clone(orig: bigint): bigint {
12200 if(!isWasmInitialized) {
12201 throw new Error("initializeWasm() must be awaited first!");
12203 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone(orig);
12204 return nativeResponseValue;
12206 // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_ok(struct LDKPublicKey o);
12208 export function CResult_PublicKeyNoneZ_ok(o: number): bigint {
12209 if(!isWasmInitialized) {
12210 throw new Error("initializeWasm() must be awaited first!");
12212 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_ok(o);
12213 return nativeResponseValue;
12215 // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_err(void);
12217 export function CResult_PublicKeyNoneZ_err(): bigint {
12218 if(!isWasmInitialized) {
12219 throw new Error("initializeWasm() must be awaited first!");
12221 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_err();
12222 return nativeResponseValue;
12224 // bool CResult_PublicKeyNoneZ_is_ok(const struct LDKCResult_PublicKeyNoneZ *NONNULL_PTR o);
12226 export function CResult_PublicKeyNoneZ_is_ok(o: bigint): boolean {
12227 if(!isWasmInitialized) {
12228 throw new Error("initializeWasm() must be awaited first!");
12230 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_is_ok(o);
12231 return nativeResponseValue;
12233 // void CResult_PublicKeyNoneZ_free(struct LDKCResult_PublicKeyNoneZ _res);
12235 export function CResult_PublicKeyNoneZ_free(_res: bigint): void {
12236 if(!isWasmInitialized) {
12237 throw new Error("initializeWasm() must be awaited first!");
12239 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_free(_res);
12240 // debug statements here
12242 // uint64_t CResult_PublicKeyNoneZ_clone_ptr(LDKCResult_PublicKeyNoneZ *NONNULL_PTR arg);
12244 export function CResult_PublicKeyNoneZ_clone_ptr(arg: bigint): bigint {
12245 if(!isWasmInitialized) {
12246 throw new Error("initializeWasm() must be awaited first!");
12248 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_clone_ptr(arg);
12249 return nativeResponseValue;
12251 // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_clone(const struct LDKCResult_PublicKeyNoneZ *NONNULL_PTR orig);
12253 export function CResult_PublicKeyNoneZ_clone(orig: bigint): bigint {
12254 if(!isWasmInitialized) {
12255 throw new Error("initializeWasm() must be awaited first!");
12257 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_clone(orig);
12258 return nativeResponseValue;
12260 // struct LDKCOption_ScalarZ COption_ScalarZ_some(struct LDKBigEndianScalar o);
12262 export function COption_ScalarZ_some(o: bigint): bigint {
12263 if(!isWasmInitialized) {
12264 throw new Error("initializeWasm() must be awaited first!");
12266 const nativeResponseValue = wasm.TS_COption_ScalarZ_some(o);
12267 return nativeResponseValue;
12269 // struct LDKCOption_ScalarZ COption_ScalarZ_none(void);
12271 export function COption_ScalarZ_none(): bigint {
12272 if(!isWasmInitialized) {
12273 throw new Error("initializeWasm() must be awaited first!");
12275 const nativeResponseValue = wasm.TS_COption_ScalarZ_none();
12276 return nativeResponseValue;
12278 // void COption_ScalarZ_free(struct LDKCOption_ScalarZ _res);
12280 export function COption_ScalarZ_free(_res: bigint): void {
12281 if(!isWasmInitialized) {
12282 throw new Error("initializeWasm() must be awaited first!");
12284 const nativeResponseValue = wasm.TS_COption_ScalarZ_free(_res);
12285 // debug statements here
12287 // struct LDKCResult_SharedSecretNoneZ CResult_SharedSecretNoneZ_ok(struct LDKThirtyTwoBytes o);
12289 export function CResult_SharedSecretNoneZ_ok(o: number): bigint {
12290 if(!isWasmInitialized) {
12291 throw new Error("initializeWasm() must be awaited first!");
12293 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_ok(o);
12294 return nativeResponseValue;
12296 // struct LDKCResult_SharedSecretNoneZ CResult_SharedSecretNoneZ_err(void);
12298 export function CResult_SharedSecretNoneZ_err(): bigint {
12299 if(!isWasmInitialized) {
12300 throw new Error("initializeWasm() must be awaited first!");
12302 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_err();
12303 return nativeResponseValue;
12305 // bool CResult_SharedSecretNoneZ_is_ok(const struct LDKCResult_SharedSecretNoneZ *NONNULL_PTR o);
12307 export function CResult_SharedSecretNoneZ_is_ok(o: bigint): boolean {
12308 if(!isWasmInitialized) {
12309 throw new Error("initializeWasm() must be awaited first!");
12311 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_is_ok(o);
12312 return nativeResponseValue;
12314 // void CResult_SharedSecretNoneZ_free(struct LDKCResult_SharedSecretNoneZ _res);
12316 export function CResult_SharedSecretNoneZ_free(_res: bigint): void {
12317 if(!isWasmInitialized) {
12318 throw new Error("initializeWasm() must be awaited first!");
12320 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_free(_res);
12321 // debug statements here
12323 // uint64_t CResult_SharedSecretNoneZ_clone_ptr(LDKCResult_SharedSecretNoneZ *NONNULL_PTR arg);
12325 export function CResult_SharedSecretNoneZ_clone_ptr(arg: bigint): bigint {
12326 if(!isWasmInitialized) {
12327 throw new Error("initializeWasm() must be awaited first!");
12329 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_clone_ptr(arg);
12330 return nativeResponseValue;
12332 // struct LDKCResult_SharedSecretNoneZ CResult_SharedSecretNoneZ_clone(const struct LDKCResult_SharedSecretNoneZ *NONNULL_PTR orig);
12334 export function CResult_SharedSecretNoneZ_clone(orig: bigint): bigint {
12335 if(!isWasmInitialized) {
12336 throw new Error("initializeWasm() must be awaited first!");
12338 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_clone(orig);
12339 return nativeResponseValue;
12341 // void CVec_U5Z_free(struct LDKCVec_U5Z _res);
12343 export function CVec_U5Z_free(_res: number): void {
12344 if(!isWasmInitialized) {
12345 throw new Error("initializeWasm() must be awaited first!");
12347 const nativeResponseValue = wasm.TS_CVec_U5Z_free(_res);
12348 // debug statements here
12350 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_ok(struct LDKRecoverableSignature o);
12352 export function CResult_RecoverableSignatureNoneZ_ok(o: number): bigint {
12353 if(!isWasmInitialized) {
12354 throw new Error("initializeWasm() must be awaited first!");
12356 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_ok(o);
12357 return nativeResponseValue;
12359 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_err(void);
12361 export function CResult_RecoverableSignatureNoneZ_err(): bigint {
12362 if(!isWasmInitialized) {
12363 throw new Error("initializeWasm() must be awaited first!");
12365 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_err();
12366 return nativeResponseValue;
12368 // bool CResult_RecoverableSignatureNoneZ_is_ok(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR o);
12370 export function CResult_RecoverableSignatureNoneZ_is_ok(o: bigint): boolean {
12371 if(!isWasmInitialized) {
12372 throw new Error("initializeWasm() must be awaited first!");
12374 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_is_ok(o);
12375 return nativeResponseValue;
12377 // void CResult_RecoverableSignatureNoneZ_free(struct LDKCResult_RecoverableSignatureNoneZ _res);
12379 export function CResult_RecoverableSignatureNoneZ_free(_res: bigint): void {
12380 if(!isWasmInitialized) {
12381 throw new Error("initializeWasm() must be awaited first!");
12383 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_free(_res);
12384 // debug statements here
12386 // uint64_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg);
12388 export function CResult_RecoverableSignatureNoneZ_clone_ptr(arg: bigint): bigint {
12389 if(!isWasmInitialized) {
12390 throw new Error("initializeWasm() must be awaited first!");
12392 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone_ptr(arg);
12393 return nativeResponseValue;
12395 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_clone(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR orig);
12397 export function CResult_RecoverableSignatureNoneZ_clone(orig: bigint): bigint {
12398 if(!isWasmInitialized) {
12399 throw new Error("initializeWasm() must be awaited first!");
12401 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone(orig);
12402 return nativeResponseValue;
12404 // struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(struct LDKWriteableEcdsaChannelSigner o);
12406 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(o: bigint): bigint {
12407 if(!isWasmInitialized) {
12408 throw new Error("initializeWasm() must be awaited first!");
12410 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(o);
12411 return nativeResponseValue;
12413 // struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(struct LDKDecodeError e);
12415 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(e: bigint): bigint {
12416 if(!isWasmInitialized) {
12417 throw new Error("initializeWasm() must be awaited first!");
12419 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(e);
12420 return nativeResponseValue;
12422 // bool CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(const struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR o);
12424 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(o: bigint): boolean {
12425 if(!isWasmInitialized) {
12426 throw new Error("initializeWasm() must be awaited first!");
12428 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(o);
12429 return nativeResponseValue;
12431 // void CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ _res);
12433 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(_res: bigint): void {
12434 if(!isWasmInitialized) {
12435 throw new Error("initializeWasm() must be awaited first!");
12437 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(_res);
12438 // debug statements here
12440 // uint64_t CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR arg);
12442 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12443 if(!isWasmInitialized) {
12444 throw new Error("initializeWasm() must be awaited first!");
12446 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(arg);
12447 return nativeResponseValue;
12449 // struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(const struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR orig);
12451 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(orig: bigint): bigint {
12452 if(!isWasmInitialized) {
12453 throw new Error("initializeWasm() must be awaited first!");
12455 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(orig);
12456 return nativeResponseValue;
12458 // void CVec_u8Z_free(struct LDKCVec_u8Z _res);
12460 export function CVec_u8Z_free(_res: number): void {
12461 if(!isWasmInitialized) {
12462 throw new Error("initializeWasm() must be awaited first!");
12464 const nativeResponseValue = wasm.TS_CVec_u8Z_free(_res);
12465 // debug statements here
12467 // void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
12469 export function CVec_CVec_u8ZZ_free(_res: number): void {
12470 if(!isWasmInitialized) {
12471 throw new Error("initializeWasm() must be awaited first!");
12473 const nativeResponseValue = wasm.TS_CVec_CVec_u8ZZ_free(_res);
12474 // debug statements here
12476 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_ok(struct LDKCVec_CVec_u8ZZ o);
12478 export function CResult_CVec_CVec_u8ZZNoneZ_ok(o: number): bigint {
12479 if(!isWasmInitialized) {
12480 throw new Error("initializeWasm() must be awaited first!");
12482 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_ok(o);
12483 return nativeResponseValue;
12485 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
12487 export function CResult_CVec_CVec_u8ZZNoneZ_err(): bigint {
12488 if(!isWasmInitialized) {
12489 throw new Error("initializeWasm() must be awaited first!");
12491 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_err();
12492 return nativeResponseValue;
12494 // bool CResult_CVec_CVec_u8ZZNoneZ_is_ok(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR o);
12496 export function CResult_CVec_CVec_u8ZZNoneZ_is_ok(o: bigint): boolean {
12497 if(!isWasmInitialized) {
12498 throw new Error("initializeWasm() must be awaited first!");
12500 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(o);
12501 return nativeResponseValue;
12503 // void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
12505 export function CResult_CVec_CVec_u8ZZNoneZ_free(_res: bigint): void {
12506 if(!isWasmInitialized) {
12507 throw new Error("initializeWasm() must be awaited first!");
12509 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_free(_res);
12510 // debug statements here
12512 // uint64_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg);
12514 export function CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg: bigint): bigint {
12515 if(!isWasmInitialized) {
12516 throw new Error("initializeWasm() must be awaited first!");
12518 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg);
12519 return nativeResponseValue;
12521 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
12523 export function CResult_CVec_CVec_u8ZZNoneZ_clone(orig: bigint): bigint {
12524 if(!isWasmInitialized) {
12525 throw new Error("initializeWasm() must be awaited first!");
12527 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone(orig);
12528 return nativeResponseValue;
12530 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
12532 export function CResult_InMemorySignerDecodeErrorZ_ok(o: bigint): bigint {
12533 if(!isWasmInitialized) {
12534 throw new Error("initializeWasm() must be awaited first!");
12536 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_ok(o);
12537 return nativeResponseValue;
12539 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
12541 export function CResult_InMemorySignerDecodeErrorZ_err(e: bigint): bigint {
12542 if(!isWasmInitialized) {
12543 throw new Error("initializeWasm() must be awaited first!");
12545 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_err(e);
12546 return nativeResponseValue;
12548 // bool CResult_InMemorySignerDecodeErrorZ_is_ok(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR o);
12550 export function CResult_InMemorySignerDecodeErrorZ_is_ok(o: bigint): boolean {
12551 if(!isWasmInitialized) {
12552 throw new Error("initializeWasm() must be awaited first!");
12554 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_is_ok(o);
12555 return nativeResponseValue;
12557 // void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
12559 export function CResult_InMemorySignerDecodeErrorZ_free(_res: bigint): void {
12560 if(!isWasmInitialized) {
12561 throw new Error("initializeWasm() must be awaited first!");
12563 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_free(_res);
12564 // debug statements here
12566 // uint64_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg);
12568 export function CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12569 if(!isWasmInitialized) {
12570 throw new Error("initializeWasm() must be awaited first!");
12572 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg);
12573 return nativeResponseValue;
12575 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
12577 export function CResult_InMemorySignerDecodeErrorZ_clone(orig: bigint): bigint {
12578 if(!isWasmInitialized) {
12579 throw new Error("initializeWasm() must be awaited first!");
12581 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone(orig);
12582 return nativeResponseValue;
12584 // void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
12586 export function CVec_TxOutZ_free(_res: number): void {
12587 if(!isWasmInitialized) {
12588 throw new Error("initializeWasm() must be awaited first!");
12590 const nativeResponseValue = wasm.TS_CVec_TxOutZ_free(_res);
12591 // debug statements here
12593 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
12595 export function CResult_TransactionNoneZ_ok(o: number): bigint {
12596 if(!isWasmInitialized) {
12597 throw new Error("initializeWasm() must be awaited first!");
12599 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_ok(o);
12600 return nativeResponseValue;
12602 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
12604 export function CResult_TransactionNoneZ_err(): bigint {
12605 if(!isWasmInitialized) {
12606 throw new Error("initializeWasm() must be awaited first!");
12608 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_err();
12609 return nativeResponseValue;
12611 // bool CResult_TransactionNoneZ_is_ok(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR o);
12613 export function CResult_TransactionNoneZ_is_ok(o: bigint): boolean {
12614 if(!isWasmInitialized) {
12615 throw new Error("initializeWasm() must be awaited first!");
12617 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_is_ok(o);
12618 return nativeResponseValue;
12620 // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
12622 export function CResult_TransactionNoneZ_free(_res: bigint): void {
12623 if(!isWasmInitialized) {
12624 throw new Error("initializeWasm() must be awaited first!");
12626 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_free(_res);
12627 // debug statements here
12629 // uint64_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg);
12631 export function CResult_TransactionNoneZ_clone_ptr(arg: bigint): bigint {
12632 if(!isWasmInitialized) {
12633 throw new Error("initializeWasm() must be awaited first!");
12635 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone_ptr(arg);
12636 return nativeResponseValue;
12638 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_clone(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR orig);
12640 export function CResult_TransactionNoneZ_clone(orig: bigint): bigint {
12641 if(!isWasmInitialized) {
12642 throw new Error("initializeWasm() must be awaited first!");
12644 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone(orig);
12645 return nativeResponseValue;
12647 // struct LDKCOption_u16Z COption_u16Z_some(uint16_t o);
12649 export function COption_u16Z_some(o: number): bigint {
12650 if(!isWasmInitialized) {
12651 throw new Error("initializeWasm() must be awaited first!");
12653 const nativeResponseValue = wasm.TS_COption_u16Z_some(o);
12654 return nativeResponseValue;
12656 // struct LDKCOption_u16Z COption_u16Z_none(void);
12658 export function COption_u16Z_none(): bigint {
12659 if(!isWasmInitialized) {
12660 throw new Error("initializeWasm() must be awaited first!");
12662 const nativeResponseValue = wasm.TS_COption_u16Z_none();
12663 return nativeResponseValue;
12665 // void COption_u16Z_free(struct LDKCOption_u16Z _res);
12667 export function COption_u16Z_free(_res: bigint): void {
12668 if(!isWasmInitialized) {
12669 throw new Error("initializeWasm() must be awaited first!");
12671 const nativeResponseValue = wasm.TS_COption_u16Z_free(_res);
12672 // debug statements here
12674 // uint64_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg);
12676 export function COption_u16Z_clone_ptr(arg: bigint): bigint {
12677 if(!isWasmInitialized) {
12678 throw new Error("initializeWasm() must be awaited first!");
12680 const nativeResponseValue = wasm.TS_COption_u16Z_clone_ptr(arg);
12681 return nativeResponseValue;
12683 // struct LDKCOption_u16Z COption_u16Z_clone(const struct LDKCOption_u16Z *NONNULL_PTR orig);
12685 export function COption_u16Z_clone(orig: bigint): bigint {
12686 if(!isWasmInitialized) {
12687 throw new Error("initializeWasm() must be awaited first!");
12689 const nativeResponseValue = wasm.TS_COption_u16Z_clone(orig);
12690 return nativeResponseValue;
12692 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_ok(struct LDKThirtyTwoBytes o);
12694 export function CResult__u832APIErrorZ_ok(o: number): bigint {
12695 if(!isWasmInitialized) {
12696 throw new Error("initializeWasm() must be awaited first!");
12698 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_ok(o);
12699 return nativeResponseValue;
12701 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_err(struct LDKAPIError e);
12703 export function CResult__u832APIErrorZ_err(e: bigint): bigint {
12704 if(!isWasmInitialized) {
12705 throw new Error("initializeWasm() must be awaited first!");
12707 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_err(e);
12708 return nativeResponseValue;
12710 // bool CResult__u832APIErrorZ_is_ok(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR o);
12712 export function CResult__u832APIErrorZ_is_ok(o: bigint): boolean {
12713 if(!isWasmInitialized) {
12714 throw new Error("initializeWasm() must be awaited first!");
12716 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_is_ok(o);
12717 return nativeResponseValue;
12719 // void CResult__u832APIErrorZ_free(struct LDKCResult__u832APIErrorZ _res);
12721 export function CResult__u832APIErrorZ_free(_res: bigint): void {
12722 if(!isWasmInitialized) {
12723 throw new Error("initializeWasm() must be awaited first!");
12725 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_free(_res);
12726 // debug statements here
12728 // uint64_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg);
12730 export function CResult__u832APIErrorZ_clone_ptr(arg: bigint): bigint {
12731 if(!isWasmInitialized) {
12732 throw new Error("initializeWasm() must be awaited first!");
12734 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone_ptr(arg);
12735 return nativeResponseValue;
12737 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_clone(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR orig);
12739 export function CResult__u832APIErrorZ_clone(orig: bigint): bigint {
12740 if(!isWasmInitialized) {
12741 throw new Error("initializeWasm() must be awaited first!");
12743 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone(orig);
12744 return nativeResponseValue;
12746 // void CVec_RecentPaymentDetailsZ_free(struct LDKCVec_RecentPaymentDetailsZ _res);
12748 export function CVec_RecentPaymentDetailsZ_free(_res: number): void {
12749 if(!isWasmInitialized) {
12750 throw new Error("initializeWasm() must be awaited first!");
12752 const nativeResponseValue = wasm.TS_CVec_RecentPaymentDetailsZ_free(_res);
12753 // debug statements here
12755 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
12757 export function CResult_NonePaymentSendFailureZ_ok(): bigint {
12758 if(!isWasmInitialized) {
12759 throw new Error("initializeWasm() must be awaited first!");
12761 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_ok();
12762 return nativeResponseValue;
12764 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
12766 export function CResult_NonePaymentSendFailureZ_err(e: bigint): bigint {
12767 if(!isWasmInitialized) {
12768 throw new Error("initializeWasm() must be awaited first!");
12770 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_err(e);
12771 return nativeResponseValue;
12773 // bool CResult_NonePaymentSendFailureZ_is_ok(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR o);
12775 export function CResult_NonePaymentSendFailureZ_is_ok(o: bigint): boolean {
12776 if(!isWasmInitialized) {
12777 throw new Error("initializeWasm() must be awaited first!");
12779 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_is_ok(o);
12780 return nativeResponseValue;
12782 // void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
12784 export function CResult_NonePaymentSendFailureZ_free(_res: bigint): void {
12785 if(!isWasmInitialized) {
12786 throw new Error("initializeWasm() must be awaited first!");
12788 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_free(_res);
12789 // debug statements here
12791 // uint64_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg);
12793 export function CResult_NonePaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
12794 if(!isWasmInitialized) {
12795 throw new Error("initializeWasm() must be awaited first!");
12797 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone_ptr(arg);
12798 return nativeResponseValue;
12800 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
12802 export function CResult_NonePaymentSendFailureZ_clone(orig: bigint): bigint {
12803 if(!isWasmInitialized) {
12804 throw new Error("initializeWasm() must be awaited first!");
12806 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone(orig);
12807 return nativeResponseValue;
12809 // struct LDKCResult_NoneRetryableSendFailureZ CResult_NoneRetryableSendFailureZ_ok(void);
12811 export function CResult_NoneRetryableSendFailureZ_ok(): bigint {
12812 if(!isWasmInitialized) {
12813 throw new Error("initializeWasm() must be awaited first!");
12815 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_ok();
12816 return nativeResponseValue;
12818 // struct LDKCResult_NoneRetryableSendFailureZ CResult_NoneRetryableSendFailureZ_err(enum LDKRetryableSendFailure e);
12820 export function CResult_NoneRetryableSendFailureZ_err(e: RetryableSendFailure): bigint {
12821 if(!isWasmInitialized) {
12822 throw new Error("initializeWasm() must be awaited first!");
12824 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_err(e);
12825 return nativeResponseValue;
12827 // bool CResult_NoneRetryableSendFailureZ_is_ok(const struct LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR o);
12829 export function CResult_NoneRetryableSendFailureZ_is_ok(o: bigint): boolean {
12830 if(!isWasmInitialized) {
12831 throw new Error("initializeWasm() must be awaited first!");
12833 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_is_ok(o);
12834 return nativeResponseValue;
12836 // void CResult_NoneRetryableSendFailureZ_free(struct LDKCResult_NoneRetryableSendFailureZ _res);
12838 export function CResult_NoneRetryableSendFailureZ_free(_res: bigint): void {
12839 if(!isWasmInitialized) {
12840 throw new Error("initializeWasm() must be awaited first!");
12842 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_free(_res);
12843 // debug statements here
12845 // uint64_t CResult_NoneRetryableSendFailureZ_clone_ptr(LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR arg);
12847 export function CResult_NoneRetryableSendFailureZ_clone_ptr(arg: bigint): bigint {
12848 if(!isWasmInitialized) {
12849 throw new Error("initializeWasm() must be awaited first!");
12851 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_clone_ptr(arg);
12852 return nativeResponseValue;
12854 // struct LDKCResult_NoneRetryableSendFailureZ CResult_NoneRetryableSendFailureZ_clone(const struct LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR orig);
12856 export function CResult_NoneRetryableSendFailureZ_clone(orig: bigint): bigint {
12857 if(!isWasmInitialized) {
12858 throw new Error("initializeWasm() must be awaited first!");
12860 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_clone(orig);
12861 return nativeResponseValue;
12863 // struct LDKCResult_PaymentHashPaymentSendFailureZ CResult_PaymentHashPaymentSendFailureZ_ok(struct LDKThirtyTwoBytes o);
12865 export function CResult_PaymentHashPaymentSendFailureZ_ok(o: number): bigint {
12866 if(!isWasmInitialized) {
12867 throw new Error("initializeWasm() must be awaited first!");
12869 const nativeResponseValue = wasm.TS_CResult_PaymentHashPaymentSendFailureZ_ok(o);
12870 return nativeResponseValue;
12872 // struct LDKCResult_PaymentHashPaymentSendFailureZ CResult_PaymentHashPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
12874 export function CResult_PaymentHashPaymentSendFailureZ_err(e: bigint): bigint {
12875 if(!isWasmInitialized) {
12876 throw new Error("initializeWasm() must be awaited first!");
12878 const nativeResponseValue = wasm.TS_CResult_PaymentHashPaymentSendFailureZ_err(e);
12879 return nativeResponseValue;
12881 // bool CResult_PaymentHashPaymentSendFailureZ_is_ok(const struct LDKCResult_PaymentHashPaymentSendFailureZ *NONNULL_PTR o);
12883 export function CResult_PaymentHashPaymentSendFailureZ_is_ok(o: bigint): boolean {
12884 if(!isWasmInitialized) {
12885 throw new Error("initializeWasm() must be awaited first!");
12887 const nativeResponseValue = wasm.TS_CResult_PaymentHashPaymentSendFailureZ_is_ok(o);
12888 return nativeResponseValue;
12890 // void CResult_PaymentHashPaymentSendFailureZ_free(struct LDKCResult_PaymentHashPaymentSendFailureZ _res);
12892 export function CResult_PaymentHashPaymentSendFailureZ_free(_res: bigint): void {
12893 if(!isWasmInitialized) {
12894 throw new Error("initializeWasm() must be awaited first!");
12896 const nativeResponseValue = wasm.TS_CResult_PaymentHashPaymentSendFailureZ_free(_res);
12897 // debug statements here
12899 // uint64_t CResult_PaymentHashPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentHashPaymentSendFailureZ *NONNULL_PTR arg);
12901 export function CResult_PaymentHashPaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
12902 if(!isWasmInitialized) {
12903 throw new Error("initializeWasm() must be awaited first!");
12905 const nativeResponseValue = wasm.TS_CResult_PaymentHashPaymentSendFailureZ_clone_ptr(arg);
12906 return nativeResponseValue;
12908 // struct LDKCResult_PaymentHashPaymentSendFailureZ CResult_PaymentHashPaymentSendFailureZ_clone(const struct LDKCResult_PaymentHashPaymentSendFailureZ *NONNULL_PTR orig);
12910 export function CResult_PaymentHashPaymentSendFailureZ_clone(orig: bigint): bigint {
12911 if(!isWasmInitialized) {
12912 throw new Error("initializeWasm() must be awaited first!");
12914 const nativeResponseValue = wasm.TS_CResult_PaymentHashPaymentSendFailureZ_clone(orig);
12915 return nativeResponseValue;
12917 // struct LDKCResult_PaymentHashRetryableSendFailureZ CResult_PaymentHashRetryableSendFailureZ_ok(struct LDKThirtyTwoBytes o);
12919 export function CResult_PaymentHashRetryableSendFailureZ_ok(o: number): bigint {
12920 if(!isWasmInitialized) {
12921 throw new Error("initializeWasm() must be awaited first!");
12923 const nativeResponseValue = wasm.TS_CResult_PaymentHashRetryableSendFailureZ_ok(o);
12924 return nativeResponseValue;
12926 // struct LDKCResult_PaymentHashRetryableSendFailureZ CResult_PaymentHashRetryableSendFailureZ_err(enum LDKRetryableSendFailure e);
12928 export function CResult_PaymentHashRetryableSendFailureZ_err(e: RetryableSendFailure): bigint {
12929 if(!isWasmInitialized) {
12930 throw new Error("initializeWasm() must be awaited first!");
12932 const nativeResponseValue = wasm.TS_CResult_PaymentHashRetryableSendFailureZ_err(e);
12933 return nativeResponseValue;
12935 // bool CResult_PaymentHashRetryableSendFailureZ_is_ok(const struct LDKCResult_PaymentHashRetryableSendFailureZ *NONNULL_PTR o);
12937 export function CResult_PaymentHashRetryableSendFailureZ_is_ok(o: bigint): boolean {
12938 if(!isWasmInitialized) {
12939 throw new Error("initializeWasm() must be awaited first!");
12941 const nativeResponseValue = wasm.TS_CResult_PaymentHashRetryableSendFailureZ_is_ok(o);
12942 return nativeResponseValue;
12944 // void CResult_PaymentHashRetryableSendFailureZ_free(struct LDKCResult_PaymentHashRetryableSendFailureZ _res);
12946 export function CResult_PaymentHashRetryableSendFailureZ_free(_res: bigint): void {
12947 if(!isWasmInitialized) {
12948 throw new Error("initializeWasm() must be awaited first!");
12950 const nativeResponseValue = wasm.TS_CResult_PaymentHashRetryableSendFailureZ_free(_res);
12951 // debug statements here
12953 // uint64_t CResult_PaymentHashRetryableSendFailureZ_clone_ptr(LDKCResult_PaymentHashRetryableSendFailureZ *NONNULL_PTR arg);
12955 export function CResult_PaymentHashRetryableSendFailureZ_clone_ptr(arg: bigint): bigint {
12956 if(!isWasmInitialized) {
12957 throw new Error("initializeWasm() must be awaited first!");
12959 const nativeResponseValue = wasm.TS_CResult_PaymentHashRetryableSendFailureZ_clone_ptr(arg);
12960 return nativeResponseValue;
12962 // struct LDKCResult_PaymentHashRetryableSendFailureZ CResult_PaymentHashRetryableSendFailureZ_clone(const struct LDKCResult_PaymentHashRetryableSendFailureZ *NONNULL_PTR orig);
12964 export function CResult_PaymentHashRetryableSendFailureZ_clone(orig: bigint): bigint {
12965 if(!isWasmInitialized) {
12966 throw new Error("initializeWasm() must be awaited first!");
12968 const nativeResponseValue = wasm.TS_CResult_PaymentHashRetryableSendFailureZ_clone(orig);
12969 return nativeResponseValue;
12971 // uint64_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg);
12973 export function C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg: bigint): bigint {
12974 if(!isWasmInitialized) {
12975 throw new Error("initializeWasm() must be awaited first!");
12977 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg);
12978 return nativeResponseValue;
12980 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_clone(const struct LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR orig);
12982 export function C2Tuple_PaymentHashPaymentIdZ_clone(orig: bigint): bigint {
12983 if(!isWasmInitialized) {
12984 throw new Error("initializeWasm() must be awaited first!");
12986 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone(orig);
12987 return nativeResponseValue;
12989 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
12991 export function C2Tuple_PaymentHashPaymentIdZ_new(a: number, b: number): bigint {
12992 if(!isWasmInitialized) {
12993 throw new Error("initializeWasm() must be awaited first!");
12995 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_new(a, b);
12996 return nativeResponseValue;
12998 // void C2Tuple_PaymentHashPaymentIdZ_free(struct LDKC2Tuple_PaymentHashPaymentIdZ _res);
13000 export function C2Tuple_PaymentHashPaymentIdZ_free(_res: bigint): void {
13001 if(!isWasmInitialized) {
13002 throw new Error("initializeWasm() must be awaited first!");
13004 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_free(_res);
13005 // debug statements here
13007 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(struct LDKC2Tuple_PaymentHashPaymentIdZ o);
13009 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o: bigint): bigint {
13010 if(!isWasmInitialized) {
13011 throw new Error("initializeWasm() must be awaited first!");
13013 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o);
13014 return nativeResponseValue;
13016 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
13018 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e: bigint): bigint {
13019 if(!isWasmInitialized) {
13020 throw new Error("initializeWasm() must be awaited first!");
13022 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e);
13023 return nativeResponseValue;
13025 // bool CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR o);
13027 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o: bigint): boolean {
13028 if(!isWasmInitialized) {
13029 throw new Error("initializeWasm() must be awaited first!");
13031 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o);
13032 return nativeResponseValue;
13034 // void CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ _res);
13036 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res: bigint): void {
13037 if(!isWasmInitialized) {
13038 throw new Error("initializeWasm() must be awaited first!");
13040 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res);
13041 // debug statements here
13043 // uint64_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg);
13045 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
13046 if(!isWasmInitialized) {
13047 throw new Error("initializeWasm() must be awaited first!");
13049 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg);
13050 return nativeResponseValue;
13052 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR orig);
13054 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig: bigint): bigint {
13055 if(!isWasmInitialized) {
13056 throw new Error("initializeWasm() must be awaited first!");
13058 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig);
13059 return nativeResponseValue;
13061 // void CVec_ThirtyTwoBytesZ_free(struct LDKCVec_ThirtyTwoBytesZ _res);
13063 export function CVec_ThirtyTwoBytesZ_free(_res: number): void {
13064 if(!isWasmInitialized) {
13065 throw new Error("initializeWasm() must be awaited first!");
13067 const nativeResponseValue = wasm.TS_CVec_ThirtyTwoBytesZ_free(_res);
13068 // debug statements here
13070 // uint64_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg);
13072 export function C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg: bigint): bigint {
13073 if(!isWasmInitialized) {
13074 throw new Error("initializeWasm() must be awaited first!");
13076 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg);
13077 return nativeResponseValue;
13079 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_clone(const struct LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR orig);
13081 export function C2Tuple_PaymentHashPaymentSecretZ_clone(orig: bigint): bigint {
13082 if(!isWasmInitialized) {
13083 throw new Error("initializeWasm() must be awaited first!");
13085 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone(orig);
13086 return nativeResponseValue;
13088 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
13090 export function C2Tuple_PaymentHashPaymentSecretZ_new(a: number, b: number): bigint {
13091 if(!isWasmInitialized) {
13092 throw new Error("initializeWasm() must be awaited first!");
13094 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_new(a, b);
13095 return nativeResponseValue;
13097 // void C2Tuple_PaymentHashPaymentSecretZ_free(struct LDKC2Tuple_PaymentHashPaymentSecretZ _res);
13099 export function C2Tuple_PaymentHashPaymentSecretZ_free(_res: bigint): void {
13100 if(!isWasmInitialized) {
13101 throw new Error("initializeWasm() must be awaited first!");
13103 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_free(_res);
13104 // debug statements here
13106 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
13108 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o: bigint): bigint {
13109 if(!isWasmInitialized) {
13110 throw new Error("initializeWasm() must be awaited first!");
13112 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o);
13113 return nativeResponseValue;
13115 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(void);
13117 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(): bigint {
13118 if(!isWasmInitialized) {
13119 throw new Error("initializeWasm() must be awaited first!");
13121 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err();
13122 return nativeResponseValue;
13124 // bool CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR o);
13126 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o: bigint): boolean {
13127 if(!isWasmInitialized) {
13128 throw new Error("initializeWasm() must be awaited first!");
13130 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o);
13131 return nativeResponseValue;
13133 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ _res);
13135 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res: bigint): void {
13136 if(!isWasmInitialized) {
13137 throw new Error("initializeWasm() must be awaited first!");
13139 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res);
13140 // debug statements here
13142 // uint64_t CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR arg);
13144 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg: bigint): bigint {
13145 if(!isWasmInitialized) {
13146 throw new Error("initializeWasm() must be awaited first!");
13148 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg);
13149 return nativeResponseValue;
13151 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR orig);
13153 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig: bigint): bigint {
13154 if(!isWasmInitialized) {
13155 throw new Error("initializeWasm() must be awaited first!");
13157 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig);
13158 return nativeResponseValue;
13160 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
13162 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o: bigint): bigint {
13163 if(!isWasmInitialized) {
13164 throw new Error("initializeWasm() must be awaited first!");
13166 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o);
13167 return nativeResponseValue;
13169 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(struct LDKAPIError e);
13171 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e: bigint): bigint {
13172 if(!isWasmInitialized) {
13173 throw new Error("initializeWasm() must be awaited first!");
13175 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e);
13176 return nativeResponseValue;
13178 // bool CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR o);
13180 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o: bigint): boolean {
13181 if(!isWasmInitialized) {
13182 throw new Error("initializeWasm() must be awaited first!");
13184 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o);
13185 return nativeResponseValue;
13187 // void CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ _res);
13189 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res: bigint): void {
13190 if(!isWasmInitialized) {
13191 throw new Error("initializeWasm() must be awaited first!");
13193 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res);
13194 // debug statements here
13196 // uint64_t CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR arg);
13198 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg: bigint): bigint {
13199 if(!isWasmInitialized) {
13200 throw new Error("initializeWasm() must be awaited first!");
13202 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg);
13203 return nativeResponseValue;
13205 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR orig);
13207 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig: bigint): bigint {
13208 if(!isWasmInitialized) {
13209 throw new Error("initializeWasm() must be awaited first!");
13211 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig);
13212 return nativeResponseValue;
13214 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_ok(struct LDKThirtyTwoBytes o);
13216 export function CResult_PaymentSecretNoneZ_ok(o: number): bigint {
13217 if(!isWasmInitialized) {
13218 throw new Error("initializeWasm() must be awaited first!");
13220 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_ok(o);
13221 return nativeResponseValue;
13223 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_err(void);
13225 export function CResult_PaymentSecretNoneZ_err(): bigint {
13226 if(!isWasmInitialized) {
13227 throw new Error("initializeWasm() must be awaited first!");
13229 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_err();
13230 return nativeResponseValue;
13232 // bool CResult_PaymentSecretNoneZ_is_ok(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR o);
13234 export function CResult_PaymentSecretNoneZ_is_ok(o: bigint): boolean {
13235 if(!isWasmInitialized) {
13236 throw new Error("initializeWasm() must be awaited first!");
13238 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_is_ok(o);
13239 return nativeResponseValue;
13241 // void CResult_PaymentSecretNoneZ_free(struct LDKCResult_PaymentSecretNoneZ _res);
13243 export function CResult_PaymentSecretNoneZ_free(_res: bigint): void {
13244 if(!isWasmInitialized) {
13245 throw new Error("initializeWasm() must be awaited first!");
13247 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_free(_res);
13248 // debug statements here
13250 // uint64_t CResult_PaymentSecretNoneZ_clone_ptr(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR arg);
13252 export function CResult_PaymentSecretNoneZ_clone_ptr(arg: bigint): bigint {
13253 if(!isWasmInitialized) {
13254 throw new Error("initializeWasm() must be awaited first!");
13256 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone_ptr(arg);
13257 return nativeResponseValue;
13259 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_clone(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR orig);
13261 export function CResult_PaymentSecretNoneZ_clone(orig: bigint): bigint {
13262 if(!isWasmInitialized) {
13263 throw new Error("initializeWasm() must be awaited first!");
13265 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone(orig);
13266 return nativeResponseValue;
13268 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
13270 export function CResult_PaymentSecretAPIErrorZ_ok(o: number): bigint {
13271 if(!isWasmInitialized) {
13272 throw new Error("initializeWasm() must be awaited first!");
13274 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_ok(o);
13275 return nativeResponseValue;
13277 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_err(struct LDKAPIError e);
13279 export function CResult_PaymentSecretAPIErrorZ_err(e: bigint): bigint {
13280 if(!isWasmInitialized) {
13281 throw new Error("initializeWasm() must be awaited first!");
13283 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_err(e);
13284 return nativeResponseValue;
13286 // bool CResult_PaymentSecretAPIErrorZ_is_ok(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR o);
13288 export function CResult_PaymentSecretAPIErrorZ_is_ok(o: bigint): boolean {
13289 if(!isWasmInitialized) {
13290 throw new Error("initializeWasm() must be awaited first!");
13292 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_is_ok(o);
13293 return nativeResponseValue;
13295 // void CResult_PaymentSecretAPIErrorZ_free(struct LDKCResult_PaymentSecretAPIErrorZ _res);
13297 export function CResult_PaymentSecretAPIErrorZ_free(_res: bigint): void {
13298 if(!isWasmInitialized) {
13299 throw new Error("initializeWasm() must be awaited first!");
13301 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_free(_res);
13302 // debug statements here
13304 // uint64_t CResult_PaymentSecretAPIErrorZ_clone_ptr(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR arg);
13306 export function CResult_PaymentSecretAPIErrorZ_clone_ptr(arg: bigint): bigint {
13307 if(!isWasmInitialized) {
13308 throw new Error("initializeWasm() must be awaited first!");
13310 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone_ptr(arg);
13311 return nativeResponseValue;
13313 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_clone(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR orig);
13315 export function CResult_PaymentSecretAPIErrorZ_clone(orig: bigint): bigint {
13316 if(!isWasmInitialized) {
13317 throw new Error("initializeWasm() must be awaited first!");
13319 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone(orig);
13320 return nativeResponseValue;
13322 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
13324 export function CResult_PaymentPreimageAPIErrorZ_ok(o: number): bigint {
13325 if(!isWasmInitialized) {
13326 throw new Error("initializeWasm() must be awaited first!");
13328 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_ok(o);
13329 return nativeResponseValue;
13331 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_err(struct LDKAPIError e);
13333 export function CResult_PaymentPreimageAPIErrorZ_err(e: bigint): bigint {
13334 if(!isWasmInitialized) {
13335 throw new Error("initializeWasm() must be awaited first!");
13337 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_err(e);
13338 return nativeResponseValue;
13340 // bool CResult_PaymentPreimageAPIErrorZ_is_ok(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR o);
13342 export function CResult_PaymentPreimageAPIErrorZ_is_ok(o: bigint): boolean {
13343 if(!isWasmInitialized) {
13344 throw new Error("initializeWasm() must be awaited first!");
13346 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_is_ok(o);
13347 return nativeResponseValue;
13349 // void CResult_PaymentPreimageAPIErrorZ_free(struct LDKCResult_PaymentPreimageAPIErrorZ _res);
13351 export function CResult_PaymentPreimageAPIErrorZ_free(_res: bigint): void {
13352 if(!isWasmInitialized) {
13353 throw new Error("initializeWasm() must be awaited first!");
13355 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_free(_res);
13356 // debug statements here
13358 // uint64_t CResult_PaymentPreimageAPIErrorZ_clone_ptr(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR arg);
13360 export function CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg: bigint): bigint {
13361 if(!isWasmInitialized) {
13362 throw new Error("initializeWasm() must be awaited first!");
13364 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg);
13365 return nativeResponseValue;
13367 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_clone(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR orig);
13369 export function CResult_PaymentPreimageAPIErrorZ_clone(orig: bigint): bigint {
13370 if(!isWasmInitialized) {
13371 throw new Error("initializeWasm() must be awaited first!");
13373 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone(orig);
13374 return nativeResponseValue;
13376 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(struct LDKCounterpartyForwardingInfo o);
13378 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o: bigint): bigint {
13379 if(!isWasmInitialized) {
13380 throw new Error("initializeWasm() must be awaited first!");
13382 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o);
13383 return nativeResponseValue;
13385 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_err(struct LDKDecodeError e);
13387 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e: bigint): bigint {
13388 if(!isWasmInitialized) {
13389 throw new Error("initializeWasm() must be awaited first!");
13391 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e);
13392 return nativeResponseValue;
13394 // bool CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR o);
13396 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o: bigint): boolean {
13397 if(!isWasmInitialized) {
13398 throw new Error("initializeWasm() must be awaited first!");
13400 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o);
13401 return nativeResponseValue;
13403 // void CResult_CounterpartyForwardingInfoDecodeErrorZ_free(struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ _res);
13405 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res: bigint): void {
13406 if(!isWasmInitialized) {
13407 throw new Error("initializeWasm() must be awaited first!");
13409 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res);
13410 // debug statements here
13412 // uint64_t CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR arg);
13414 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13415 if(!isWasmInitialized) {
13416 throw new Error("initializeWasm() must be awaited first!");
13418 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg);
13419 return nativeResponseValue;
13421 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR orig);
13423 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig: bigint): bigint {
13424 if(!isWasmInitialized) {
13425 throw new Error("initializeWasm() must be awaited first!");
13427 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig);
13428 return nativeResponseValue;
13430 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_ok(struct LDKChannelCounterparty o);
13432 export function CResult_ChannelCounterpartyDecodeErrorZ_ok(o: bigint): bigint {
13433 if(!isWasmInitialized) {
13434 throw new Error("initializeWasm() must be awaited first!");
13436 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_ok(o);
13437 return nativeResponseValue;
13439 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_err(struct LDKDecodeError e);
13441 export function CResult_ChannelCounterpartyDecodeErrorZ_err(e: bigint): bigint {
13442 if(!isWasmInitialized) {
13443 throw new Error("initializeWasm() must be awaited first!");
13445 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_err(e);
13446 return nativeResponseValue;
13448 // bool CResult_ChannelCounterpartyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR o);
13450 export function CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o: bigint): boolean {
13451 if(!isWasmInitialized) {
13452 throw new Error("initializeWasm() must be awaited first!");
13454 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o);
13455 return nativeResponseValue;
13457 // void CResult_ChannelCounterpartyDecodeErrorZ_free(struct LDKCResult_ChannelCounterpartyDecodeErrorZ _res);
13459 export function CResult_ChannelCounterpartyDecodeErrorZ_free(_res: bigint): void {
13460 if(!isWasmInitialized) {
13461 throw new Error("initializeWasm() must be awaited first!");
13463 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_free(_res);
13464 // debug statements here
13466 // uint64_t CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR arg);
13468 export function CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13469 if(!isWasmInitialized) {
13470 throw new Error("initializeWasm() must be awaited first!");
13472 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg);
13473 return nativeResponseValue;
13475 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_clone(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR orig);
13477 export function CResult_ChannelCounterpartyDecodeErrorZ_clone(orig: bigint): bigint {
13478 if(!isWasmInitialized) {
13479 throw new Error("initializeWasm() must be awaited first!");
13481 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone(orig);
13482 return nativeResponseValue;
13484 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_ok(struct LDKChannelDetails o);
13486 export function CResult_ChannelDetailsDecodeErrorZ_ok(o: bigint): bigint {
13487 if(!isWasmInitialized) {
13488 throw new Error("initializeWasm() must be awaited first!");
13490 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_ok(o);
13491 return nativeResponseValue;
13493 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_err(struct LDKDecodeError e);
13495 export function CResult_ChannelDetailsDecodeErrorZ_err(e: bigint): bigint {
13496 if(!isWasmInitialized) {
13497 throw new Error("initializeWasm() must be awaited first!");
13499 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_err(e);
13500 return nativeResponseValue;
13502 // bool CResult_ChannelDetailsDecodeErrorZ_is_ok(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR o);
13504 export function CResult_ChannelDetailsDecodeErrorZ_is_ok(o: bigint): boolean {
13505 if(!isWasmInitialized) {
13506 throw new Error("initializeWasm() must be awaited first!");
13508 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_is_ok(o);
13509 return nativeResponseValue;
13511 // void CResult_ChannelDetailsDecodeErrorZ_free(struct LDKCResult_ChannelDetailsDecodeErrorZ _res);
13513 export function CResult_ChannelDetailsDecodeErrorZ_free(_res: bigint): void {
13514 if(!isWasmInitialized) {
13515 throw new Error("initializeWasm() must be awaited first!");
13517 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_free(_res);
13518 // debug statements here
13520 // uint64_t CResult_ChannelDetailsDecodeErrorZ_clone_ptr(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR arg);
13522 export function CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13523 if(!isWasmInitialized) {
13524 throw new Error("initializeWasm() must be awaited first!");
13526 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg);
13527 return nativeResponseValue;
13529 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_clone(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR orig);
13531 export function CResult_ChannelDetailsDecodeErrorZ_clone(orig: bigint): bigint {
13532 if(!isWasmInitialized) {
13533 throw new Error("initializeWasm() must be awaited first!");
13535 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone(orig);
13536 return nativeResponseValue;
13538 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_ok(struct LDKPhantomRouteHints o);
13540 export function CResult_PhantomRouteHintsDecodeErrorZ_ok(o: bigint): bigint {
13541 if(!isWasmInitialized) {
13542 throw new Error("initializeWasm() must be awaited first!");
13544 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_ok(o);
13545 return nativeResponseValue;
13547 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_err(struct LDKDecodeError e);
13549 export function CResult_PhantomRouteHintsDecodeErrorZ_err(e: bigint): bigint {
13550 if(!isWasmInitialized) {
13551 throw new Error("initializeWasm() must be awaited first!");
13553 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_err(e);
13554 return nativeResponseValue;
13556 // bool CResult_PhantomRouteHintsDecodeErrorZ_is_ok(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR o);
13558 export function CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o: bigint): boolean {
13559 if(!isWasmInitialized) {
13560 throw new Error("initializeWasm() must be awaited first!");
13562 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o);
13563 return nativeResponseValue;
13565 // void CResult_PhantomRouteHintsDecodeErrorZ_free(struct LDKCResult_PhantomRouteHintsDecodeErrorZ _res);
13567 export function CResult_PhantomRouteHintsDecodeErrorZ_free(_res: bigint): void {
13568 if(!isWasmInitialized) {
13569 throw new Error("initializeWasm() must be awaited first!");
13571 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_free(_res);
13572 // debug statements here
13574 // uint64_t CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR arg);
13576 export function CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13577 if(!isWasmInitialized) {
13578 throw new Error("initializeWasm() must be awaited first!");
13580 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg);
13581 return nativeResponseValue;
13583 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_clone(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR orig);
13585 export function CResult_PhantomRouteHintsDecodeErrorZ_clone(orig: bigint): bigint {
13586 if(!isWasmInitialized) {
13587 throw new Error("initializeWasm() must be awaited first!");
13589 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone(orig);
13590 return nativeResponseValue;
13592 // void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
13594 export function CVec_ChannelMonitorZ_free(_res: number): void {
13595 if(!isWasmInitialized) {
13596 throw new Error("initializeWasm() must be awaited first!");
13598 const nativeResponseValue = wasm.TS_CVec_ChannelMonitorZ_free(_res);
13599 // debug statements here
13601 // struct LDKC2Tuple_BlockHashChannelManagerZ C2Tuple_BlockHashChannelManagerZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelManager b);
13603 export function C2Tuple_BlockHashChannelManagerZ_new(a: number, b: bigint): bigint {
13604 if(!isWasmInitialized) {
13605 throw new Error("initializeWasm() must be awaited first!");
13607 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_new(a, b);
13608 return nativeResponseValue;
13610 // void C2Tuple_BlockHashChannelManagerZ_free(struct LDKC2Tuple_BlockHashChannelManagerZ _res);
13612 export function C2Tuple_BlockHashChannelManagerZ_free(_res: bigint): void {
13613 if(!isWasmInitialized) {
13614 throw new Error("initializeWasm() must be awaited first!");
13616 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_free(_res);
13617 // debug statements here
13619 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelManagerZ o);
13621 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o: bigint): bigint {
13622 if(!isWasmInitialized) {
13623 throw new Error("initializeWasm() must be awaited first!");
13625 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o);
13626 return nativeResponseValue;
13628 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
13630 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e: bigint): bigint {
13631 if(!isWasmInitialized) {
13632 throw new Error("initializeWasm() must be awaited first!");
13634 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e);
13635 return nativeResponseValue;
13637 // bool CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR o);
13639 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o: bigint): boolean {
13640 if(!isWasmInitialized) {
13641 throw new Error("initializeWasm() must be awaited first!");
13643 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o);
13644 return nativeResponseValue;
13646 // void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res);
13648 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res: bigint): void {
13649 if(!isWasmInitialized) {
13650 throw new Error("initializeWasm() must be awaited first!");
13652 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res);
13653 // debug statements here
13655 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
13657 export function CResult_ChannelConfigDecodeErrorZ_ok(o: bigint): bigint {
13658 if(!isWasmInitialized) {
13659 throw new Error("initializeWasm() must be awaited first!");
13661 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_ok(o);
13662 return nativeResponseValue;
13664 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
13666 export function CResult_ChannelConfigDecodeErrorZ_err(e: bigint): bigint {
13667 if(!isWasmInitialized) {
13668 throw new Error("initializeWasm() must be awaited first!");
13670 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_err(e);
13671 return nativeResponseValue;
13673 // bool CResult_ChannelConfigDecodeErrorZ_is_ok(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR o);
13675 export function CResult_ChannelConfigDecodeErrorZ_is_ok(o: bigint): boolean {
13676 if(!isWasmInitialized) {
13677 throw new Error("initializeWasm() must be awaited first!");
13679 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_is_ok(o);
13680 return nativeResponseValue;
13682 // void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
13684 export function CResult_ChannelConfigDecodeErrorZ_free(_res: bigint): void {
13685 if(!isWasmInitialized) {
13686 throw new Error("initializeWasm() must be awaited first!");
13688 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_free(_res);
13689 // debug statements here
13691 // uint64_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg);
13693 export function CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13694 if(!isWasmInitialized) {
13695 throw new Error("initializeWasm() must be awaited first!");
13697 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg);
13698 return nativeResponseValue;
13700 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
13702 export function CResult_ChannelConfigDecodeErrorZ_clone(orig: bigint): bigint {
13703 if(!isWasmInitialized) {
13704 throw new Error("initializeWasm() must be awaited first!");
13706 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone(orig);
13707 return nativeResponseValue;
13709 // struct LDKCOption_APIErrorZ COption_APIErrorZ_some(struct LDKAPIError o);
13711 export function COption_APIErrorZ_some(o: bigint): bigint {
13712 if(!isWasmInitialized) {
13713 throw new Error("initializeWasm() must be awaited first!");
13715 const nativeResponseValue = wasm.TS_COption_APIErrorZ_some(o);
13716 return nativeResponseValue;
13718 // struct LDKCOption_APIErrorZ COption_APIErrorZ_none(void);
13720 export function COption_APIErrorZ_none(): bigint {
13721 if(!isWasmInitialized) {
13722 throw new Error("initializeWasm() must be awaited first!");
13724 const nativeResponseValue = wasm.TS_COption_APIErrorZ_none();
13725 return nativeResponseValue;
13727 // void COption_APIErrorZ_free(struct LDKCOption_APIErrorZ _res);
13729 export function COption_APIErrorZ_free(_res: bigint): void {
13730 if(!isWasmInitialized) {
13731 throw new Error("initializeWasm() must be awaited first!");
13733 const nativeResponseValue = wasm.TS_COption_APIErrorZ_free(_res);
13734 // debug statements here
13736 // uint64_t COption_APIErrorZ_clone_ptr(LDKCOption_APIErrorZ *NONNULL_PTR arg);
13738 export function COption_APIErrorZ_clone_ptr(arg: bigint): bigint {
13739 if(!isWasmInitialized) {
13740 throw new Error("initializeWasm() must be awaited first!");
13742 const nativeResponseValue = wasm.TS_COption_APIErrorZ_clone_ptr(arg);
13743 return nativeResponseValue;
13745 // struct LDKCOption_APIErrorZ COption_APIErrorZ_clone(const struct LDKCOption_APIErrorZ *NONNULL_PTR orig);
13747 export function COption_APIErrorZ_clone(orig: bigint): bigint {
13748 if(!isWasmInitialized) {
13749 throw new Error("initializeWasm() must be awaited first!");
13751 const nativeResponseValue = wasm.TS_COption_APIErrorZ_clone(orig);
13752 return nativeResponseValue;
13754 // struct LDKCResult_COption_APIErrorZDecodeErrorZ CResult_COption_APIErrorZDecodeErrorZ_ok(struct LDKCOption_APIErrorZ o);
13756 export function CResult_COption_APIErrorZDecodeErrorZ_ok(o: bigint): bigint {
13757 if(!isWasmInitialized) {
13758 throw new Error("initializeWasm() must be awaited first!");
13760 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_ok(o);
13761 return nativeResponseValue;
13763 // struct LDKCResult_COption_APIErrorZDecodeErrorZ CResult_COption_APIErrorZDecodeErrorZ_err(struct LDKDecodeError e);
13765 export function CResult_COption_APIErrorZDecodeErrorZ_err(e: bigint): bigint {
13766 if(!isWasmInitialized) {
13767 throw new Error("initializeWasm() must be awaited first!");
13769 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_err(e);
13770 return nativeResponseValue;
13772 // bool CResult_COption_APIErrorZDecodeErrorZ_is_ok(const struct LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR o);
13774 export function CResult_COption_APIErrorZDecodeErrorZ_is_ok(o: bigint): boolean {
13775 if(!isWasmInitialized) {
13776 throw new Error("initializeWasm() must be awaited first!");
13778 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_is_ok(o);
13779 return nativeResponseValue;
13781 // void CResult_COption_APIErrorZDecodeErrorZ_free(struct LDKCResult_COption_APIErrorZDecodeErrorZ _res);
13783 export function CResult_COption_APIErrorZDecodeErrorZ_free(_res: bigint): void {
13784 if(!isWasmInitialized) {
13785 throw new Error("initializeWasm() must be awaited first!");
13787 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_free(_res);
13788 // debug statements here
13790 // uint64_t CResult_COption_APIErrorZDecodeErrorZ_clone_ptr(LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR arg);
13792 export function CResult_COption_APIErrorZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13793 if(!isWasmInitialized) {
13794 throw new Error("initializeWasm() must be awaited first!");
13796 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_clone_ptr(arg);
13797 return nativeResponseValue;
13799 // struct LDKCResult_COption_APIErrorZDecodeErrorZ CResult_COption_APIErrorZDecodeErrorZ_clone(const struct LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR orig);
13801 export function CResult_COption_APIErrorZDecodeErrorZ_clone(orig: bigint): bigint {
13802 if(!isWasmInitialized) {
13803 throw new Error("initializeWasm() must be awaited first!");
13805 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_clone(orig);
13806 return nativeResponseValue;
13808 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
13810 export function CResult_OutPointDecodeErrorZ_ok(o: bigint): bigint {
13811 if(!isWasmInitialized) {
13812 throw new Error("initializeWasm() must be awaited first!");
13814 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_ok(o);
13815 return nativeResponseValue;
13817 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
13819 export function CResult_OutPointDecodeErrorZ_err(e: bigint): bigint {
13820 if(!isWasmInitialized) {
13821 throw new Error("initializeWasm() must be awaited first!");
13823 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_err(e);
13824 return nativeResponseValue;
13826 // bool CResult_OutPointDecodeErrorZ_is_ok(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR o);
13828 export function CResult_OutPointDecodeErrorZ_is_ok(o: bigint): boolean {
13829 if(!isWasmInitialized) {
13830 throw new Error("initializeWasm() must be awaited first!");
13832 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_is_ok(o);
13833 return nativeResponseValue;
13835 // void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
13837 export function CResult_OutPointDecodeErrorZ_free(_res: bigint): void {
13838 if(!isWasmInitialized) {
13839 throw new Error("initializeWasm() must be awaited first!");
13841 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_free(_res);
13842 // debug statements here
13844 // uint64_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg);
13846 export function CResult_OutPointDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13847 if(!isWasmInitialized) {
13848 throw new Error("initializeWasm() must be awaited first!");
13850 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone_ptr(arg);
13851 return nativeResponseValue;
13853 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
13855 export function CResult_OutPointDecodeErrorZ_clone(orig: bigint): bigint {
13856 if(!isWasmInitialized) {
13857 throw new Error("initializeWasm() must be awaited first!");
13859 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone(orig);
13860 return nativeResponseValue;
13862 // struct LDKCOption_TypeZ COption_TypeZ_some(struct LDKType o);
13864 export function COption_TypeZ_some(o: bigint): bigint {
13865 if(!isWasmInitialized) {
13866 throw new Error("initializeWasm() must be awaited first!");
13868 const nativeResponseValue = wasm.TS_COption_TypeZ_some(o);
13869 return nativeResponseValue;
13871 // struct LDKCOption_TypeZ COption_TypeZ_none(void);
13873 export function COption_TypeZ_none(): bigint {
13874 if(!isWasmInitialized) {
13875 throw new Error("initializeWasm() must be awaited first!");
13877 const nativeResponseValue = wasm.TS_COption_TypeZ_none();
13878 return nativeResponseValue;
13880 // void COption_TypeZ_free(struct LDKCOption_TypeZ _res);
13882 export function COption_TypeZ_free(_res: bigint): void {
13883 if(!isWasmInitialized) {
13884 throw new Error("initializeWasm() must be awaited first!");
13886 const nativeResponseValue = wasm.TS_COption_TypeZ_free(_res);
13887 // debug statements here
13889 // uint64_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg);
13891 export function COption_TypeZ_clone_ptr(arg: bigint): bigint {
13892 if(!isWasmInitialized) {
13893 throw new Error("initializeWasm() must be awaited first!");
13895 const nativeResponseValue = wasm.TS_COption_TypeZ_clone_ptr(arg);
13896 return nativeResponseValue;
13898 // struct LDKCOption_TypeZ COption_TypeZ_clone(const struct LDKCOption_TypeZ *NONNULL_PTR orig);
13900 export function COption_TypeZ_clone(orig: bigint): bigint {
13901 if(!isWasmInitialized) {
13902 throw new Error("initializeWasm() must be awaited first!");
13904 const nativeResponseValue = wasm.TS_COption_TypeZ_clone(orig);
13905 return nativeResponseValue;
13907 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_ok(struct LDKCOption_TypeZ o);
13909 export function CResult_COption_TypeZDecodeErrorZ_ok(o: bigint): bigint {
13910 if(!isWasmInitialized) {
13911 throw new Error("initializeWasm() must be awaited first!");
13913 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_ok(o);
13914 return nativeResponseValue;
13916 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_err(struct LDKDecodeError e);
13918 export function CResult_COption_TypeZDecodeErrorZ_err(e: bigint): bigint {
13919 if(!isWasmInitialized) {
13920 throw new Error("initializeWasm() must be awaited first!");
13922 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_err(e);
13923 return nativeResponseValue;
13925 // bool CResult_COption_TypeZDecodeErrorZ_is_ok(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR o);
13927 export function CResult_COption_TypeZDecodeErrorZ_is_ok(o: bigint): boolean {
13928 if(!isWasmInitialized) {
13929 throw new Error("initializeWasm() must be awaited first!");
13931 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_is_ok(o);
13932 return nativeResponseValue;
13934 // void CResult_COption_TypeZDecodeErrorZ_free(struct LDKCResult_COption_TypeZDecodeErrorZ _res);
13936 export function CResult_COption_TypeZDecodeErrorZ_free(_res: bigint): void {
13937 if(!isWasmInitialized) {
13938 throw new Error("initializeWasm() must be awaited first!");
13940 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_free(_res);
13941 // debug statements here
13943 // uint64_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg);
13945 export function CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13946 if(!isWasmInitialized) {
13947 throw new Error("initializeWasm() must be awaited first!");
13949 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg);
13950 return nativeResponseValue;
13952 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_clone(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR orig);
13954 export function CResult_COption_TypeZDecodeErrorZ_clone(orig: bigint): bigint {
13955 if(!isWasmInitialized) {
13956 throw new Error("initializeWasm() must be awaited first!");
13958 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone(orig);
13959 return nativeResponseValue;
13961 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_ok(struct LDKThirtyTwoBytes o);
13963 export function CResult_PaymentIdPaymentErrorZ_ok(o: number): bigint {
13964 if(!isWasmInitialized) {
13965 throw new Error("initializeWasm() must be awaited first!");
13967 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_ok(o);
13968 return nativeResponseValue;
13970 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_err(struct LDKPaymentError e);
13972 export function CResult_PaymentIdPaymentErrorZ_err(e: bigint): bigint {
13973 if(!isWasmInitialized) {
13974 throw new Error("initializeWasm() must be awaited first!");
13976 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_err(e);
13977 return nativeResponseValue;
13979 // bool CResult_PaymentIdPaymentErrorZ_is_ok(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR o);
13981 export function CResult_PaymentIdPaymentErrorZ_is_ok(o: bigint): boolean {
13982 if(!isWasmInitialized) {
13983 throw new Error("initializeWasm() must be awaited first!");
13985 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_is_ok(o);
13986 return nativeResponseValue;
13988 // void CResult_PaymentIdPaymentErrorZ_free(struct LDKCResult_PaymentIdPaymentErrorZ _res);
13990 export function CResult_PaymentIdPaymentErrorZ_free(_res: bigint): void {
13991 if(!isWasmInitialized) {
13992 throw new Error("initializeWasm() must be awaited first!");
13994 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_free(_res);
13995 // debug statements here
13997 // uint64_t CResult_PaymentIdPaymentErrorZ_clone_ptr(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR arg);
13999 export function CResult_PaymentIdPaymentErrorZ_clone_ptr(arg: bigint): bigint {
14000 if(!isWasmInitialized) {
14001 throw new Error("initializeWasm() must be awaited first!");
14003 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone_ptr(arg);
14004 return nativeResponseValue;
14006 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_clone(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR orig);
14008 export function CResult_PaymentIdPaymentErrorZ_clone(orig: bigint): bigint {
14009 if(!isWasmInitialized) {
14010 throw new Error("initializeWasm() must be awaited first!");
14012 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone(orig);
14013 return nativeResponseValue;
14015 // struct LDKCResult_NonePaymentErrorZ CResult_NonePaymentErrorZ_ok(void);
14017 export function CResult_NonePaymentErrorZ_ok(): bigint {
14018 if(!isWasmInitialized) {
14019 throw new Error("initializeWasm() must be awaited first!");
14021 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_ok();
14022 return nativeResponseValue;
14024 // struct LDKCResult_NonePaymentErrorZ CResult_NonePaymentErrorZ_err(struct LDKPaymentError e);
14026 export function CResult_NonePaymentErrorZ_err(e: bigint): bigint {
14027 if(!isWasmInitialized) {
14028 throw new Error("initializeWasm() must be awaited first!");
14030 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_err(e);
14031 return nativeResponseValue;
14033 // bool CResult_NonePaymentErrorZ_is_ok(const struct LDKCResult_NonePaymentErrorZ *NONNULL_PTR o);
14035 export function CResult_NonePaymentErrorZ_is_ok(o: bigint): boolean {
14036 if(!isWasmInitialized) {
14037 throw new Error("initializeWasm() must be awaited first!");
14039 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_is_ok(o);
14040 return nativeResponseValue;
14042 // void CResult_NonePaymentErrorZ_free(struct LDKCResult_NonePaymentErrorZ _res);
14044 export function CResult_NonePaymentErrorZ_free(_res: bigint): void {
14045 if(!isWasmInitialized) {
14046 throw new Error("initializeWasm() must be awaited first!");
14048 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_free(_res);
14049 // debug statements here
14051 // uint64_t CResult_NonePaymentErrorZ_clone_ptr(LDKCResult_NonePaymentErrorZ *NONNULL_PTR arg);
14053 export function CResult_NonePaymentErrorZ_clone_ptr(arg: bigint): bigint {
14054 if(!isWasmInitialized) {
14055 throw new Error("initializeWasm() must be awaited first!");
14057 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_clone_ptr(arg);
14058 return nativeResponseValue;
14060 // struct LDKCResult_NonePaymentErrorZ CResult_NonePaymentErrorZ_clone(const struct LDKCResult_NonePaymentErrorZ *NONNULL_PTR orig);
14062 export function CResult_NonePaymentErrorZ_clone(orig: bigint): bigint {
14063 if(!isWasmInitialized) {
14064 throw new Error("initializeWasm() must be awaited first!");
14066 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_clone(orig);
14067 return nativeResponseValue;
14069 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_ok(struct LDKStr o);
14071 export function CResult_StringErrorZ_ok(o: number): bigint {
14072 if(!isWasmInitialized) {
14073 throw new Error("initializeWasm() must be awaited first!");
14075 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_ok(o);
14076 return nativeResponseValue;
14078 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_err(enum LDKSecp256k1Error e);
14080 export function CResult_StringErrorZ_err(e: Secp256k1Error): bigint {
14081 if(!isWasmInitialized) {
14082 throw new Error("initializeWasm() must be awaited first!");
14084 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_err(e);
14085 return nativeResponseValue;
14087 // bool CResult_StringErrorZ_is_ok(const struct LDKCResult_StringErrorZ *NONNULL_PTR o);
14089 export function CResult_StringErrorZ_is_ok(o: bigint): boolean {
14090 if(!isWasmInitialized) {
14091 throw new Error("initializeWasm() must be awaited first!");
14093 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_is_ok(o);
14094 return nativeResponseValue;
14096 // void CResult_StringErrorZ_free(struct LDKCResult_StringErrorZ _res);
14098 export function CResult_StringErrorZ_free(_res: bigint): void {
14099 if(!isWasmInitialized) {
14100 throw new Error("initializeWasm() must be awaited first!");
14102 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_free(_res);
14103 // debug statements here
14105 // uint64_t CResult_StringErrorZ_clone_ptr(LDKCResult_StringErrorZ *NONNULL_PTR arg);
14107 export function CResult_StringErrorZ_clone_ptr(arg: bigint): bigint {
14108 if(!isWasmInitialized) {
14109 throw new Error("initializeWasm() must be awaited first!");
14111 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_clone_ptr(arg);
14112 return nativeResponseValue;
14114 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_clone(const struct LDKCResult_StringErrorZ *NONNULL_PTR orig);
14116 export function CResult_StringErrorZ_clone(orig: bigint): bigint {
14117 if(!isWasmInitialized) {
14118 throw new Error("initializeWasm() must be awaited first!");
14120 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_clone(orig);
14121 return nativeResponseValue;
14123 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_ok(struct LDKPublicKey o);
14125 export function CResult_PublicKeyErrorZ_ok(o: number): bigint {
14126 if(!isWasmInitialized) {
14127 throw new Error("initializeWasm() must be awaited first!");
14129 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_ok(o);
14130 return nativeResponseValue;
14132 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_err(enum LDKSecp256k1Error e);
14134 export function CResult_PublicKeyErrorZ_err(e: Secp256k1Error): bigint {
14135 if(!isWasmInitialized) {
14136 throw new Error("initializeWasm() must be awaited first!");
14138 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_err(e);
14139 return nativeResponseValue;
14141 // bool CResult_PublicKeyErrorZ_is_ok(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR o);
14143 export function CResult_PublicKeyErrorZ_is_ok(o: bigint): boolean {
14144 if(!isWasmInitialized) {
14145 throw new Error("initializeWasm() must be awaited first!");
14147 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_is_ok(o);
14148 return nativeResponseValue;
14150 // void CResult_PublicKeyErrorZ_free(struct LDKCResult_PublicKeyErrorZ _res);
14152 export function CResult_PublicKeyErrorZ_free(_res: bigint): void {
14153 if(!isWasmInitialized) {
14154 throw new Error("initializeWasm() must be awaited first!");
14156 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_free(_res);
14157 // debug statements here
14159 // uint64_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg);
14161 export function CResult_PublicKeyErrorZ_clone_ptr(arg: bigint): bigint {
14162 if(!isWasmInitialized) {
14163 throw new Error("initializeWasm() must be awaited first!");
14165 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone_ptr(arg);
14166 return nativeResponseValue;
14168 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_clone(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR orig);
14170 export function CResult_PublicKeyErrorZ_clone(orig: bigint): bigint {
14171 if(!isWasmInitialized) {
14172 throw new Error("initializeWasm() must be awaited first!");
14174 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone(orig);
14175 return nativeResponseValue;
14177 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
14179 export function CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: bigint): bigint {
14180 if(!isWasmInitialized) {
14181 throw new Error("initializeWasm() must be awaited first!");
14183 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o);
14184 return nativeResponseValue;
14186 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
14188 export function CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: bigint): bigint {
14189 if(!isWasmInitialized) {
14190 throw new Error("initializeWasm() must be awaited first!");
14192 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(e);
14193 return nativeResponseValue;
14195 // bool CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR o);
14197 export function CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
14198 if(!isWasmInitialized) {
14199 throw new Error("initializeWasm() must be awaited first!");
14201 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o);
14202 return nativeResponseValue;
14204 // void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
14206 export function CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: bigint): void {
14207 if(!isWasmInitialized) {
14208 throw new Error("initializeWasm() must be awaited first!");
14210 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res);
14211 // debug statements here
14213 // uint64_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg);
14215 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14216 if(!isWasmInitialized) {
14217 throw new Error("initializeWasm() must be awaited first!");
14219 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg);
14220 return nativeResponseValue;
14222 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
14224 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: bigint): bigint {
14225 if(!isWasmInitialized) {
14226 throw new Error("initializeWasm() must be awaited first!");
14228 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig);
14229 return nativeResponseValue;
14231 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_some(struct LDKMonitorEvent o);
14233 export function COption_MonitorEventZ_some(o: bigint): bigint {
14234 if(!isWasmInitialized) {
14235 throw new Error("initializeWasm() must be awaited first!");
14237 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_some(o);
14238 return nativeResponseValue;
14240 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_none(void);
14242 export function COption_MonitorEventZ_none(): bigint {
14243 if(!isWasmInitialized) {
14244 throw new Error("initializeWasm() must be awaited first!");
14246 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_none();
14247 return nativeResponseValue;
14249 // void COption_MonitorEventZ_free(struct LDKCOption_MonitorEventZ _res);
14251 export function COption_MonitorEventZ_free(_res: bigint): void {
14252 if(!isWasmInitialized) {
14253 throw new Error("initializeWasm() must be awaited first!");
14255 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_free(_res);
14256 // debug statements here
14258 // uint64_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg);
14260 export function COption_MonitorEventZ_clone_ptr(arg: bigint): bigint {
14261 if(!isWasmInitialized) {
14262 throw new Error("initializeWasm() must be awaited first!");
14264 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone_ptr(arg);
14265 return nativeResponseValue;
14267 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_clone(const struct LDKCOption_MonitorEventZ *NONNULL_PTR orig);
14269 export function COption_MonitorEventZ_clone(orig: bigint): bigint {
14270 if(!isWasmInitialized) {
14271 throw new Error("initializeWasm() must be awaited first!");
14273 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone(orig);
14274 return nativeResponseValue;
14276 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_ok(struct LDKCOption_MonitorEventZ o);
14278 export function CResult_COption_MonitorEventZDecodeErrorZ_ok(o: bigint): bigint {
14279 if(!isWasmInitialized) {
14280 throw new Error("initializeWasm() must be awaited first!");
14282 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(o);
14283 return nativeResponseValue;
14285 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_err(struct LDKDecodeError e);
14287 export function CResult_COption_MonitorEventZDecodeErrorZ_err(e: bigint): bigint {
14288 if(!isWasmInitialized) {
14289 throw new Error("initializeWasm() must be awaited first!");
14291 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_err(e);
14292 return nativeResponseValue;
14294 // bool CResult_COption_MonitorEventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR o);
14296 export function CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o: bigint): boolean {
14297 if(!isWasmInitialized) {
14298 throw new Error("initializeWasm() must be awaited first!");
14300 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o);
14301 return nativeResponseValue;
14303 // void CResult_COption_MonitorEventZDecodeErrorZ_free(struct LDKCResult_COption_MonitorEventZDecodeErrorZ _res);
14305 export function CResult_COption_MonitorEventZDecodeErrorZ_free(_res: bigint): void {
14306 if(!isWasmInitialized) {
14307 throw new Error("initializeWasm() must be awaited first!");
14309 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_free(_res);
14310 // debug statements here
14312 // uint64_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg);
14314 export function CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14315 if(!isWasmInitialized) {
14316 throw new Error("initializeWasm() must be awaited first!");
14318 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg);
14319 return nativeResponseValue;
14321 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_clone(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR orig);
14323 export function CResult_COption_MonitorEventZDecodeErrorZ_clone(orig: bigint): bigint {
14324 if(!isWasmInitialized) {
14325 throw new Error("initializeWasm() must be awaited first!");
14327 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(orig);
14328 return nativeResponseValue;
14330 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
14332 export function CResult_HTLCUpdateDecodeErrorZ_ok(o: bigint): bigint {
14333 if(!isWasmInitialized) {
14334 throw new Error("initializeWasm() must be awaited first!");
14336 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_ok(o);
14337 return nativeResponseValue;
14339 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
14341 export function CResult_HTLCUpdateDecodeErrorZ_err(e: bigint): bigint {
14342 if(!isWasmInitialized) {
14343 throw new Error("initializeWasm() must be awaited first!");
14345 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_err(e);
14346 return nativeResponseValue;
14348 // bool CResult_HTLCUpdateDecodeErrorZ_is_ok(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR o);
14350 export function CResult_HTLCUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
14351 if(!isWasmInitialized) {
14352 throw new Error("initializeWasm() must be awaited first!");
14354 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(o);
14355 return nativeResponseValue;
14357 // void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
14359 export function CResult_HTLCUpdateDecodeErrorZ_free(_res: bigint): void {
14360 if(!isWasmInitialized) {
14361 throw new Error("initializeWasm() must be awaited first!");
14363 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_free(_res);
14364 // debug statements here
14366 // uint64_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg);
14368 export function CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14369 if(!isWasmInitialized) {
14370 throw new Error("initializeWasm() must be awaited first!");
14372 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg);
14373 return nativeResponseValue;
14375 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
14377 export function CResult_HTLCUpdateDecodeErrorZ_clone(orig: bigint): bigint {
14378 if(!isWasmInitialized) {
14379 throw new Error("initializeWasm() must be awaited first!");
14381 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone(orig);
14382 return nativeResponseValue;
14384 // uint64_t C2Tuple_OutPointScriptZ_clone_ptr(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR arg);
14386 export function C2Tuple_OutPointScriptZ_clone_ptr(arg: bigint): bigint {
14387 if(!isWasmInitialized) {
14388 throw new Error("initializeWasm() must be awaited first!");
14390 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone_ptr(arg);
14391 return nativeResponseValue;
14393 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_clone(const struct LDKC2Tuple_OutPointScriptZ *NONNULL_PTR orig);
14395 export function C2Tuple_OutPointScriptZ_clone(orig: bigint): bigint {
14396 if(!isWasmInitialized) {
14397 throw new Error("initializeWasm() must be awaited first!");
14399 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone(orig);
14400 return nativeResponseValue;
14402 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
14404 export function C2Tuple_OutPointScriptZ_new(a: bigint, b: number): bigint {
14405 if(!isWasmInitialized) {
14406 throw new Error("initializeWasm() must be awaited first!");
14408 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_new(a, b);
14409 return nativeResponseValue;
14411 // void C2Tuple_OutPointScriptZ_free(struct LDKC2Tuple_OutPointScriptZ _res);
14413 export function C2Tuple_OutPointScriptZ_free(_res: bigint): void {
14414 if(!isWasmInitialized) {
14415 throw new Error("initializeWasm() must be awaited first!");
14417 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_free(_res);
14418 // debug statements here
14420 // uint64_t C2Tuple_u32ScriptZ_clone_ptr(LDKC2Tuple_u32ScriptZ *NONNULL_PTR arg);
14422 export function C2Tuple_u32ScriptZ_clone_ptr(arg: bigint): bigint {
14423 if(!isWasmInitialized) {
14424 throw new Error("initializeWasm() must be awaited first!");
14426 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone_ptr(arg);
14427 return nativeResponseValue;
14429 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_clone(const struct LDKC2Tuple_u32ScriptZ *NONNULL_PTR orig);
14431 export function C2Tuple_u32ScriptZ_clone(orig: bigint): bigint {
14432 if(!isWasmInitialized) {
14433 throw new Error("initializeWasm() must be awaited first!");
14435 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone(orig);
14436 return nativeResponseValue;
14438 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_new(uint32_t a, struct LDKCVec_u8Z b);
14440 export function C2Tuple_u32ScriptZ_new(a: number, b: number): bigint {
14441 if(!isWasmInitialized) {
14442 throw new Error("initializeWasm() must be awaited first!");
14444 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_new(a, b);
14445 return nativeResponseValue;
14447 // void C2Tuple_u32ScriptZ_free(struct LDKC2Tuple_u32ScriptZ _res);
14449 export function C2Tuple_u32ScriptZ_free(_res: bigint): void {
14450 if(!isWasmInitialized) {
14451 throw new Error("initializeWasm() must be awaited first!");
14453 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_free(_res);
14454 // debug statements here
14456 // void CVec_C2Tuple_u32ScriptZZ_free(struct LDKCVec_C2Tuple_u32ScriptZZ _res);
14458 export function CVec_C2Tuple_u32ScriptZZ_free(_res: number): void {
14459 if(!isWasmInitialized) {
14460 throw new Error("initializeWasm() must be awaited first!");
14462 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32ScriptZZ_free(_res);
14463 // debug statements here
14465 // uint64_t C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR arg);
14467 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg: bigint): bigint {
14468 if(!isWasmInitialized) {
14469 throw new Error("initializeWasm() must be awaited first!");
14471 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg);
14472 return nativeResponseValue;
14474 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR orig);
14476 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig: bigint): bigint {
14477 if(!isWasmInitialized) {
14478 throw new Error("initializeWasm() must be awaited first!");
14480 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig);
14481 return nativeResponseValue;
14483 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32ScriptZZ b);
14485 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a: number, b: number): bigint {
14486 if(!isWasmInitialized) {
14487 throw new Error("initializeWasm() must be awaited first!");
14489 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a, b);
14490 return nativeResponseValue;
14492 // void C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res);
14494 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res: bigint): void {
14495 if(!isWasmInitialized) {
14496 throw new Error("initializeWasm() must be awaited first!");
14498 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res);
14499 // debug statements here
14501 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res);
14503 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res: number): void {
14504 if(!isWasmInitialized) {
14505 throw new Error("initializeWasm() must be awaited first!");
14507 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res);
14508 // debug statements here
14510 // void CVec_EventZ_free(struct LDKCVec_EventZ _res);
14512 export function CVec_EventZ_free(_res: number): void {
14513 if(!isWasmInitialized) {
14514 throw new Error("initializeWasm() must be awaited first!");
14516 const nativeResponseValue = wasm.TS_CVec_EventZ_free(_res);
14517 // debug statements here
14519 // void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
14521 export function CVec_TransactionZ_free(_res: number): void {
14522 if(!isWasmInitialized) {
14523 throw new Error("initializeWasm() must be awaited first!");
14525 const nativeResponseValue = wasm.TS_CVec_TransactionZ_free(_res);
14526 // debug statements here
14528 // uint64_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg);
14530 export function C2Tuple_u32TxOutZ_clone_ptr(arg: bigint): bigint {
14531 if(!isWasmInitialized) {
14532 throw new Error("initializeWasm() must be awaited first!");
14534 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone_ptr(arg);
14535 return nativeResponseValue;
14537 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
14539 export function C2Tuple_u32TxOutZ_clone(orig: bigint): bigint {
14540 if(!isWasmInitialized) {
14541 throw new Error("initializeWasm() must be awaited first!");
14543 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone(orig);
14544 return nativeResponseValue;
14546 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
14548 export function C2Tuple_u32TxOutZ_new(a: number, b: bigint): bigint {
14549 if(!isWasmInitialized) {
14550 throw new Error("initializeWasm() must be awaited first!");
14552 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_new(a, b);
14553 return nativeResponseValue;
14555 // void C2Tuple_u32TxOutZ_free(struct LDKC2Tuple_u32TxOutZ _res);
14557 export function C2Tuple_u32TxOutZ_free(_res: bigint): void {
14558 if(!isWasmInitialized) {
14559 throw new Error("initializeWasm() must be awaited first!");
14561 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_free(_res);
14562 // debug statements here
14564 // void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
14566 export function CVec_C2Tuple_u32TxOutZZ_free(_res: number): void {
14567 if(!isWasmInitialized) {
14568 throw new Error("initializeWasm() must be awaited first!");
14570 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32TxOutZZ_free(_res);
14571 // debug statements here
14573 // uint64_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg);
14575 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg: bigint): bigint {
14576 if(!isWasmInitialized) {
14577 throw new Error("initializeWasm() must be awaited first!");
14579 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg);
14580 return nativeResponseValue;
14582 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR orig);
14584 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig: bigint): bigint {
14585 if(!isWasmInitialized) {
14586 throw new Error("initializeWasm() must be awaited first!");
14588 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig);
14589 return nativeResponseValue;
14591 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
14593 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a: number, b: number): bigint {
14594 if(!isWasmInitialized) {
14595 throw new Error("initializeWasm() must be awaited first!");
14597 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a, b);
14598 return nativeResponseValue;
14600 // void C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res);
14602 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res: bigint): void {
14603 if(!isWasmInitialized) {
14604 throw new Error("initializeWasm() must be awaited first!");
14606 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res);
14607 // debug statements here
14609 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res);
14611 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res: number): void {
14612 if(!isWasmInitialized) {
14613 throw new Error("initializeWasm() must be awaited first!");
14615 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res);
14616 // debug statements here
14618 // void CVec_BalanceZ_free(struct LDKCVec_BalanceZ _res);
14620 export function CVec_BalanceZ_free(_res: number): void {
14621 if(!isWasmInitialized) {
14622 throw new Error("initializeWasm() must be awaited first!");
14624 const nativeResponseValue = wasm.TS_CVec_BalanceZ_free(_res);
14625 // debug statements here
14627 // uint64_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg);
14629 export function C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg: bigint): bigint {
14630 if(!isWasmInitialized) {
14631 throw new Error("initializeWasm() must be awaited first!");
14633 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg);
14634 return nativeResponseValue;
14636 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_clone(const struct LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR orig);
14638 export function C2Tuple_BlockHashChannelMonitorZ_clone(orig: bigint): bigint {
14639 if(!isWasmInitialized) {
14640 throw new Error("initializeWasm() must be awaited first!");
14642 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone(orig);
14643 return nativeResponseValue;
14645 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
14647 export function C2Tuple_BlockHashChannelMonitorZ_new(a: number, b: bigint): bigint {
14648 if(!isWasmInitialized) {
14649 throw new Error("initializeWasm() must be awaited first!");
14651 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_new(a, b);
14652 return nativeResponseValue;
14654 // void C2Tuple_BlockHashChannelMonitorZ_free(struct LDKC2Tuple_BlockHashChannelMonitorZ _res);
14656 export function C2Tuple_BlockHashChannelMonitorZ_free(_res: bigint): void {
14657 if(!isWasmInitialized) {
14658 throw new Error("initializeWasm() must be awaited first!");
14660 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_free(_res);
14661 // debug statements here
14663 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelMonitorZ o);
14665 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o: bigint): bigint {
14666 if(!isWasmInitialized) {
14667 throw new Error("initializeWasm() must be awaited first!");
14669 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o);
14670 return nativeResponseValue;
14672 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
14674 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e: bigint): bigint {
14675 if(!isWasmInitialized) {
14676 throw new Error("initializeWasm() must be awaited first!");
14678 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e);
14679 return nativeResponseValue;
14681 // bool CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR o);
14683 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o: bigint): boolean {
14684 if(!isWasmInitialized) {
14685 throw new Error("initializeWasm() must be awaited first!");
14687 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o);
14688 return nativeResponseValue;
14690 // void CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res);
14692 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res: bigint): void {
14693 if(!isWasmInitialized) {
14694 throw new Error("initializeWasm() must be awaited first!");
14696 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res);
14697 // debug statements here
14699 // uint64_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg);
14701 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14702 if(!isWasmInitialized) {
14703 throw new Error("initializeWasm() must be awaited first!");
14705 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg);
14706 return nativeResponseValue;
14708 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR orig);
14710 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig: bigint): bigint {
14711 if(!isWasmInitialized) {
14712 throw new Error("initializeWasm() must be awaited first!");
14714 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig);
14715 return nativeResponseValue;
14717 // uint64_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg);
14719 export function C2Tuple_PublicKeyTypeZ_clone_ptr(arg: bigint): bigint {
14720 if(!isWasmInitialized) {
14721 throw new Error("initializeWasm() must be awaited first!");
14723 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone_ptr(arg);
14724 return nativeResponseValue;
14726 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_clone(const struct LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR orig);
14728 export function C2Tuple_PublicKeyTypeZ_clone(orig: bigint): bigint {
14729 if(!isWasmInitialized) {
14730 throw new Error("initializeWasm() must be awaited first!");
14732 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone(orig);
14733 return nativeResponseValue;
14735 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_new(struct LDKPublicKey a, struct LDKType b);
14737 export function C2Tuple_PublicKeyTypeZ_new(a: number, b: bigint): bigint {
14738 if(!isWasmInitialized) {
14739 throw new Error("initializeWasm() must be awaited first!");
14741 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_new(a, b);
14742 return nativeResponseValue;
14744 // void C2Tuple_PublicKeyTypeZ_free(struct LDKC2Tuple_PublicKeyTypeZ _res);
14746 export function C2Tuple_PublicKeyTypeZ_free(_res: bigint): void {
14747 if(!isWasmInitialized) {
14748 throw new Error("initializeWasm() must be awaited first!");
14750 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_free(_res);
14751 // debug statements here
14753 // void CVec_C2Tuple_PublicKeyTypeZZ_free(struct LDKCVec_C2Tuple_PublicKeyTypeZZ _res);
14755 export function CVec_C2Tuple_PublicKeyTypeZZ_free(_res: number): void {
14756 if(!isWasmInitialized) {
14757 throw new Error("initializeWasm() must be awaited first!");
14759 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyTypeZZ_free(_res);
14760 // debug statements here
14762 // struct LDKCOption_CustomOnionMessageContentsZ COption_CustomOnionMessageContentsZ_some(struct LDKCustomOnionMessageContents o);
14764 export function COption_CustomOnionMessageContentsZ_some(o: bigint): bigint {
14765 if(!isWasmInitialized) {
14766 throw new Error("initializeWasm() must be awaited first!");
14768 const nativeResponseValue = wasm.TS_COption_CustomOnionMessageContentsZ_some(o);
14769 return nativeResponseValue;
14771 // struct LDKCOption_CustomOnionMessageContentsZ COption_CustomOnionMessageContentsZ_none(void);
14773 export function COption_CustomOnionMessageContentsZ_none(): bigint {
14774 if(!isWasmInitialized) {
14775 throw new Error("initializeWasm() must be awaited first!");
14777 const nativeResponseValue = wasm.TS_COption_CustomOnionMessageContentsZ_none();
14778 return nativeResponseValue;
14780 // void COption_CustomOnionMessageContentsZ_free(struct LDKCOption_CustomOnionMessageContentsZ _res);
14782 export function COption_CustomOnionMessageContentsZ_free(_res: bigint): void {
14783 if(!isWasmInitialized) {
14784 throw new Error("initializeWasm() must be awaited first!");
14786 const nativeResponseValue = wasm.TS_COption_CustomOnionMessageContentsZ_free(_res);
14787 // debug statements here
14789 // uint64_t COption_CustomOnionMessageContentsZ_clone_ptr(LDKCOption_CustomOnionMessageContentsZ *NONNULL_PTR arg);
14791 export function COption_CustomOnionMessageContentsZ_clone_ptr(arg: bigint): bigint {
14792 if(!isWasmInitialized) {
14793 throw new Error("initializeWasm() must be awaited first!");
14795 const nativeResponseValue = wasm.TS_COption_CustomOnionMessageContentsZ_clone_ptr(arg);
14796 return nativeResponseValue;
14798 // struct LDKCOption_CustomOnionMessageContentsZ COption_CustomOnionMessageContentsZ_clone(const struct LDKCOption_CustomOnionMessageContentsZ *NONNULL_PTR orig);
14800 export function COption_CustomOnionMessageContentsZ_clone(orig: bigint): bigint {
14801 if(!isWasmInitialized) {
14802 throw new Error("initializeWasm() must be awaited first!");
14804 const nativeResponseValue = wasm.TS_COption_CustomOnionMessageContentsZ_clone(orig);
14805 return nativeResponseValue;
14807 // struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok(struct LDKCOption_CustomOnionMessageContentsZ o);
14809 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok(o: bigint): bigint {
14810 if(!isWasmInitialized) {
14811 throw new Error("initializeWasm() must be awaited first!");
14813 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok(o);
14814 return nativeResponseValue;
14816 // struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_err(struct LDKDecodeError e);
14818 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_err(e: bigint): bigint {
14819 if(!isWasmInitialized) {
14820 throw new Error("initializeWasm() must be awaited first!");
14822 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_err(e);
14823 return nativeResponseValue;
14825 // bool CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_is_ok(const struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR o);
14827 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_is_ok(o: bigint): boolean {
14828 if(!isWasmInitialized) {
14829 throw new Error("initializeWasm() must be awaited first!");
14831 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_is_ok(o);
14832 return nativeResponseValue;
14834 // void CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ _res);
14836 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(_res: bigint): void {
14837 if(!isWasmInitialized) {
14838 throw new Error("initializeWasm() must be awaited first!");
14840 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(_res);
14841 // debug statements here
14843 // uint64_t CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR arg);
14845 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14846 if(!isWasmInitialized) {
14847 throw new Error("initializeWasm() must be awaited first!");
14849 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr(arg);
14850 return nativeResponseValue;
14852 // struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone(const struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR orig);
14854 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone(orig: bigint): bigint {
14855 if(!isWasmInitialized) {
14856 throw new Error("initializeWasm() must be awaited first!");
14858 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone(orig);
14859 return nativeResponseValue;
14861 // struct LDKCOption_NetAddressZ COption_NetAddressZ_some(struct LDKNetAddress o);
14863 export function COption_NetAddressZ_some(o: bigint): bigint {
14864 if(!isWasmInitialized) {
14865 throw new Error("initializeWasm() must be awaited first!");
14867 const nativeResponseValue = wasm.TS_COption_NetAddressZ_some(o);
14868 return nativeResponseValue;
14870 // struct LDKCOption_NetAddressZ COption_NetAddressZ_none(void);
14872 export function COption_NetAddressZ_none(): bigint {
14873 if(!isWasmInitialized) {
14874 throw new Error("initializeWasm() must be awaited first!");
14876 const nativeResponseValue = wasm.TS_COption_NetAddressZ_none();
14877 return nativeResponseValue;
14879 // void COption_NetAddressZ_free(struct LDKCOption_NetAddressZ _res);
14881 export function COption_NetAddressZ_free(_res: bigint): void {
14882 if(!isWasmInitialized) {
14883 throw new Error("initializeWasm() must be awaited first!");
14885 const nativeResponseValue = wasm.TS_COption_NetAddressZ_free(_res);
14886 // debug statements here
14888 // uint64_t COption_NetAddressZ_clone_ptr(LDKCOption_NetAddressZ *NONNULL_PTR arg);
14890 export function COption_NetAddressZ_clone_ptr(arg: bigint): bigint {
14891 if(!isWasmInitialized) {
14892 throw new Error("initializeWasm() must be awaited first!");
14894 const nativeResponseValue = wasm.TS_COption_NetAddressZ_clone_ptr(arg);
14895 return nativeResponseValue;
14897 // struct LDKCOption_NetAddressZ COption_NetAddressZ_clone(const struct LDKCOption_NetAddressZ *NONNULL_PTR orig);
14899 export function COption_NetAddressZ_clone(orig: bigint): bigint {
14900 if(!isWasmInitialized) {
14901 throw new Error("initializeWasm() must be awaited first!");
14903 const nativeResponseValue = wasm.TS_COption_NetAddressZ_clone(orig);
14904 return nativeResponseValue;
14906 // uint64_t C2Tuple_PublicKeyCOption_NetAddressZZ_clone_ptr(LDKC2Tuple_PublicKeyCOption_NetAddressZZ *NONNULL_PTR arg);
14908 export function C2Tuple_PublicKeyCOption_NetAddressZZ_clone_ptr(arg: bigint): bigint {
14909 if(!isWasmInitialized) {
14910 throw new Error("initializeWasm() must be awaited first!");
14912 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_NetAddressZZ_clone_ptr(arg);
14913 return nativeResponseValue;
14915 // struct LDKC2Tuple_PublicKeyCOption_NetAddressZZ C2Tuple_PublicKeyCOption_NetAddressZZ_clone(const struct LDKC2Tuple_PublicKeyCOption_NetAddressZZ *NONNULL_PTR orig);
14917 export function C2Tuple_PublicKeyCOption_NetAddressZZ_clone(orig: bigint): bigint {
14918 if(!isWasmInitialized) {
14919 throw new Error("initializeWasm() must be awaited first!");
14921 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_NetAddressZZ_clone(orig);
14922 return nativeResponseValue;
14924 // struct LDKC2Tuple_PublicKeyCOption_NetAddressZZ C2Tuple_PublicKeyCOption_NetAddressZZ_new(struct LDKPublicKey a, struct LDKCOption_NetAddressZ b);
14926 export function C2Tuple_PublicKeyCOption_NetAddressZZ_new(a: number, b: bigint): bigint {
14927 if(!isWasmInitialized) {
14928 throw new Error("initializeWasm() must be awaited first!");
14930 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_NetAddressZZ_new(a, b);
14931 return nativeResponseValue;
14933 // void C2Tuple_PublicKeyCOption_NetAddressZZ_free(struct LDKC2Tuple_PublicKeyCOption_NetAddressZZ _res);
14935 export function C2Tuple_PublicKeyCOption_NetAddressZZ_free(_res: bigint): void {
14936 if(!isWasmInitialized) {
14937 throw new Error("initializeWasm() must be awaited first!");
14939 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_NetAddressZZ_free(_res);
14940 // debug statements here
14942 // void CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ_free(struct LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ _res);
14944 export function CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ_free(_res: number): void {
14945 if(!isWasmInitialized) {
14946 throw new Error("initializeWasm() must be awaited first!");
14948 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ_free(_res);
14949 // debug statements here
14951 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
14953 export function CResult_CVec_u8ZPeerHandleErrorZ_ok(o: number): bigint {
14954 if(!isWasmInitialized) {
14955 throw new Error("initializeWasm() must be awaited first!");
14957 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(o);
14958 return nativeResponseValue;
14960 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
14962 export function CResult_CVec_u8ZPeerHandleErrorZ_err(e: bigint): bigint {
14963 if(!isWasmInitialized) {
14964 throw new Error("initializeWasm() must be awaited first!");
14966 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_err(e);
14967 return nativeResponseValue;
14969 // bool CResult_CVec_u8ZPeerHandleErrorZ_is_ok(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR o);
14971 export function CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o: bigint): boolean {
14972 if(!isWasmInitialized) {
14973 throw new Error("initializeWasm() must be awaited first!");
14975 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o);
14976 return nativeResponseValue;
14978 // void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
14980 export function CResult_CVec_u8ZPeerHandleErrorZ_free(_res: bigint): void {
14981 if(!isWasmInitialized) {
14982 throw new Error("initializeWasm() must be awaited first!");
14984 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_free(_res);
14985 // debug statements here
14987 // uint64_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg);
14989 export function CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
14990 if(!isWasmInitialized) {
14991 throw new Error("initializeWasm() must be awaited first!");
14993 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg);
14994 return nativeResponseValue;
14996 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
14998 export function CResult_CVec_u8ZPeerHandleErrorZ_clone(orig: bigint): bigint {
14999 if(!isWasmInitialized) {
15000 throw new Error("initializeWasm() must be awaited first!");
15002 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(orig);
15003 return nativeResponseValue;
15005 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
15007 export function CResult_NonePeerHandleErrorZ_ok(): bigint {
15008 if(!isWasmInitialized) {
15009 throw new Error("initializeWasm() must be awaited first!");
15011 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_ok();
15012 return nativeResponseValue;
15014 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
15016 export function CResult_NonePeerHandleErrorZ_err(e: bigint): bigint {
15017 if(!isWasmInitialized) {
15018 throw new Error("initializeWasm() must be awaited first!");
15020 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_err(e);
15021 return nativeResponseValue;
15023 // bool CResult_NonePeerHandleErrorZ_is_ok(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR o);
15025 export function CResult_NonePeerHandleErrorZ_is_ok(o: bigint): boolean {
15026 if(!isWasmInitialized) {
15027 throw new Error("initializeWasm() must be awaited first!");
15029 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_is_ok(o);
15030 return nativeResponseValue;
15032 // void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
15034 export function CResult_NonePeerHandleErrorZ_free(_res: bigint): void {
15035 if(!isWasmInitialized) {
15036 throw new Error("initializeWasm() must be awaited first!");
15038 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_free(_res);
15039 // debug statements here
15041 // uint64_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg);
15043 export function CResult_NonePeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
15044 if(!isWasmInitialized) {
15045 throw new Error("initializeWasm() must be awaited first!");
15047 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone_ptr(arg);
15048 return nativeResponseValue;
15050 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
15052 export function CResult_NonePeerHandleErrorZ_clone(orig: bigint): bigint {
15053 if(!isWasmInitialized) {
15054 throw new Error("initializeWasm() must be awaited first!");
15056 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone(orig);
15057 return nativeResponseValue;
15059 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
15061 export function CResult_boolPeerHandleErrorZ_ok(o: boolean): bigint {
15062 if(!isWasmInitialized) {
15063 throw new Error("initializeWasm() must be awaited first!");
15065 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_ok(o);
15066 return nativeResponseValue;
15068 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
15070 export function CResult_boolPeerHandleErrorZ_err(e: bigint): bigint {
15071 if(!isWasmInitialized) {
15072 throw new Error("initializeWasm() must be awaited first!");
15074 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_err(e);
15075 return nativeResponseValue;
15077 // bool CResult_boolPeerHandleErrorZ_is_ok(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR o);
15079 export function CResult_boolPeerHandleErrorZ_is_ok(o: bigint): boolean {
15080 if(!isWasmInitialized) {
15081 throw new Error("initializeWasm() must be awaited first!");
15083 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_is_ok(o);
15084 return nativeResponseValue;
15086 // void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
15088 export function CResult_boolPeerHandleErrorZ_free(_res: bigint): void {
15089 if(!isWasmInitialized) {
15090 throw new Error("initializeWasm() must be awaited first!");
15092 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_free(_res);
15093 // debug statements here
15095 // uint64_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg);
15097 export function CResult_boolPeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
15098 if(!isWasmInitialized) {
15099 throw new Error("initializeWasm() must be awaited first!");
15101 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone_ptr(arg);
15102 return nativeResponseValue;
15104 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
15106 export function CResult_boolPeerHandleErrorZ_clone(orig: bigint): bigint {
15107 if(!isWasmInitialized) {
15108 throw new Error("initializeWasm() must be awaited first!");
15110 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone(orig);
15111 return nativeResponseValue;
15113 // struct LDKCResult_TxOutUtxoLookupErrorZ CResult_TxOutUtxoLookupErrorZ_ok(struct LDKTxOut o);
15115 export function CResult_TxOutUtxoLookupErrorZ_ok(o: bigint): bigint {
15116 if(!isWasmInitialized) {
15117 throw new Error("initializeWasm() must be awaited first!");
15119 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_ok(o);
15120 return nativeResponseValue;
15122 // struct LDKCResult_TxOutUtxoLookupErrorZ CResult_TxOutUtxoLookupErrorZ_err(enum LDKUtxoLookupError e);
15124 export function CResult_TxOutUtxoLookupErrorZ_err(e: UtxoLookupError): bigint {
15125 if(!isWasmInitialized) {
15126 throw new Error("initializeWasm() must be awaited first!");
15128 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_err(e);
15129 return nativeResponseValue;
15131 // bool CResult_TxOutUtxoLookupErrorZ_is_ok(const struct LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR o);
15133 export function CResult_TxOutUtxoLookupErrorZ_is_ok(o: bigint): boolean {
15134 if(!isWasmInitialized) {
15135 throw new Error("initializeWasm() must be awaited first!");
15137 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_is_ok(o);
15138 return nativeResponseValue;
15140 // void CResult_TxOutUtxoLookupErrorZ_free(struct LDKCResult_TxOutUtxoLookupErrorZ _res);
15142 export function CResult_TxOutUtxoLookupErrorZ_free(_res: bigint): void {
15143 if(!isWasmInitialized) {
15144 throw new Error("initializeWasm() must be awaited first!");
15146 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_free(_res);
15147 // debug statements here
15149 // uint64_t CResult_TxOutUtxoLookupErrorZ_clone_ptr(LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR arg);
15151 export function CResult_TxOutUtxoLookupErrorZ_clone_ptr(arg: bigint): bigint {
15152 if(!isWasmInitialized) {
15153 throw new Error("initializeWasm() must be awaited first!");
15155 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_clone_ptr(arg);
15156 return nativeResponseValue;
15158 // struct LDKCResult_TxOutUtxoLookupErrorZ CResult_TxOutUtxoLookupErrorZ_clone(const struct LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR orig);
15160 export function CResult_TxOutUtxoLookupErrorZ_clone(orig: bigint): bigint {
15161 if(!isWasmInitialized) {
15162 throw new Error("initializeWasm() must be awaited first!");
15164 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_clone(orig);
15165 return nativeResponseValue;
15167 // struct LDKCResult_NoneSendErrorZ CResult_NoneSendErrorZ_ok(void);
15169 export function CResult_NoneSendErrorZ_ok(): bigint {
15170 if(!isWasmInitialized) {
15171 throw new Error("initializeWasm() must be awaited first!");
15173 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_ok();
15174 return nativeResponseValue;
15176 // struct LDKCResult_NoneSendErrorZ CResult_NoneSendErrorZ_err(struct LDKSendError e);
15178 export function CResult_NoneSendErrorZ_err(e: bigint): bigint {
15179 if(!isWasmInitialized) {
15180 throw new Error("initializeWasm() must be awaited first!");
15182 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_err(e);
15183 return nativeResponseValue;
15185 // bool CResult_NoneSendErrorZ_is_ok(const struct LDKCResult_NoneSendErrorZ *NONNULL_PTR o);
15187 export function CResult_NoneSendErrorZ_is_ok(o: bigint): boolean {
15188 if(!isWasmInitialized) {
15189 throw new Error("initializeWasm() must be awaited first!");
15191 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_is_ok(o);
15192 return nativeResponseValue;
15194 // void CResult_NoneSendErrorZ_free(struct LDKCResult_NoneSendErrorZ _res);
15196 export function CResult_NoneSendErrorZ_free(_res: bigint): void {
15197 if(!isWasmInitialized) {
15198 throw new Error("initializeWasm() must be awaited first!");
15200 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_free(_res);
15201 // debug statements here
15203 // struct LDKCResult_u32GraphSyncErrorZ CResult_u32GraphSyncErrorZ_ok(uint32_t o);
15205 export function CResult_u32GraphSyncErrorZ_ok(o: number): bigint {
15206 if(!isWasmInitialized) {
15207 throw new Error("initializeWasm() must be awaited first!");
15209 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_ok(o);
15210 return nativeResponseValue;
15212 // struct LDKCResult_u32GraphSyncErrorZ CResult_u32GraphSyncErrorZ_err(struct LDKGraphSyncError e);
15214 export function CResult_u32GraphSyncErrorZ_err(e: bigint): bigint {
15215 if(!isWasmInitialized) {
15216 throw new Error("initializeWasm() must be awaited first!");
15218 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_err(e);
15219 return nativeResponseValue;
15221 // bool CResult_u32GraphSyncErrorZ_is_ok(const struct LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR o);
15223 export function CResult_u32GraphSyncErrorZ_is_ok(o: bigint): boolean {
15224 if(!isWasmInitialized) {
15225 throw new Error("initializeWasm() must be awaited first!");
15227 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_is_ok(o);
15228 return nativeResponseValue;
15230 // void CResult_u32GraphSyncErrorZ_free(struct LDKCResult_u32GraphSyncErrorZ _res);
15232 export function CResult_u32GraphSyncErrorZ_free(_res: bigint): void {
15233 if(!isWasmInitialized) {
15234 throw new Error("initializeWasm() must be awaited first!");
15236 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_free(_res);
15237 // debug statements here
15239 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_ok(enum LDKSiPrefix o);
15241 export function CResult_SiPrefixParseErrorZ_ok(o: SiPrefix): bigint {
15242 if(!isWasmInitialized) {
15243 throw new Error("initializeWasm() must be awaited first!");
15245 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_ok(o);
15246 return nativeResponseValue;
15248 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_err(struct LDKParseError e);
15250 export function CResult_SiPrefixParseErrorZ_err(e: bigint): bigint {
15251 if(!isWasmInitialized) {
15252 throw new Error("initializeWasm() must be awaited first!");
15254 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_err(e);
15255 return nativeResponseValue;
15257 // bool CResult_SiPrefixParseErrorZ_is_ok(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR o);
15259 export function CResult_SiPrefixParseErrorZ_is_ok(o: bigint): boolean {
15260 if(!isWasmInitialized) {
15261 throw new Error("initializeWasm() must be awaited first!");
15263 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_is_ok(o);
15264 return nativeResponseValue;
15266 // void CResult_SiPrefixParseErrorZ_free(struct LDKCResult_SiPrefixParseErrorZ _res);
15268 export function CResult_SiPrefixParseErrorZ_free(_res: bigint): void {
15269 if(!isWasmInitialized) {
15270 throw new Error("initializeWasm() must be awaited first!");
15272 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_free(_res);
15273 // debug statements here
15275 // uint64_t CResult_SiPrefixParseErrorZ_clone_ptr(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR arg);
15277 export function CResult_SiPrefixParseErrorZ_clone_ptr(arg: bigint): bigint {
15278 if(!isWasmInitialized) {
15279 throw new Error("initializeWasm() must be awaited first!");
15281 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone_ptr(arg);
15282 return nativeResponseValue;
15284 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_clone(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR orig);
15286 export function CResult_SiPrefixParseErrorZ_clone(orig: bigint): bigint {
15287 if(!isWasmInitialized) {
15288 throw new Error("initializeWasm() must be awaited first!");
15290 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone(orig);
15291 return nativeResponseValue;
15293 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_ok(struct LDKInvoice o);
15295 export function CResult_InvoiceParseOrSemanticErrorZ_ok(o: bigint): bigint {
15296 if(!isWasmInitialized) {
15297 throw new Error("initializeWasm() must be awaited first!");
15299 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_ok(o);
15300 return nativeResponseValue;
15302 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_err(struct LDKParseOrSemanticError e);
15304 export function CResult_InvoiceParseOrSemanticErrorZ_err(e: bigint): bigint {
15305 if(!isWasmInitialized) {
15306 throw new Error("initializeWasm() must be awaited first!");
15308 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_err(e);
15309 return nativeResponseValue;
15311 // bool CResult_InvoiceParseOrSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR o);
15313 export function CResult_InvoiceParseOrSemanticErrorZ_is_ok(o: bigint): boolean {
15314 if(!isWasmInitialized) {
15315 throw new Error("initializeWasm() must be awaited first!");
15317 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_is_ok(o);
15318 return nativeResponseValue;
15320 // void CResult_InvoiceParseOrSemanticErrorZ_free(struct LDKCResult_InvoiceParseOrSemanticErrorZ _res);
15322 export function CResult_InvoiceParseOrSemanticErrorZ_free(_res: bigint): void {
15323 if(!isWasmInitialized) {
15324 throw new Error("initializeWasm() must be awaited first!");
15326 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_free(_res);
15327 // debug statements here
15329 // uint64_t CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR arg);
15331 export function CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg: bigint): bigint {
15332 if(!isWasmInitialized) {
15333 throw new Error("initializeWasm() must be awaited first!");
15335 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg);
15336 return nativeResponseValue;
15338 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_clone(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR orig);
15340 export function CResult_InvoiceParseOrSemanticErrorZ_clone(orig: bigint): bigint {
15341 if(!isWasmInitialized) {
15342 throw new Error("initializeWasm() must be awaited first!");
15344 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone(orig);
15345 return nativeResponseValue;
15347 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_ok(struct LDKSignedRawInvoice o);
15349 export function CResult_SignedRawInvoiceParseErrorZ_ok(o: bigint): bigint {
15350 if(!isWasmInitialized) {
15351 throw new Error("initializeWasm() must be awaited first!");
15353 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_ok(o);
15354 return nativeResponseValue;
15356 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_err(struct LDKParseError e);
15358 export function CResult_SignedRawInvoiceParseErrorZ_err(e: bigint): bigint {
15359 if(!isWasmInitialized) {
15360 throw new Error("initializeWasm() must be awaited first!");
15362 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_err(e);
15363 return nativeResponseValue;
15365 // bool CResult_SignedRawInvoiceParseErrorZ_is_ok(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR o);
15367 export function CResult_SignedRawInvoiceParseErrorZ_is_ok(o: bigint): boolean {
15368 if(!isWasmInitialized) {
15369 throw new Error("initializeWasm() must be awaited first!");
15371 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_is_ok(o);
15372 return nativeResponseValue;
15374 // void CResult_SignedRawInvoiceParseErrorZ_free(struct LDKCResult_SignedRawInvoiceParseErrorZ _res);
15376 export function CResult_SignedRawInvoiceParseErrorZ_free(_res: bigint): void {
15377 if(!isWasmInitialized) {
15378 throw new Error("initializeWasm() must be awaited first!");
15380 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_free(_res);
15381 // debug statements here
15383 // uint64_t CResult_SignedRawInvoiceParseErrorZ_clone_ptr(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR arg);
15385 export function CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg: bigint): bigint {
15386 if(!isWasmInitialized) {
15387 throw new Error("initializeWasm() must be awaited first!");
15389 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg);
15390 return nativeResponseValue;
15392 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_clone(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR orig);
15394 export function CResult_SignedRawInvoiceParseErrorZ_clone(orig: bigint): bigint {
15395 if(!isWasmInitialized) {
15396 throw new Error("initializeWasm() must be awaited first!");
15398 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone(orig);
15399 return nativeResponseValue;
15401 // uint64_t C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR arg);
15403 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg: bigint): bigint {
15404 if(!isWasmInitialized) {
15405 throw new Error("initializeWasm() must be awaited first!");
15407 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg);
15408 return nativeResponseValue;
15410 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(const struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR orig);
15412 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig: bigint): bigint {
15413 if(!isWasmInitialized) {
15414 throw new Error("initializeWasm() must be awaited first!");
15416 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig);
15417 return nativeResponseValue;
15419 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(struct LDKRawInvoice a, struct LDKThirtyTwoBytes b, struct LDKInvoiceSignature c);
15421 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a: bigint, b: number, c: bigint): bigint {
15422 if(!isWasmInitialized) {
15423 throw new Error("initializeWasm() must be awaited first!");
15425 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a, b, c);
15426 return nativeResponseValue;
15428 // void C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ _res);
15430 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res: bigint): void {
15431 if(!isWasmInitialized) {
15432 throw new Error("initializeWasm() must be awaited first!");
15434 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res);
15435 // debug statements here
15437 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_ok(struct LDKPayeePubKey o);
15439 export function CResult_PayeePubKeyErrorZ_ok(o: bigint): bigint {
15440 if(!isWasmInitialized) {
15441 throw new Error("initializeWasm() must be awaited first!");
15443 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_ok(o);
15444 return nativeResponseValue;
15446 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_err(enum LDKSecp256k1Error e);
15448 export function CResult_PayeePubKeyErrorZ_err(e: Secp256k1Error): bigint {
15449 if(!isWasmInitialized) {
15450 throw new Error("initializeWasm() must be awaited first!");
15452 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_err(e);
15453 return nativeResponseValue;
15455 // bool CResult_PayeePubKeyErrorZ_is_ok(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR o);
15457 export function CResult_PayeePubKeyErrorZ_is_ok(o: bigint): boolean {
15458 if(!isWasmInitialized) {
15459 throw new Error("initializeWasm() must be awaited first!");
15461 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_is_ok(o);
15462 return nativeResponseValue;
15464 // void CResult_PayeePubKeyErrorZ_free(struct LDKCResult_PayeePubKeyErrorZ _res);
15466 export function CResult_PayeePubKeyErrorZ_free(_res: bigint): void {
15467 if(!isWasmInitialized) {
15468 throw new Error("initializeWasm() must be awaited first!");
15470 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_free(_res);
15471 // debug statements here
15473 // uint64_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg);
15475 export function CResult_PayeePubKeyErrorZ_clone_ptr(arg: bigint): bigint {
15476 if(!isWasmInitialized) {
15477 throw new Error("initializeWasm() must be awaited first!");
15479 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone_ptr(arg);
15480 return nativeResponseValue;
15482 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_clone(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR orig);
15484 export function CResult_PayeePubKeyErrorZ_clone(orig: bigint): bigint {
15485 if(!isWasmInitialized) {
15486 throw new Error("initializeWasm() must be awaited first!");
15488 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone(orig);
15489 return nativeResponseValue;
15491 // void CVec_PrivateRouteZ_free(struct LDKCVec_PrivateRouteZ _res);
15493 export function CVec_PrivateRouteZ_free(_res: number): void {
15494 if(!isWasmInitialized) {
15495 throw new Error("initializeWasm() must be awaited first!");
15497 const nativeResponseValue = wasm.TS_CVec_PrivateRouteZ_free(_res);
15498 // debug statements here
15500 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_ok(struct LDKPositiveTimestamp o);
15502 export function CResult_PositiveTimestampCreationErrorZ_ok(o: bigint): bigint {
15503 if(!isWasmInitialized) {
15504 throw new Error("initializeWasm() must be awaited first!");
15506 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_ok(o);
15507 return nativeResponseValue;
15509 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_err(enum LDKCreationError e);
15511 export function CResult_PositiveTimestampCreationErrorZ_err(e: CreationError): bigint {
15512 if(!isWasmInitialized) {
15513 throw new Error("initializeWasm() must be awaited first!");
15515 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_err(e);
15516 return nativeResponseValue;
15518 // bool CResult_PositiveTimestampCreationErrorZ_is_ok(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR o);
15520 export function CResult_PositiveTimestampCreationErrorZ_is_ok(o: bigint): boolean {
15521 if(!isWasmInitialized) {
15522 throw new Error("initializeWasm() must be awaited first!");
15524 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_is_ok(o);
15525 return nativeResponseValue;
15527 // void CResult_PositiveTimestampCreationErrorZ_free(struct LDKCResult_PositiveTimestampCreationErrorZ _res);
15529 export function CResult_PositiveTimestampCreationErrorZ_free(_res: bigint): void {
15530 if(!isWasmInitialized) {
15531 throw new Error("initializeWasm() must be awaited first!");
15533 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_free(_res);
15534 // debug statements here
15536 // uint64_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg);
15538 export function CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg: bigint): bigint {
15539 if(!isWasmInitialized) {
15540 throw new Error("initializeWasm() must be awaited first!");
15542 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg);
15543 return nativeResponseValue;
15545 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_clone(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR orig);
15547 export function CResult_PositiveTimestampCreationErrorZ_clone(orig: bigint): bigint {
15548 if(!isWasmInitialized) {
15549 throw new Error("initializeWasm() must be awaited first!");
15551 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone(orig);
15552 return nativeResponseValue;
15554 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_ok(void);
15556 export function CResult_NoneSemanticErrorZ_ok(): bigint {
15557 if(!isWasmInitialized) {
15558 throw new Error("initializeWasm() must be awaited first!");
15560 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_ok();
15561 return nativeResponseValue;
15563 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_err(enum LDKSemanticError e);
15565 export function CResult_NoneSemanticErrorZ_err(e: SemanticError): bigint {
15566 if(!isWasmInitialized) {
15567 throw new Error("initializeWasm() must be awaited first!");
15569 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_err(e);
15570 return nativeResponseValue;
15572 // bool CResult_NoneSemanticErrorZ_is_ok(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR o);
15574 export function CResult_NoneSemanticErrorZ_is_ok(o: bigint): boolean {
15575 if(!isWasmInitialized) {
15576 throw new Error("initializeWasm() must be awaited first!");
15578 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_is_ok(o);
15579 return nativeResponseValue;
15581 // void CResult_NoneSemanticErrorZ_free(struct LDKCResult_NoneSemanticErrorZ _res);
15583 export function CResult_NoneSemanticErrorZ_free(_res: bigint): void {
15584 if(!isWasmInitialized) {
15585 throw new Error("initializeWasm() must be awaited first!");
15587 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_free(_res);
15588 // debug statements here
15590 // uint64_t CResult_NoneSemanticErrorZ_clone_ptr(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR arg);
15592 export function CResult_NoneSemanticErrorZ_clone_ptr(arg: bigint): bigint {
15593 if(!isWasmInitialized) {
15594 throw new Error("initializeWasm() must be awaited first!");
15596 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone_ptr(arg);
15597 return nativeResponseValue;
15599 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_clone(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR orig);
15601 export function CResult_NoneSemanticErrorZ_clone(orig: bigint): bigint {
15602 if(!isWasmInitialized) {
15603 throw new Error("initializeWasm() must be awaited first!");
15605 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone(orig);
15606 return nativeResponseValue;
15608 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_ok(struct LDKInvoice o);
15610 export function CResult_InvoiceSemanticErrorZ_ok(o: bigint): bigint {
15611 if(!isWasmInitialized) {
15612 throw new Error("initializeWasm() must be awaited first!");
15614 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_ok(o);
15615 return nativeResponseValue;
15617 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_err(enum LDKSemanticError e);
15619 export function CResult_InvoiceSemanticErrorZ_err(e: SemanticError): bigint {
15620 if(!isWasmInitialized) {
15621 throw new Error("initializeWasm() must be awaited first!");
15623 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_err(e);
15624 return nativeResponseValue;
15626 // bool CResult_InvoiceSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR o);
15628 export function CResult_InvoiceSemanticErrorZ_is_ok(o: bigint): boolean {
15629 if(!isWasmInitialized) {
15630 throw new Error("initializeWasm() must be awaited first!");
15632 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_is_ok(o);
15633 return nativeResponseValue;
15635 // void CResult_InvoiceSemanticErrorZ_free(struct LDKCResult_InvoiceSemanticErrorZ _res);
15637 export function CResult_InvoiceSemanticErrorZ_free(_res: bigint): void {
15638 if(!isWasmInitialized) {
15639 throw new Error("initializeWasm() must be awaited first!");
15641 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_free(_res);
15642 // debug statements here
15644 // uint64_t CResult_InvoiceSemanticErrorZ_clone_ptr(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR arg);
15646 export function CResult_InvoiceSemanticErrorZ_clone_ptr(arg: bigint): bigint {
15647 if(!isWasmInitialized) {
15648 throw new Error("initializeWasm() must be awaited first!");
15650 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone_ptr(arg);
15651 return nativeResponseValue;
15653 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_clone(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR orig);
15655 export function CResult_InvoiceSemanticErrorZ_clone(orig: bigint): bigint {
15656 if(!isWasmInitialized) {
15657 throw new Error("initializeWasm() must be awaited first!");
15659 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone(orig);
15660 return nativeResponseValue;
15662 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_ok(struct LDKDescription o);
15664 export function CResult_DescriptionCreationErrorZ_ok(o: bigint): bigint {
15665 if(!isWasmInitialized) {
15666 throw new Error("initializeWasm() must be awaited first!");
15668 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_ok(o);
15669 return nativeResponseValue;
15671 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_err(enum LDKCreationError e);
15673 export function CResult_DescriptionCreationErrorZ_err(e: CreationError): bigint {
15674 if(!isWasmInitialized) {
15675 throw new Error("initializeWasm() must be awaited first!");
15677 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_err(e);
15678 return nativeResponseValue;
15680 // bool CResult_DescriptionCreationErrorZ_is_ok(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR o);
15682 export function CResult_DescriptionCreationErrorZ_is_ok(o: bigint): boolean {
15683 if(!isWasmInitialized) {
15684 throw new Error("initializeWasm() must be awaited first!");
15686 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_is_ok(o);
15687 return nativeResponseValue;
15689 // void CResult_DescriptionCreationErrorZ_free(struct LDKCResult_DescriptionCreationErrorZ _res);
15691 export function CResult_DescriptionCreationErrorZ_free(_res: bigint): void {
15692 if(!isWasmInitialized) {
15693 throw new Error("initializeWasm() must be awaited first!");
15695 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_free(_res);
15696 // debug statements here
15698 // uint64_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg);
15700 export function CResult_DescriptionCreationErrorZ_clone_ptr(arg: bigint): bigint {
15701 if(!isWasmInitialized) {
15702 throw new Error("initializeWasm() must be awaited first!");
15704 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone_ptr(arg);
15705 return nativeResponseValue;
15707 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_clone(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR orig);
15709 export function CResult_DescriptionCreationErrorZ_clone(orig: bigint): bigint {
15710 if(!isWasmInitialized) {
15711 throw new Error("initializeWasm() must be awaited first!");
15713 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone(orig);
15714 return nativeResponseValue;
15716 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_ok(struct LDKPrivateRoute o);
15718 export function CResult_PrivateRouteCreationErrorZ_ok(o: bigint): bigint {
15719 if(!isWasmInitialized) {
15720 throw new Error("initializeWasm() must be awaited first!");
15722 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_ok(o);
15723 return nativeResponseValue;
15725 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_err(enum LDKCreationError e);
15727 export function CResult_PrivateRouteCreationErrorZ_err(e: CreationError): bigint {
15728 if(!isWasmInitialized) {
15729 throw new Error("initializeWasm() must be awaited first!");
15731 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_err(e);
15732 return nativeResponseValue;
15734 // bool CResult_PrivateRouteCreationErrorZ_is_ok(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR o);
15736 export function CResult_PrivateRouteCreationErrorZ_is_ok(o: bigint): boolean {
15737 if(!isWasmInitialized) {
15738 throw new Error("initializeWasm() must be awaited first!");
15740 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_is_ok(o);
15741 return nativeResponseValue;
15743 // void CResult_PrivateRouteCreationErrorZ_free(struct LDKCResult_PrivateRouteCreationErrorZ _res);
15745 export function CResult_PrivateRouteCreationErrorZ_free(_res: bigint): void {
15746 if(!isWasmInitialized) {
15747 throw new Error("initializeWasm() must be awaited first!");
15749 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_free(_res);
15750 // debug statements here
15752 // uint64_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg);
15754 export function CResult_PrivateRouteCreationErrorZ_clone_ptr(arg: bigint): bigint {
15755 if(!isWasmInitialized) {
15756 throw new Error("initializeWasm() must be awaited first!");
15758 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(arg);
15759 return nativeResponseValue;
15761 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_clone(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR orig);
15763 export function CResult_PrivateRouteCreationErrorZ_clone(orig: bigint): bigint {
15764 if(!isWasmInitialized) {
15765 throw new Error("initializeWasm() must be awaited first!");
15767 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone(orig);
15768 return nativeResponseValue;
15770 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_ok(void);
15772 export function CResult_NoneErrorZ_ok(): bigint {
15773 if(!isWasmInitialized) {
15774 throw new Error("initializeWasm() must be awaited first!");
15776 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_ok();
15777 return nativeResponseValue;
15779 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_err(enum LDKIOError e);
15781 export function CResult_NoneErrorZ_err(e: IOError): bigint {
15782 if(!isWasmInitialized) {
15783 throw new Error("initializeWasm() must be awaited first!");
15785 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_err(e);
15786 return nativeResponseValue;
15788 // bool CResult_NoneErrorZ_is_ok(const struct LDKCResult_NoneErrorZ *NONNULL_PTR o);
15790 export function CResult_NoneErrorZ_is_ok(o: bigint): boolean {
15791 if(!isWasmInitialized) {
15792 throw new Error("initializeWasm() must be awaited first!");
15794 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_is_ok(o);
15795 return nativeResponseValue;
15797 // void CResult_NoneErrorZ_free(struct LDKCResult_NoneErrorZ _res);
15799 export function CResult_NoneErrorZ_free(_res: bigint): void {
15800 if(!isWasmInitialized) {
15801 throw new Error("initializeWasm() must be awaited first!");
15803 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_free(_res);
15804 // debug statements here
15806 // uint64_t CResult_NoneErrorZ_clone_ptr(LDKCResult_NoneErrorZ *NONNULL_PTR arg);
15808 export function CResult_NoneErrorZ_clone_ptr(arg: bigint): bigint {
15809 if(!isWasmInitialized) {
15810 throw new Error("initializeWasm() must be awaited first!");
15812 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone_ptr(arg);
15813 return nativeResponseValue;
15815 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_clone(const struct LDKCResult_NoneErrorZ *NONNULL_PTR orig);
15817 export function CResult_NoneErrorZ_clone(orig: bigint): bigint {
15818 if(!isWasmInitialized) {
15819 throw new Error("initializeWasm() must be awaited first!");
15821 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone(orig);
15822 return nativeResponseValue;
15824 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_ok(struct LDKNetAddress o);
15826 export function CResult_NetAddressDecodeErrorZ_ok(o: bigint): bigint {
15827 if(!isWasmInitialized) {
15828 throw new Error("initializeWasm() must be awaited first!");
15830 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_ok(o);
15831 return nativeResponseValue;
15833 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_err(struct LDKDecodeError e);
15835 export function CResult_NetAddressDecodeErrorZ_err(e: bigint): bigint {
15836 if(!isWasmInitialized) {
15837 throw new Error("initializeWasm() must be awaited first!");
15839 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_err(e);
15840 return nativeResponseValue;
15842 // bool CResult_NetAddressDecodeErrorZ_is_ok(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR o);
15844 export function CResult_NetAddressDecodeErrorZ_is_ok(o: bigint): boolean {
15845 if(!isWasmInitialized) {
15846 throw new Error("initializeWasm() must be awaited first!");
15848 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_is_ok(o);
15849 return nativeResponseValue;
15851 // void CResult_NetAddressDecodeErrorZ_free(struct LDKCResult_NetAddressDecodeErrorZ _res);
15853 export function CResult_NetAddressDecodeErrorZ_free(_res: bigint): void {
15854 if(!isWasmInitialized) {
15855 throw new Error("initializeWasm() must be awaited first!");
15857 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_free(_res);
15858 // debug statements here
15860 // uint64_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg);
15862 export function CResult_NetAddressDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15863 if(!isWasmInitialized) {
15864 throw new Error("initializeWasm() must be awaited first!");
15866 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone_ptr(arg);
15867 return nativeResponseValue;
15869 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_clone(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR orig);
15871 export function CResult_NetAddressDecodeErrorZ_clone(orig: bigint): bigint {
15872 if(!isWasmInitialized) {
15873 throw new Error("initializeWasm() must be awaited first!");
15875 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone(orig);
15876 return nativeResponseValue;
15878 // void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
15880 export function CVec_UpdateAddHTLCZ_free(_res: number): void {
15881 if(!isWasmInitialized) {
15882 throw new Error("initializeWasm() must be awaited first!");
15884 const nativeResponseValue = wasm.TS_CVec_UpdateAddHTLCZ_free(_res);
15885 // debug statements here
15887 // void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
15889 export function CVec_UpdateFulfillHTLCZ_free(_res: number): void {
15890 if(!isWasmInitialized) {
15891 throw new Error("initializeWasm() must be awaited first!");
15893 const nativeResponseValue = wasm.TS_CVec_UpdateFulfillHTLCZ_free(_res);
15894 // debug statements here
15896 // void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
15898 export function CVec_UpdateFailHTLCZ_free(_res: number): void {
15899 if(!isWasmInitialized) {
15900 throw new Error("initializeWasm() must be awaited first!");
15902 const nativeResponseValue = wasm.TS_CVec_UpdateFailHTLCZ_free(_res);
15903 // debug statements here
15905 // void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
15907 export function CVec_UpdateFailMalformedHTLCZ_free(_res: number): void {
15908 if(!isWasmInitialized) {
15909 throw new Error("initializeWasm() must be awaited first!");
15911 const nativeResponseValue = wasm.TS_CVec_UpdateFailMalformedHTLCZ_free(_res);
15912 // debug statements here
15914 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
15916 export function CResult_AcceptChannelDecodeErrorZ_ok(o: bigint): bigint {
15917 if(!isWasmInitialized) {
15918 throw new Error("initializeWasm() must be awaited first!");
15920 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_ok(o);
15921 return nativeResponseValue;
15923 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
15925 export function CResult_AcceptChannelDecodeErrorZ_err(e: bigint): bigint {
15926 if(!isWasmInitialized) {
15927 throw new Error("initializeWasm() must be awaited first!");
15929 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_err(e);
15930 return nativeResponseValue;
15932 // bool CResult_AcceptChannelDecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR o);
15934 export function CResult_AcceptChannelDecodeErrorZ_is_ok(o: bigint): boolean {
15935 if(!isWasmInitialized) {
15936 throw new Error("initializeWasm() must be awaited first!");
15938 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_is_ok(o);
15939 return nativeResponseValue;
15941 // void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
15943 export function CResult_AcceptChannelDecodeErrorZ_free(_res: bigint): void {
15944 if(!isWasmInitialized) {
15945 throw new Error("initializeWasm() must be awaited first!");
15947 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_free(_res);
15948 // debug statements here
15950 // uint64_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg);
15952 export function CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15953 if(!isWasmInitialized) {
15954 throw new Error("initializeWasm() must be awaited first!");
15956 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg);
15957 return nativeResponseValue;
15959 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
15961 export function CResult_AcceptChannelDecodeErrorZ_clone(orig: bigint): bigint {
15962 if(!isWasmInitialized) {
15963 throw new Error("initializeWasm() must be awaited first!");
15965 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone(orig);
15966 return nativeResponseValue;
15968 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
15970 export function CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: bigint): bigint {
15971 if(!isWasmInitialized) {
15972 throw new Error("initializeWasm() must be awaited first!");
15974 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(o);
15975 return nativeResponseValue;
15977 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
15979 export function CResult_AnnouncementSignaturesDecodeErrorZ_err(e: bigint): bigint {
15980 if(!isWasmInitialized) {
15981 throw new Error("initializeWasm() must be awaited first!");
15983 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(e);
15984 return nativeResponseValue;
15986 // bool CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR o);
15988 export function CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o: bigint): boolean {
15989 if(!isWasmInitialized) {
15990 throw new Error("initializeWasm() must be awaited first!");
15992 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o);
15993 return nativeResponseValue;
15995 // void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
15997 export function CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: bigint): void {
15998 if(!isWasmInitialized) {
15999 throw new Error("initializeWasm() must be awaited first!");
16001 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(_res);
16002 // debug statements here
16004 // uint64_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg);
16006 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16007 if(!isWasmInitialized) {
16008 throw new Error("initializeWasm() must be awaited first!");
16010 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg);
16011 return nativeResponseValue;
16013 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
16015 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: bigint): bigint {
16016 if(!isWasmInitialized) {
16017 throw new Error("initializeWasm() must be awaited first!");
16019 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig);
16020 return nativeResponseValue;
16022 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
16024 export function CResult_ChannelReestablishDecodeErrorZ_ok(o: bigint): bigint {
16025 if(!isWasmInitialized) {
16026 throw new Error("initializeWasm() must be awaited first!");
16028 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_ok(o);
16029 return nativeResponseValue;
16031 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
16033 export function CResult_ChannelReestablishDecodeErrorZ_err(e: bigint): bigint {
16034 if(!isWasmInitialized) {
16035 throw new Error("initializeWasm() must be awaited first!");
16037 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_err(e);
16038 return nativeResponseValue;
16040 // bool CResult_ChannelReestablishDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR o);
16042 export function CResult_ChannelReestablishDecodeErrorZ_is_ok(o: bigint): boolean {
16043 if(!isWasmInitialized) {
16044 throw new Error("initializeWasm() must be awaited first!");
16046 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(o);
16047 return nativeResponseValue;
16049 // void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
16051 export function CResult_ChannelReestablishDecodeErrorZ_free(_res: bigint): void {
16052 if(!isWasmInitialized) {
16053 throw new Error("initializeWasm() must be awaited first!");
16055 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_free(_res);
16056 // debug statements here
16058 // uint64_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg);
16060 export function CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16061 if(!isWasmInitialized) {
16062 throw new Error("initializeWasm() must be awaited first!");
16064 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg);
16065 return nativeResponseValue;
16067 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
16069 export function CResult_ChannelReestablishDecodeErrorZ_clone(orig: bigint): bigint {
16070 if(!isWasmInitialized) {
16071 throw new Error("initializeWasm() must be awaited first!");
16073 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone(orig);
16074 return nativeResponseValue;
16076 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
16078 export function CResult_ClosingSignedDecodeErrorZ_ok(o: bigint): bigint {
16079 if(!isWasmInitialized) {
16080 throw new Error("initializeWasm() must be awaited first!");
16082 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_ok(o);
16083 return nativeResponseValue;
16085 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
16087 export function CResult_ClosingSignedDecodeErrorZ_err(e: bigint): bigint {
16088 if(!isWasmInitialized) {
16089 throw new Error("initializeWasm() must be awaited first!");
16091 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_err(e);
16092 return nativeResponseValue;
16094 // bool CResult_ClosingSignedDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR o);
16096 export function CResult_ClosingSignedDecodeErrorZ_is_ok(o: bigint): boolean {
16097 if(!isWasmInitialized) {
16098 throw new Error("initializeWasm() must be awaited first!");
16100 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_is_ok(o);
16101 return nativeResponseValue;
16103 // void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
16105 export function CResult_ClosingSignedDecodeErrorZ_free(_res: bigint): void {
16106 if(!isWasmInitialized) {
16107 throw new Error("initializeWasm() must be awaited first!");
16109 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_free(_res);
16110 // debug statements here
16112 // uint64_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg);
16114 export function CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16115 if(!isWasmInitialized) {
16116 throw new Error("initializeWasm() must be awaited first!");
16118 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg);
16119 return nativeResponseValue;
16121 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
16123 export function CResult_ClosingSignedDecodeErrorZ_clone(orig: bigint): bigint {
16124 if(!isWasmInitialized) {
16125 throw new Error("initializeWasm() must be awaited first!");
16127 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone(orig);
16128 return nativeResponseValue;
16130 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(struct LDKClosingSignedFeeRange o);
16132 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o: bigint): bigint {
16133 if(!isWasmInitialized) {
16134 throw new Error("initializeWasm() must be awaited first!");
16136 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o);
16137 return nativeResponseValue;
16139 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_err(struct LDKDecodeError e);
16141 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e: bigint): bigint {
16142 if(!isWasmInitialized) {
16143 throw new Error("initializeWasm() must be awaited first!");
16145 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e);
16146 return nativeResponseValue;
16148 // bool CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR o);
16150 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o: bigint): boolean {
16151 if(!isWasmInitialized) {
16152 throw new Error("initializeWasm() must be awaited first!");
16154 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o);
16155 return nativeResponseValue;
16157 // void CResult_ClosingSignedFeeRangeDecodeErrorZ_free(struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res);
16159 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res: bigint): void {
16160 if(!isWasmInitialized) {
16161 throw new Error("initializeWasm() must be awaited first!");
16163 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res);
16164 // debug statements here
16166 // uint64_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg);
16168 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16169 if(!isWasmInitialized) {
16170 throw new Error("initializeWasm() must be awaited first!");
16172 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg);
16173 return nativeResponseValue;
16175 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR orig);
16177 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig: bigint): bigint {
16178 if(!isWasmInitialized) {
16179 throw new Error("initializeWasm() must be awaited first!");
16181 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig);
16182 return nativeResponseValue;
16184 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
16186 export function CResult_CommitmentSignedDecodeErrorZ_ok(o: bigint): bigint {
16187 if(!isWasmInitialized) {
16188 throw new Error("initializeWasm() must be awaited first!");
16190 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_ok(o);
16191 return nativeResponseValue;
16193 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
16195 export function CResult_CommitmentSignedDecodeErrorZ_err(e: bigint): bigint {
16196 if(!isWasmInitialized) {
16197 throw new Error("initializeWasm() must be awaited first!");
16199 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_err(e);
16200 return nativeResponseValue;
16202 // bool CResult_CommitmentSignedDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR o);
16204 export function CResult_CommitmentSignedDecodeErrorZ_is_ok(o: bigint): boolean {
16205 if(!isWasmInitialized) {
16206 throw new Error("initializeWasm() must be awaited first!");
16208 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(o);
16209 return nativeResponseValue;
16211 // void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
16213 export function CResult_CommitmentSignedDecodeErrorZ_free(_res: bigint): void {
16214 if(!isWasmInitialized) {
16215 throw new Error("initializeWasm() must be awaited first!");
16217 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_free(_res);
16218 // debug statements here
16220 // uint64_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg);
16222 export function CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16223 if(!isWasmInitialized) {
16224 throw new Error("initializeWasm() must be awaited first!");
16226 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg);
16227 return nativeResponseValue;
16229 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
16231 export function CResult_CommitmentSignedDecodeErrorZ_clone(orig: bigint): bigint {
16232 if(!isWasmInitialized) {
16233 throw new Error("initializeWasm() must be awaited first!");
16235 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone(orig);
16236 return nativeResponseValue;
16238 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
16240 export function CResult_FundingCreatedDecodeErrorZ_ok(o: bigint): bigint {
16241 if(!isWasmInitialized) {
16242 throw new Error("initializeWasm() must be awaited first!");
16244 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_ok(o);
16245 return nativeResponseValue;
16247 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
16249 export function CResult_FundingCreatedDecodeErrorZ_err(e: bigint): bigint {
16250 if(!isWasmInitialized) {
16251 throw new Error("initializeWasm() must be awaited first!");
16253 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_err(e);
16254 return nativeResponseValue;
16256 // bool CResult_FundingCreatedDecodeErrorZ_is_ok(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR o);
16258 export function CResult_FundingCreatedDecodeErrorZ_is_ok(o: bigint): boolean {
16259 if(!isWasmInitialized) {
16260 throw new Error("initializeWasm() must be awaited first!");
16262 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_is_ok(o);
16263 return nativeResponseValue;
16265 // void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
16267 export function CResult_FundingCreatedDecodeErrorZ_free(_res: bigint): void {
16268 if(!isWasmInitialized) {
16269 throw new Error("initializeWasm() must be awaited first!");
16271 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_free(_res);
16272 // debug statements here
16274 // uint64_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg);
16276 export function CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16277 if(!isWasmInitialized) {
16278 throw new Error("initializeWasm() must be awaited first!");
16280 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg);
16281 return nativeResponseValue;
16283 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
16285 export function CResult_FundingCreatedDecodeErrorZ_clone(orig: bigint): bigint {
16286 if(!isWasmInitialized) {
16287 throw new Error("initializeWasm() must be awaited first!");
16289 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone(orig);
16290 return nativeResponseValue;
16292 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
16294 export function CResult_FundingSignedDecodeErrorZ_ok(o: bigint): bigint {
16295 if(!isWasmInitialized) {
16296 throw new Error("initializeWasm() must be awaited first!");
16298 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_ok(o);
16299 return nativeResponseValue;
16301 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
16303 export function CResult_FundingSignedDecodeErrorZ_err(e: bigint): bigint {
16304 if(!isWasmInitialized) {
16305 throw new Error("initializeWasm() must be awaited first!");
16307 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_err(e);
16308 return nativeResponseValue;
16310 // bool CResult_FundingSignedDecodeErrorZ_is_ok(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR o);
16312 export function CResult_FundingSignedDecodeErrorZ_is_ok(o: bigint): boolean {
16313 if(!isWasmInitialized) {
16314 throw new Error("initializeWasm() must be awaited first!");
16316 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_is_ok(o);
16317 return nativeResponseValue;
16319 // void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
16321 export function CResult_FundingSignedDecodeErrorZ_free(_res: bigint): void {
16322 if(!isWasmInitialized) {
16323 throw new Error("initializeWasm() must be awaited first!");
16325 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_free(_res);
16326 // debug statements here
16328 // uint64_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg);
16330 export function CResult_FundingSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16331 if(!isWasmInitialized) {
16332 throw new Error("initializeWasm() must be awaited first!");
16334 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(arg);
16335 return nativeResponseValue;
16337 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
16339 export function CResult_FundingSignedDecodeErrorZ_clone(orig: bigint): bigint {
16340 if(!isWasmInitialized) {
16341 throw new Error("initializeWasm() must be awaited first!");
16343 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone(orig);
16344 return nativeResponseValue;
16346 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_ok(struct LDKChannelReady o);
16348 export function CResult_ChannelReadyDecodeErrorZ_ok(o: bigint): bigint {
16349 if(!isWasmInitialized) {
16350 throw new Error("initializeWasm() must be awaited first!");
16352 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_ok(o);
16353 return nativeResponseValue;
16355 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_err(struct LDKDecodeError e);
16357 export function CResult_ChannelReadyDecodeErrorZ_err(e: bigint): bigint {
16358 if(!isWasmInitialized) {
16359 throw new Error("initializeWasm() must be awaited first!");
16361 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_err(e);
16362 return nativeResponseValue;
16364 // bool CResult_ChannelReadyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR o);
16366 export function CResult_ChannelReadyDecodeErrorZ_is_ok(o: bigint): boolean {
16367 if(!isWasmInitialized) {
16368 throw new Error("initializeWasm() must be awaited first!");
16370 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_is_ok(o);
16371 return nativeResponseValue;
16373 // void CResult_ChannelReadyDecodeErrorZ_free(struct LDKCResult_ChannelReadyDecodeErrorZ _res);
16375 export function CResult_ChannelReadyDecodeErrorZ_free(_res: bigint): void {
16376 if(!isWasmInitialized) {
16377 throw new Error("initializeWasm() must be awaited first!");
16379 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_free(_res);
16380 // debug statements here
16382 // uint64_t CResult_ChannelReadyDecodeErrorZ_clone_ptr(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR arg);
16384 export function CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16385 if(!isWasmInitialized) {
16386 throw new Error("initializeWasm() must be awaited first!");
16388 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg);
16389 return nativeResponseValue;
16391 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_clone(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR orig);
16393 export function CResult_ChannelReadyDecodeErrorZ_clone(orig: bigint): bigint {
16394 if(!isWasmInitialized) {
16395 throw new Error("initializeWasm() must be awaited first!");
16397 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone(orig);
16398 return nativeResponseValue;
16400 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
16402 export function CResult_InitDecodeErrorZ_ok(o: bigint): bigint {
16403 if(!isWasmInitialized) {
16404 throw new Error("initializeWasm() must be awaited first!");
16406 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_ok(o);
16407 return nativeResponseValue;
16409 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
16411 export function CResult_InitDecodeErrorZ_err(e: bigint): bigint {
16412 if(!isWasmInitialized) {
16413 throw new Error("initializeWasm() must be awaited first!");
16415 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_err(e);
16416 return nativeResponseValue;
16418 // bool CResult_InitDecodeErrorZ_is_ok(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR o);
16420 export function CResult_InitDecodeErrorZ_is_ok(o: bigint): boolean {
16421 if(!isWasmInitialized) {
16422 throw new Error("initializeWasm() must be awaited first!");
16424 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_is_ok(o);
16425 return nativeResponseValue;
16427 // void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
16429 export function CResult_InitDecodeErrorZ_free(_res: bigint): void {
16430 if(!isWasmInitialized) {
16431 throw new Error("initializeWasm() must be awaited first!");
16433 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_free(_res);
16434 // debug statements here
16436 // uint64_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg);
16438 export function CResult_InitDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16439 if(!isWasmInitialized) {
16440 throw new Error("initializeWasm() must be awaited first!");
16442 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone_ptr(arg);
16443 return nativeResponseValue;
16445 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
16447 export function CResult_InitDecodeErrorZ_clone(orig: bigint): bigint {
16448 if(!isWasmInitialized) {
16449 throw new Error("initializeWasm() must be awaited first!");
16451 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone(orig);
16452 return nativeResponseValue;
16454 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
16456 export function CResult_OpenChannelDecodeErrorZ_ok(o: bigint): bigint {
16457 if(!isWasmInitialized) {
16458 throw new Error("initializeWasm() must be awaited first!");
16460 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_ok(o);
16461 return nativeResponseValue;
16463 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
16465 export function CResult_OpenChannelDecodeErrorZ_err(e: bigint): bigint {
16466 if(!isWasmInitialized) {
16467 throw new Error("initializeWasm() must be awaited first!");
16469 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_err(e);
16470 return nativeResponseValue;
16472 // bool CResult_OpenChannelDecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR o);
16474 export function CResult_OpenChannelDecodeErrorZ_is_ok(o: bigint): boolean {
16475 if(!isWasmInitialized) {
16476 throw new Error("initializeWasm() must be awaited first!");
16478 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_is_ok(o);
16479 return nativeResponseValue;
16481 // void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
16483 export function CResult_OpenChannelDecodeErrorZ_free(_res: bigint): void {
16484 if(!isWasmInitialized) {
16485 throw new Error("initializeWasm() must be awaited first!");
16487 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_free(_res);
16488 // debug statements here
16490 // uint64_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg);
16492 export function CResult_OpenChannelDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16493 if(!isWasmInitialized) {
16494 throw new Error("initializeWasm() must be awaited first!");
16496 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(arg);
16497 return nativeResponseValue;
16499 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
16501 export function CResult_OpenChannelDecodeErrorZ_clone(orig: bigint): bigint {
16502 if(!isWasmInitialized) {
16503 throw new Error("initializeWasm() must be awaited first!");
16505 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone(orig);
16506 return nativeResponseValue;
16508 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
16510 export function CResult_RevokeAndACKDecodeErrorZ_ok(o: bigint): bigint {
16511 if(!isWasmInitialized) {
16512 throw new Error("initializeWasm() must be awaited first!");
16514 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_ok(o);
16515 return nativeResponseValue;
16517 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
16519 export function CResult_RevokeAndACKDecodeErrorZ_err(e: bigint): bigint {
16520 if(!isWasmInitialized) {
16521 throw new Error("initializeWasm() must be awaited first!");
16523 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_err(e);
16524 return nativeResponseValue;
16526 // bool CResult_RevokeAndACKDecodeErrorZ_is_ok(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR o);
16528 export function CResult_RevokeAndACKDecodeErrorZ_is_ok(o: bigint): boolean {
16529 if(!isWasmInitialized) {
16530 throw new Error("initializeWasm() must be awaited first!");
16532 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(o);
16533 return nativeResponseValue;
16535 // void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
16537 export function CResult_RevokeAndACKDecodeErrorZ_free(_res: bigint): void {
16538 if(!isWasmInitialized) {
16539 throw new Error("initializeWasm() must be awaited first!");
16541 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_free(_res);
16542 // debug statements here
16544 // uint64_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg);
16546 export function CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16547 if(!isWasmInitialized) {
16548 throw new Error("initializeWasm() must be awaited first!");
16550 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg);
16551 return nativeResponseValue;
16553 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
16555 export function CResult_RevokeAndACKDecodeErrorZ_clone(orig: bigint): bigint {
16556 if(!isWasmInitialized) {
16557 throw new Error("initializeWasm() must be awaited first!");
16559 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone(orig);
16560 return nativeResponseValue;
16562 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
16564 export function CResult_ShutdownDecodeErrorZ_ok(o: bigint): bigint {
16565 if(!isWasmInitialized) {
16566 throw new Error("initializeWasm() must be awaited first!");
16568 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_ok(o);
16569 return nativeResponseValue;
16571 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
16573 export function CResult_ShutdownDecodeErrorZ_err(e: bigint): bigint {
16574 if(!isWasmInitialized) {
16575 throw new Error("initializeWasm() must be awaited first!");
16577 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_err(e);
16578 return nativeResponseValue;
16580 // bool CResult_ShutdownDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR o);
16582 export function CResult_ShutdownDecodeErrorZ_is_ok(o: bigint): boolean {
16583 if(!isWasmInitialized) {
16584 throw new Error("initializeWasm() must be awaited first!");
16586 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_is_ok(o);
16587 return nativeResponseValue;
16589 // void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
16591 export function CResult_ShutdownDecodeErrorZ_free(_res: bigint): void {
16592 if(!isWasmInitialized) {
16593 throw new Error("initializeWasm() must be awaited first!");
16595 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_free(_res);
16596 // debug statements here
16598 // uint64_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg);
16600 export function CResult_ShutdownDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16601 if(!isWasmInitialized) {
16602 throw new Error("initializeWasm() must be awaited first!");
16604 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone_ptr(arg);
16605 return nativeResponseValue;
16607 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
16609 export function CResult_ShutdownDecodeErrorZ_clone(orig: bigint): bigint {
16610 if(!isWasmInitialized) {
16611 throw new Error("initializeWasm() must be awaited first!");
16613 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone(orig);
16614 return nativeResponseValue;
16616 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
16618 export function CResult_UpdateFailHTLCDecodeErrorZ_ok(o: bigint): bigint {
16619 if(!isWasmInitialized) {
16620 throw new Error("initializeWasm() must be awaited first!");
16622 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(o);
16623 return nativeResponseValue;
16625 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
16627 export function CResult_UpdateFailHTLCDecodeErrorZ_err(e: bigint): bigint {
16628 if(!isWasmInitialized) {
16629 throw new Error("initializeWasm() must be awaited first!");
16631 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_err(e);
16632 return nativeResponseValue;
16634 // bool CResult_UpdateFailHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR o);
16636 export function CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
16637 if(!isWasmInitialized) {
16638 throw new Error("initializeWasm() must be awaited first!");
16640 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o);
16641 return nativeResponseValue;
16643 // void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
16645 export function CResult_UpdateFailHTLCDecodeErrorZ_free(_res: bigint): void {
16646 if(!isWasmInitialized) {
16647 throw new Error("initializeWasm() must be awaited first!");
16649 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_free(_res);
16650 // debug statements here
16652 // uint64_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg);
16654 export function CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16655 if(!isWasmInitialized) {
16656 throw new Error("initializeWasm() must be awaited first!");
16658 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg);
16659 return nativeResponseValue;
16661 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
16663 export function CResult_UpdateFailHTLCDecodeErrorZ_clone(orig: bigint): bigint {
16664 if(!isWasmInitialized) {
16665 throw new Error("initializeWasm() must be awaited first!");
16667 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(orig);
16668 return nativeResponseValue;
16670 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
16672 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o: bigint): bigint {
16673 if(!isWasmInitialized) {
16674 throw new Error("initializeWasm() must be awaited first!");
16676 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o);
16677 return nativeResponseValue;
16679 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
16681 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e: bigint): bigint {
16682 if(!isWasmInitialized) {
16683 throw new Error("initializeWasm() must be awaited first!");
16685 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e);
16686 return nativeResponseValue;
16688 // bool CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR o);
16690 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
16691 if(!isWasmInitialized) {
16692 throw new Error("initializeWasm() must be awaited first!");
16694 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o);
16695 return nativeResponseValue;
16697 // void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
16699 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res: bigint): void {
16700 if(!isWasmInitialized) {
16701 throw new Error("initializeWasm() must be awaited first!");
16703 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res);
16704 // debug statements here
16706 // uint64_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg);
16708 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16709 if(!isWasmInitialized) {
16710 throw new Error("initializeWasm() must be awaited first!");
16712 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg);
16713 return nativeResponseValue;
16715 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
16717 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig: bigint): bigint {
16718 if(!isWasmInitialized) {
16719 throw new Error("initializeWasm() must be awaited first!");
16721 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig);
16722 return nativeResponseValue;
16724 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
16726 export function CResult_UpdateFeeDecodeErrorZ_ok(o: bigint): bigint {
16727 if(!isWasmInitialized) {
16728 throw new Error("initializeWasm() must be awaited first!");
16730 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_ok(o);
16731 return nativeResponseValue;
16733 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
16735 export function CResult_UpdateFeeDecodeErrorZ_err(e: bigint): bigint {
16736 if(!isWasmInitialized) {
16737 throw new Error("initializeWasm() must be awaited first!");
16739 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_err(e);
16740 return nativeResponseValue;
16742 // bool CResult_UpdateFeeDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR o);
16744 export function CResult_UpdateFeeDecodeErrorZ_is_ok(o: bigint): boolean {
16745 if(!isWasmInitialized) {
16746 throw new Error("initializeWasm() must be awaited first!");
16748 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_is_ok(o);
16749 return nativeResponseValue;
16751 // void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
16753 export function CResult_UpdateFeeDecodeErrorZ_free(_res: bigint): void {
16754 if(!isWasmInitialized) {
16755 throw new Error("initializeWasm() must be awaited first!");
16757 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_free(_res);
16758 // debug statements here
16760 // uint64_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg);
16762 export function CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16763 if(!isWasmInitialized) {
16764 throw new Error("initializeWasm() must be awaited first!");
16766 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg);
16767 return nativeResponseValue;
16769 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
16771 export function CResult_UpdateFeeDecodeErrorZ_clone(orig: bigint): bigint {
16772 if(!isWasmInitialized) {
16773 throw new Error("initializeWasm() must be awaited first!");
16775 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone(orig);
16776 return nativeResponseValue;
16778 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
16780 export function CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o: bigint): bigint {
16781 if(!isWasmInitialized) {
16782 throw new Error("initializeWasm() must be awaited first!");
16784 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o);
16785 return nativeResponseValue;
16787 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
16789 export function CResult_UpdateFulfillHTLCDecodeErrorZ_err(e: bigint): bigint {
16790 if(!isWasmInitialized) {
16791 throw new Error("initializeWasm() must be awaited first!");
16793 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(e);
16794 return nativeResponseValue;
16796 // bool CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR o);
16798 export function CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
16799 if(!isWasmInitialized) {
16800 throw new Error("initializeWasm() must be awaited first!");
16802 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o);
16803 return nativeResponseValue;
16805 // void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
16807 export function CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res: bigint): void {
16808 if(!isWasmInitialized) {
16809 throw new Error("initializeWasm() must be awaited first!");
16811 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res);
16812 // debug statements here
16814 // uint64_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg);
16816 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16817 if(!isWasmInitialized) {
16818 throw new Error("initializeWasm() must be awaited first!");
16820 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg);
16821 return nativeResponseValue;
16823 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
16825 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig: bigint): bigint {
16826 if(!isWasmInitialized) {
16827 throw new Error("initializeWasm() must be awaited first!");
16829 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig);
16830 return nativeResponseValue;
16832 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
16834 export function CResult_UpdateAddHTLCDecodeErrorZ_ok(o: bigint): bigint {
16835 if(!isWasmInitialized) {
16836 throw new Error("initializeWasm() must be awaited first!");
16838 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(o);
16839 return nativeResponseValue;
16841 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
16843 export function CResult_UpdateAddHTLCDecodeErrorZ_err(e: bigint): bigint {
16844 if(!isWasmInitialized) {
16845 throw new Error("initializeWasm() must be awaited first!");
16847 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_err(e);
16848 return nativeResponseValue;
16850 // bool CResult_UpdateAddHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR o);
16852 export function CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
16853 if(!isWasmInitialized) {
16854 throw new Error("initializeWasm() must be awaited first!");
16856 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o);
16857 return nativeResponseValue;
16859 // void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
16861 export function CResult_UpdateAddHTLCDecodeErrorZ_free(_res: bigint): void {
16862 if(!isWasmInitialized) {
16863 throw new Error("initializeWasm() must be awaited first!");
16865 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_free(_res);
16866 // debug statements here
16868 // uint64_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg);
16870 export function CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16871 if(!isWasmInitialized) {
16872 throw new Error("initializeWasm() must be awaited first!");
16874 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg);
16875 return nativeResponseValue;
16877 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
16879 export function CResult_UpdateAddHTLCDecodeErrorZ_clone(orig: bigint): bigint {
16880 if(!isWasmInitialized) {
16881 throw new Error("initializeWasm() must be awaited first!");
16883 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(orig);
16884 return nativeResponseValue;
16886 // struct LDKCResult_OnionMessageDecodeErrorZ CResult_OnionMessageDecodeErrorZ_ok(struct LDKOnionMessage o);
16888 export function CResult_OnionMessageDecodeErrorZ_ok(o: bigint): bigint {
16889 if(!isWasmInitialized) {
16890 throw new Error("initializeWasm() must be awaited first!");
16892 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_ok(o);
16893 return nativeResponseValue;
16895 // struct LDKCResult_OnionMessageDecodeErrorZ CResult_OnionMessageDecodeErrorZ_err(struct LDKDecodeError e);
16897 export function CResult_OnionMessageDecodeErrorZ_err(e: bigint): bigint {
16898 if(!isWasmInitialized) {
16899 throw new Error("initializeWasm() must be awaited first!");
16901 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_err(e);
16902 return nativeResponseValue;
16904 // bool CResult_OnionMessageDecodeErrorZ_is_ok(const struct LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR o);
16906 export function CResult_OnionMessageDecodeErrorZ_is_ok(o: bigint): boolean {
16907 if(!isWasmInitialized) {
16908 throw new Error("initializeWasm() must be awaited first!");
16910 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_is_ok(o);
16911 return nativeResponseValue;
16913 // void CResult_OnionMessageDecodeErrorZ_free(struct LDKCResult_OnionMessageDecodeErrorZ _res);
16915 export function CResult_OnionMessageDecodeErrorZ_free(_res: bigint): void {
16916 if(!isWasmInitialized) {
16917 throw new Error("initializeWasm() must be awaited first!");
16919 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_free(_res);
16920 // debug statements here
16922 // uint64_t CResult_OnionMessageDecodeErrorZ_clone_ptr(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR arg);
16924 export function CResult_OnionMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16925 if(!isWasmInitialized) {
16926 throw new Error("initializeWasm() must be awaited first!");
16928 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_clone_ptr(arg);
16929 return nativeResponseValue;
16931 // struct LDKCResult_OnionMessageDecodeErrorZ CResult_OnionMessageDecodeErrorZ_clone(const struct LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR orig);
16933 export function CResult_OnionMessageDecodeErrorZ_clone(orig: bigint): bigint {
16934 if(!isWasmInitialized) {
16935 throw new Error("initializeWasm() must be awaited first!");
16937 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_clone(orig);
16938 return nativeResponseValue;
16940 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
16942 export function CResult_PingDecodeErrorZ_ok(o: bigint): bigint {
16943 if(!isWasmInitialized) {
16944 throw new Error("initializeWasm() must be awaited first!");
16946 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_ok(o);
16947 return nativeResponseValue;
16949 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
16951 export function CResult_PingDecodeErrorZ_err(e: bigint): bigint {
16952 if(!isWasmInitialized) {
16953 throw new Error("initializeWasm() must be awaited first!");
16955 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_err(e);
16956 return nativeResponseValue;
16958 // bool CResult_PingDecodeErrorZ_is_ok(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR o);
16960 export function CResult_PingDecodeErrorZ_is_ok(o: bigint): boolean {
16961 if(!isWasmInitialized) {
16962 throw new Error("initializeWasm() must be awaited first!");
16964 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_is_ok(o);
16965 return nativeResponseValue;
16967 // void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
16969 export function CResult_PingDecodeErrorZ_free(_res: bigint): void {
16970 if(!isWasmInitialized) {
16971 throw new Error("initializeWasm() must be awaited first!");
16973 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_free(_res);
16974 // debug statements here
16976 // uint64_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg);
16978 export function CResult_PingDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16979 if(!isWasmInitialized) {
16980 throw new Error("initializeWasm() must be awaited first!");
16982 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone_ptr(arg);
16983 return nativeResponseValue;
16985 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
16987 export function CResult_PingDecodeErrorZ_clone(orig: bigint): bigint {
16988 if(!isWasmInitialized) {
16989 throw new Error("initializeWasm() must be awaited first!");
16991 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone(orig);
16992 return nativeResponseValue;
16994 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
16996 export function CResult_PongDecodeErrorZ_ok(o: bigint): bigint {
16997 if(!isWasmInitialized) {
16998 throw new Error("initializeWasm() must be awaited first!");
17000 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_ok(o);
17001 return nativeResponseValue;
17003 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
17005 export function CResult_PongDecodeErrorZ_err(e: bigint): bigint {
17006 if(!isWasmInitialized) {
17007 throw new Error("initializeWasm() must be awaited first!");
17009 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_err(e);
17010 return nativeResponseValue;
17012 // bool CResult_PongDecodeErrorZ_is_ok(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR o);
17014 export function CResult_PongDecodeErrorZ_is_ok(o: bigint): boolean {
17015 if(!isWasmInitialized) {
17016 throw new Error("initializeWasm() must be awaited first!");
17018 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_is_ok(o);
17019 return nativeResponseValue;
17021 // void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
17023 export function CResult_PongDecodeErrorZ_free(_res: bigint): void {
17024 if(!isWasmInitialized) {
17025 throw new Error("initializeWasm() must be awaited first!");
17027 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_free(_res);
17028 // debug statements here
17030 // uint64_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg);
17032 export function CResult_PongDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17033 if(!isWasmInitialized) {
17034 throw new Error("initializeWasm() must be awaited first!");
17036 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone_ptr(arg);
17037 return nativeResponseValue;
17039 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
17041 export function CResult_PongDecodeErrorZ_clone(orig: bigint): bigint {
17042 if(!isWasmInitialized) {
17043 throw new Error("initializeWasm() must be awaited first!");
17045 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone(orig);
17046 return nativeResponseValue;
17048 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
17050 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
17051 if(!isWasmInitialized) {
17052 throw new Error("initializeWasm() must be awaited first!");
17054 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o);
17055 return nativeResponseValue;
17057 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
17059 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e: bigint): bigint {
17060 if(!isWasmInitialized) {
17061 throw new Error("initializeWasm() must be awaited first!");
17063 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e);
17064 return nativeResponseValue;
17066 // bool CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
17068 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
17069 if(!isWasmInitialized) {
17070 throw new Error("initializeWasm() must be awaited first!");
17072 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o);
17073 return nativeResponseValue;
17075 // void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
17077 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res: bigint): void {
17078 if(!isWasmInitialized) {
17079 throw new Error("initializeWasm() must be awaited first!");
17081 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res);
17082 // debug statements here
17084 // uint64_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
17086 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17087 if(!isWasmInitialized) {
17088 throw new Error("initializeWasm() must be awaited first!");
17090 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
17091 return nativeResponseValue;
17093 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
17095 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
17096 if(!isWasmInitialized) {
17097 throw new Error("initializeWasm() must be awaited first!");
17099 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig);
17100 return nativeResponseValue;
17102 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
17104 export function CResult_ChannelAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
17105 if(!isWasmInitialized) {
17106 throw new Error("initializeWasm() must be awaited first!");
17108 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(o);
17109 return nativeResponseValue;
17111 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
17113 export function CResult_ChannelAnnouncementDecodeErrorZ_err(e: bigint): bigint {
17114 if(!isWasmInitialized) {
17115 throw new Error("initializeWasm() must be awaited first!");
17117 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_err(e);
17118 return nativeResponseValue;
17120 // bool CResult_ChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
17122 export function CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
17123 if(!isWasmInitialized) {
17124 throw new Error("initializeWasm() must be awaited first!");
17126 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o);
17127 return nativeResponseValue;
17129 // void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
17131 export function CResult_ChannelAnnouncementDecodeErrorZ_free(_res: bigint): void {
17132 if(!isWasmInitialized) {
17133 throw new Error("initializeWasm() must be awaited first!");
17135 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_free(_res);
17136 // debug statements here
17138 // uint64_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
17140 export function CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17141 if(!isWasmInitialized) {
17142 throw new Error("initializeWasm() must be awaited first!");
17144 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
17145 return nativeResponseValue;
17147 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
17149 export function CResult_ChannelAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
17150 if(!isWasmInitialized) {
17151 throw new Error("initializeWasm() must be awaited first!");
17153 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(orig);
17154 return nativeResponseValue;
17156 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
17158 export function CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o: bigint): bigint {
17159 if(!isWasmInitialized) {
17160 throw new Error("initializeWasm() must be awaited first!");
17162 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o);
17163 return nativeResponseValue;
17165 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
17167 export function CResult_UnsignedChannelUpdateDecodeErrorZ_err(e: bigint): bigint {
17168 if(!isWasmInitialized) {
17169 throw new Error("initializeWasm() must be awaited first!");
17171 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(e);
17172 return nativeResponseValue;
17174 // bool CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR o);
17176 export function CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
17177 if(!isWasmInitialized) {
17178 throw new Error("initializeWasm() must be awaited first!");
17180 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o);
17181 return nativeResponseValue;
17183 // void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
17185 export function CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res: bigint): void {
17186 if(!isWasmInitialized) {
17187 throw new Error("initializeWasm() must be awaited first!");
17189 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res);
17190 // debug statements here
17192 // uint64_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
17194 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17195 if(!isWasmInitialized) {
17196 throw new Error("initializeWasm() must be awaited first!");
17198 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg);
17199 return nativeResponseValue;
17201 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
17203 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig: bigint): bigint {
17204 if(!isWasmInitialized) {
17205 throw new Error("initializeWasm() must be awaited first!");
17207 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig);
17208 return nativeResponseValue;
17210 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
17212 export function CResult_ChannelUpdateDecodeErrorZ_ok(o: bigint): bigint {
17213 if(!isWasmInitialized) {
17214 throw new Error("initializeWasm() must be awaited first!");
17216 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_ok(o);
17217 return nativeResponseValue;
17219 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
17221 export function CResult_ChannelUpdateDecodeErrorZ_err(e: bigint): bigint {
17222 if(!isWasmInitialized) {
17223 throw new Error("initializeWasm() must be awaited first!");
17225 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_err(e);
17226 return nativeResponseValue;
17228 // bool CResult_ChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR o);
17230 export function CResult_ChannelUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
17231 if(!isWasmInitialized) {
17232 throw new Error("initializeWasm() must be awaited first!");
17234 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(o);
17235 return nativeResponseValue;
17237 // void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
17239 export function CResult_ChannelUpdateDecodeErrorZ_free(_res: bigint): void {
17240 if(!isWasmInitialized) {
17241 throw new Error("initializeWasm() must be awaited first!");
17243 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_free(_res);
17244 // debug statements here
17246 // uint64_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
17248 export function CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17249 if(!isWasmInitialized) {
17250 throw new Error("initializeWasm() must be awaited first!");
17252 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg);
17253 return nativeResponseValue;
17255 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
17257 export function CResult_ChannelUpdateDecodeErrorZ_clone(orig: bigint): bigint {
17258 if(!isWasmInitialized) {
17259 throw new Error("initializeWasm() must be awaited first!");
17261 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone(orig);
17262 return nativeResponseValue;
17264 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
17266 export function CResult_ErrorMessageDecodeErrorZ_ok(o: bigint): bigint {
17267 if(!isWasmInitialized) {
17268 throw new Error("initializeWasm() must be awaited first!");
17270 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_ok(o);
17271 return nativeResponseValue;
17273 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
17275 export function CResult_ErrorMessageDecodeErrorZ_err(e: bigint): bigint {
17276 if(!isWasmInitialized) {
17277 throw new Error("initializeWasm() must be awaited first!");
17279 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_err(e);
17280 return nativeResponseValue;
17282 // bool CResult_ErrorMessageDecodeErrorZ_is_ok(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR o);
17284 export function CResult_ErrorMessageDecodeErrorZ_is_ok(o: bigint): boolean {
17285 if(!isWasmInitialized) {
17286 throw new Error("initializeWasm() must be awaited first!");
17288 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_is_ok(o);
17289 return nativeResponseValue;
17291 // void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
17293 export function CResult_ErrorMessageDecodeErrorZ_free(_res: bigint): void {
17294 if(!isWasmInitialized) {
17295 throw new Error("initializeWasm() must be awaited first!");
17297 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_free(_res);
17298 // debug statements here
17300 // uint64_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg);
17302 export function CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17303 if(!isWasmInitialized) {
17304 throw new Error("initializeWasm() must be awaited first!");
17306 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg);
17307 return nativeResponseValue;
17309 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
17311 export function CResult_ErrorMessageDecodeErrorZ_clone(orig: bigint): bigint {
17312 if(!isWasmInitialized) {
17313 throw new Error("initializeWasm() must be awaited first!");
17315 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone(orig);
17316 return nativeResponseValue;
17318 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_ok(struct LDKWarningMessage o);
17320 export function CResult_WarningMessageDecodeErrorZ_ok(o: bigint): bigint {
17321 if(!isWasmInitialized) {
17322 throw new Error("initializeWasm() must be awaited first!");
17324 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_ok(o);
17325 return nativeResponseValue;
17327 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_err(struct LDKDecodeError e);
17329 export function CResult_WarningMessageDecodeErrorZ_err(e: bigint): bigint {
17330 if(!isWasmInitialized) {
17331 throw new Error("initializeWasm() must be awaited first!");
17333 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_err(e);
17334 return nativeResponseValue;
17336 // bool CResult_WarningMessageDecodeErrorZ_is_ok(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR o);
17338 export function CResult_WarningMessageDecodeErrorZ_is_ok(o: bigint): boolean {
17339 if(!isWasmInitialized) {
17340 throw new Error("initializeWasm() must be awaited first!");
17342 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_is_ok(o);
17343 return nativeResponseValue;
17345 // void CResult_WarningMessageDecodeErrorZ_free(struct LDKCResult_WarningMessageDecodeErrorZ _res);
17347 export function CResult_WarningMessageDecodeErrorZ_free(_res: bigint): void {
17348 if(!isWasmInitialized) {
17349 throw new Error("initializeWasm() must be awaited first!");
17351 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_free(_res);
17352 // debug statements here
17354 // uint64_t CResult_WarningMessageDecodeErrorZ_clone_ptr(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR arg);
17356 export function CResult_WarningMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17357 if(!isWasmInitialized) {
17358 throw new Error("initializeWasm() must be awaited first!");
17360 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone_ptr(arg);
17361 return nativeResponseValue;
17363 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_clone(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR orig);
17365 export function CResult_WarningMessageDecodeErrorZ_clone(orig: bigint): bigint {
17366 if(!isWasmInitialized) {
17367 throw new Error("initializeWasm() must be awaited first!");
17369 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone(orig);
17370 return nativeResponseValue;
17372 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
17374 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
17375 if(!isWasmInitialized) {
17376 throw new Error("initializeWasm() must be awaited first!");
17378 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o);
17379 return nativeResponseValue;
17381 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
17383 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e: bigint): bigint {
17384 if(!isWasmInitialized) {
17385 throw new Error("initializeWasm() must be awaited first!");
17387 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e);
17388 return nativeResponseValue;
17390 // bool CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
17392 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
17393 if(!isWasmInitialized) {
17394 throw new Error("initializeWasm() must be awaited first!");
17396 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o);
17397 return nativeResponseValue;
17399 // void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
17401 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res: bigint): void {
17402 if(!isWasmInitialized) {
17403 throw new Error("initializeWasm() must be awaited first!");
17405 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res);
17406 // debug statements here
17408 // uint64_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
17410 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17411 if(!isWasmInitialized) {
17412 throw new Error("initializeWasm() must be awaited first!");
17414 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg);
17415 return nativeResponseValue;
17417 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
17419 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
17420 if(!isWasmInitialized) {
17421 throw new Error("initializeWasm() must be awaited first!");
17423 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig);
17424 return nativeResponseValue;
17426 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
17428 export function CResult_NodeAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
17429 if(!isWasmInitialized) {
17430 throw new Error("initializeWasm() must be awaited first!");
17432 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_ok(o);
17433 return nativeResponseValue;
17435 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
17437 export function CResult_NodeAnnouncementDecodeErrorZ_err(e: bigint): bigint {
17438 if(!isWasmInitialized) {
17439 throw new Error("initializeWasm() must be awaited first!");
17441 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_err(e);
17442 return nativeResponseValue;
17444 // bool CResult_NodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
17446 export function CResult_NodeAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
17447 if(!isWasmInitialized) {
17448 throw new Error("initializeWasm() must be awaited first!");
17450 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(o);
17451 return nativeResponseValue;
17453 // void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
17455 export function CResult_NodeAnnouncementDecodeErrorZ_free(_res: bigint): void {
17456 if(!isWasmInitialized) {
17457 throw new Error("initializeWasm() must be awaited first!");
17459 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_free(_res);
17460 // debug statements here
17462 // uint64_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
17464 export function CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17465 if(!isWasmInitialized) {
17466 throw new Error("initializeWasm() must be awaited first!");
17468 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg);
17469 return nativeResponseValue;
17471 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
17473 export function CResult_NodeAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
17474 if(!isWasmInitialized) {
17475 throw new Error("initializeWasm() must be awaited first!");
17477 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone(orig);
17478 return nativeResponseValue;
17480 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
17482 export function CResult_QueryShortChannelIdsDecodeErrorZ_ok(o: bigint): bigint {
17483 if(!isWasmInitialized) {
17484 throw new Error("initializeWasm() must be awaited first!");
17486 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(o);
17487 return nativeResponseValue;
17489 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
17491 export function CResult_QueryShortChannelIdsDecodeErrorZ_err(e: bigint): bigint {
17492 if(!isWasmInitialized) {
17493 throw new Error("initializeWasm() must be awaited first!");
17495 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(e);
17496 return nativeResponseValue;
17498 // bool CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR o);
17500 export function CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o: bigint): boolean {
17501 if(!isWasmInitialized) {
17502 throw new Error("initializeWasm() must be awaited first!");
17504 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o);
17505 return nativeResponseValue;
17507 // void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
17509 export function CResult_QueryShortChannelIdsDecodeErrorZ_free(_res: bigint): void {
17510 if(!isWasmInitialized) {
17511 throw new Error("initializeWasm() must be awaited first!");
17513 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(_res);
17514 // debug statements here
17516 // uint64_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg);
17518 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17519 if(!isWasmInitialized) {
17520 throw new Error("initializeWasm() must be awaited first!");
17522 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg);
17523 return nativeResponseValue;
17525 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
17527 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig: bigint): bigint {
17528 if(!isWasmInitialized) {
17529 throw new Error("initializeWasm() must be awaited first!");
17531 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig);
17532 return nativeResponseValue;
17534 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
17536 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o: bigint): bigint {
17537 if(!isWasmInitialized) {
17538 throw new Error("initializeWasm() must be awaited first!");
17540 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o);
17541 return nativeResponseValue;
17543 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
17545 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e: bigint): bigint {
17546 if(!isWasmInitialized) {
17547 throw new Error("initializeWasm() must be awaited first!");
17549 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e);
17550 return nativeResponseValue;
17552 // bool CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR o);
17554 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o: bigint): boolean {
17555 if(!isWasmInitialized) {
17556 throw new Error("initializeWasm() must be awaited first!");
17558 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o);
17559 return nativeResponseValue;
17561 // void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
17563 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res: bigint): void {
17564 if(!isWasmInitialized) {
17565 throw new Error("initializeWasm() must be awaited first!");
17567 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res);
17568 // debug statements here
17570 // uint64_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg);
17572 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17573 if(!isWasmInitialized) {
17574 throw new Error("initializeWasm() must be awaited first!");
17576 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg);
17577 return nativeResponseValue;
17579 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
17581 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig: bigint): bigint {
17582 if(!isWasmInitialized) {
17583 throw new Error("initializeWasm() must be awaited first!");
17585 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig);
17586 return nativeResponseValue;
17588 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
17590 export function CResult_QueryChannelRangeDecodeErrorZ_ok(o: bigint): bigint {
17591 if(!isWasmInitialized) {
17592 throw new Error("initializeWasm() must be awaited first!");
17594 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_ok(o);
17595 return nativeResponseValue;
17597 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
17599 export function CResult_QueryChannelRangeDecodeErrorZ_err(e: bigint): bigint {
17600 if(!isWasmInitialized) {
17601 throw new Error("initializeWasm() must be awaited first!");
17603 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_err(e);
17604 return nativeResponseValue;
17606 // bool CResult_QueryChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR o);
17608 export function CResult_QueryChannelRangeDecodeErrorZ_is_ok(o: bigint): boolean {
17609 if(!isWasmInitialized) {
17610 throw new Error("initializeWasm() must be awaited first!");
17612 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(o);
17613 return nativeResponseValue;
17615 // void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
17617 export function CResult_QueryChannelRangeDecodeErrorZ_free(_res: bigint): void {
17618 if(!isWasmInitialized) {
17619 throw new Error("initializeWasm() must be awaited first!");
17621 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_free(_res);
17622 // debug statements here
17624 // uint64_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg);
17626 export function CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17627 if(!isWasmInitialized) {
17628 throw new Error("initializeWasm() must be awaited first!");
17630 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg);
17631 return nativeResponseValue;
17633 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
17635 export function CResult_QueryChannelRangeDecodeErrorZ_clone(orig: bigint): bigint {
17636 if(!isWasmInitialized) {
17637 throw new Error("initializeWasm() must be awaited first!");
17639 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone(orig);
17640 return nativeResponseValue;
17642 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
17644 export function CResult_ReplyChannelRangeDecodeErrorZ_ok(o: bigint): bigint {
17645 if(!isWasmInitialized) {
17646 throw new Error("initializeWasm() must be awaited first!");
17648 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(o);
17649 return nativeResponseValue;
17651 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
17653 export function CResult_ReplyChannelRangeDecodeErrorZ_err(e: bigint): bigint {
17654 if(!isWasmInitialized) {
17655 throw new Error("initializeWasm() must be awaited first!");
17657 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_err(e);
17658 return nativeResponseValue;
17660 // bool CResult_ReplyChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR o);
17662 export function CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o: bigint): boolean {
17663 if(!isWasmInitialized) {
17664 throw new Error("initializeWasm() must be awaited first!");
17666 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o);
17667 return nativeResponseValue;
17669 // void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
17671 export function CResult_ReplyChannelRangeDecodeErrorZ_free(_res: bigint): void {
17672 if(!isWasmInitialized) {
17673 throw new Error("initializeWasm() must be awaited first!");
17675 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_free(_res);
17676 // debug statements here
17678 // uint64_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg);
17680 export function CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17681 if(!isWasmInitialized) {
17682 throw new Error("initializeWasm() must be awaited first!");
17684 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg);
17685 return nativeResponseValue;
17687 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
17689 export function CResult_ReplyChannelRangeDecodeErrorZ_clone(orig: bigint): bigint {
17690 if(!isWasmInitialized) {
17691 throw new Error("initializeWasm() must be awaited first!");
17693 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(orig);
17694 return nativeResponseValue;
17696 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
17698 export function CResult_GossipTimestampFilterDecodeErrorZ_ok(o: bigint): bigint {
17699 if(!isWasmInitialized) {
17700 throw new Error("initializeWasm() must be awaited first!");
17702 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(o);
17703 return nativeResponseValue;
17705 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
17707 export function CResult_GossipTimestampFilterDecodeErrorZ_err(e: bigint): bigint {
17708 if(!isWasmInitialized) {
17709 throw new Error("initializeWasm() must be awaited first!");
17711 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_err(e);
17712 return nativeResponseValue;
17714 // bool CResult_GossipTimestampFilterDecodeErrorZ_is_ok(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR o);
17716 export function CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o: bigint): boolean {
17717 if(!isWasmInitialized) {
17718 throw new Error("initializeWasm() must be awaited first!");
17720 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o);
17721 return nativeResponseValue;
17723 // void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
17725 export function CResult_GossipTimestampFilterDecodeErrorZ_free(_res: bigint): void {
17726 if(!isWasmInitialized) {
17727 throw new Error("initializeWasm() must be awaited first!");
17729 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_free(_res);
17730 // debug statements here
17732 // uint64_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg);
17734 export function CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17735 if(!isWasmInitialized) {
17736 throw new Error("initializeWasm() must be awaited first!");
17738 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg);
17739 return nativeResponseValue;
17741 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
17743 export function CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: bigint): bigint {
17744 if(!isWasmInitialized) {
17745 throw new Error("initializeWasm() must be awaited first!");
17747 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(orig);
17748 return nativeResponseValue;
17750 // void CVec_PhantomRouteHintsZ_free(struct LDKCVec_PhantomRouteHintsZ _res);
17752 export function CVec_PhantomRouteHintsZ_free(_res: number): void {
17753 if(!isWasmInitialized) {
17754 throw new Error("initializeWasm() must be awaited first!");
17756 const nativeResponseValue = wasm.TS_CVec_PhantomRouteHintsZ_free(_res);
17757 // debug statements here
17759 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_ok(struct LDKInvoice o);
17761 export function CResult_InvoiceSignOrCreationErrorZ_ok(o: bigint): bigint {
17762 if(!isWasmInitialized) {
17763 throw new Error("initializeWasm() must be awaited first!");
17765 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_ok(o);
17766 return nativeResponseValue;
17768 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_err(struct LDKSignOrCreationError e);
17770 export function CResult_InvoiceSignOrCreationErrorZ_err(e: bigint): bigint {
17771 if(!isWasmInitialized) {
17772 throw new Error("initializeWasm() must be awaited first!");
17774 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_err(e);
17775 return nativeResponseValue;
17777 // bool CResult_InvoiceSignOrCreationErrorZ_is_ok(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR o);
17779 export function CResult_InvoiceSignOrCreationErrorZ_is_ok(o: bigint): boolean {
17780 if(!isWasmInitialized) {
17781 throw new Error("initializeWasm() must be awaited first!");
17783 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_is_ok(o);
17784 return nativeResponseValue;
17786 // void CResult_InvoiceSignOrCreationErrorZ_free(struct LDKCResult_InvoiceSignOrCreationErrorZ _res);
17788 export function CResult_InvoiceSignOrCreationErrorZ_free(_res: bigint): void {
17789 if(!isWasmInitialized) {
17790 throw new Error("initializeWasm() must be awaited first!");
17792 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_free(_res);
17793 // debug statements here
17795 // uint64_t CResult_InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR arg);
17797 export function CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg: bigint): bigint {
17798 if(!isWasmInitialized) {
17799 throw new Error("initializeWasm() must be awaited first!");
17801 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg);
17802 return nativeResponseValue;
17804 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_clone(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR orig);
17806 export function CResult_InvoiceSignOrCreationErrorZ_clone(orig: bigint): bigint {
17807 if(!isWasmInitialized) {
17808 throw new Error("initializeWasm() must be awaited first!");
17810 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone(orig);
17811 return nativeResponseValue;
17813 // struct LDKCOption_FilterZ COption_FilterZ_some(struct LDKFilter o);
17815 export function COption_FilterZ_some(o: bigint): bigint {
17816 if(!isWasmInitialized) {
17817 throw new Error("initializeWasm() must be awaited first!");
17819 const nativeResponseValue = wasm.TS_COption_FilterZ_some(o);
17820 return nativeResponseValue;
17822 // struct LDKCOption_FilterZ COption_FilterZ_none(void);
17824 export function COption_FilterZ_none(): bigint {
17825 if(!isWasmInitialized) {
17826 throw new Error("initializeWasm() must be awaited first!");
17828 const nativeResponseValue = wasm.TS_COption_FilterZ_none();
17829 return nativeResponseValue;
17831 // void COption_FilterZ_free(struct LDKCOption_FilterZ _res);
17833 export function COption_FilterZ_free(_res: bigint): void {
17834 if(!isWasmInitialized) {
17835 throw new Error("initializeWasm() must be awaited first!");
17837 const nativeResponseValue = wasm.TS_COption_FilterZ_free(_res);
17838 // debug statements here
17840 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_ok(struct LDKLockedChannelMonitor o);
17842 export function CResult_LockedChannelMonitorNoneZ_ok(o: bigint): bigint {
17843 if(!isWasmInitialized) {
17844 throw new Error("initializeWasm() must be awaited first!");
17846 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_ok(o);
17847 return nativeResponseValue;
17849 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_err(void);
17851 export function CResult_LockedChannelMonitorNoneZ_err(): bigint {
17852 if(!isWasmInitialized) {
17853 throw new Error("initializeWasm() must be awaited first!");
17855 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_err();
17856 return nativeResponseValue;
17858 // bool CResult_LockedChannelMonitorNoneZ_is_ok(const struct LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR o);
17860 export function CResult_LockedChannelMonitorNoneZ_is_ok(o: bigint): boolean {
17861 if(!isWasmInitialized) {
17862 throw new Error("initializeWasm() must be awaited first!");
17864 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_is_ok(o);
17865 return nativeResponseValue;
17867 // void CResult_LockedChannelMonitorNoneZ_free(struct LDKCResult_LockedChannelMonitorNoneZ _res);
17869 export function CResult_LockedChannelMonitorNoneZ_free(_res: bigint): void {
17870 if(!isWasmInitialized) {
17871 throw new Error("initializeWasm() must be awaited first!");
17873 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_free(_res);
17874 // debug statements here
17876 // void CVec_OutPointZ_free(struct LDKCVec_OutPointZ _res);
17878 export function CVec_OutPointZ_free(_res: number): void {
17879 if(!isWasmInitialized) {
17880 throw new Error("initializeWasm() must be awaited first!");
17882 const nativeResponseValue = wasm.TS_CVec_OutPointZ_free(_res);
17883 // debug statements here
17885 // void CVec_MonitorUpdateIdZ_free(struct LDKCVec_MonitorUpdateIdZ _res);
17887 export function CVec_MonitorUpdateIdZ_free(_res: number): void {
17888 if(!isWasmInitialized) {
17889 throw new Error("initializeWasm() must be awaited first!");
17891 const nativeResponseValue = wasm.TS_CVec_MonitorUpdateIdZ_free(_res);
17892 // debug statements here
17894 // uint64_t C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR arg);
17896 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(arg: bigint): bigint {
17897 if(!isWasmInitialized) {
17898 throw new Error("initializeWasm() must be awaited first!");
17900 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(arg);
17901 return nativeResponseValue;
17903 // struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(const struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR orig);
17905 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(orig: bigint): bigint {
17906 if(!isWasmInitialized) {
17907 throw new Error("initializeWasm() must be awaited first!");
17909 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(orig);
17910 return nativeResponseValue;
17912 // struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(struct LDKOutPoint a, struct LDKCVec_MonitorUpdateIdZ b);
17914 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(a: bigint, b: number): bigint {
17915 if(!isWasmInitialized) {
17916 throw new Error("initializeWasm() must be awaited first!");
17918 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(a, b);
17919 return nativeResponseValue;
17921 // void C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ _res);
17923 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(_res: bigint): void {
17924 if(!isWasmInitialized) {
17925 throw new Error("initializeWasm() must be awaited first!");
17927 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(_res);
17928 // debug statements here
17930 // void CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(struct LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ _res);
17932 export function CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(_res: number): void {
17933 if(!isWasmInitialized) {
17934 throw new Error("initializeWasm() must be awaited first!");
17936 const nativeResponseValue = wasm.TS_CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(_res);
17937 // debug statements here
17939 // void PaymentPurpose_free(struct LDKPaymentPurpose this_ptr);
17941 export function PaymentPurpose_free(this_ptr: bigint): void {
17942 if(!isWasmInitialized) {
17943 throw new Error("initializeWasm() must be awaited first!");
17945 const nativeResponseValue = wasm.TS_PaymentPurpose_free(this_ptr);
17946 // debug statements here
17948 // uint64_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg);
17950 export function PaymentPurpose_clone_ptr(arg: bigint): bigint {
17951 if(!isWasmInitialized) {
17952 throw new Error("initializeWasm() must be awaited first!");
17954 const nativeResponseValue = wasm.TS_PaymentPurpose_clone_ptr(arg);
17955 return nativeResponseValue;
17957 // struct LDKPaymentPurpose PaymentPurpose_clone(const struct LDKPaymentPurpose *NONNULL_PTR orig);
17959 export function PaymentPurpose_clone(orig: bigint): bigint {
17960 if(!isWasmInitialized) {
17961 throw new Error("initializeWasm() must be awaited first!");
17963 const nativeResponseValue = wasm.TS_PaymentPurpose_clone(orig);
17964 return nativeResponseValue;
17966 // struct LDKPaymentPurpose PaymentPurpose_invoice_payment(struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_secret);
17968 export function PaymentPurpose_invoice_payment(payment_preimage: number, payment_secret: number): bigint {
17969 if(!isWasmInitialized) {
17970 throw new Error("initializeWasm() must be awaited first!");
17972 const nativeResponseValue = wasm.TS_PaymentPurpose_invoice_payment(payment_preimage, payment_secret);
17973 return nativeResponseValue;
17975 // struct LDKPaymentPurpose PaymentPurpose_spontaneous_payment(struct LDKThirtyTwoBytes a);
17977 export function PaymentPurpose_spontaneous_payment(a: number): bigint {
17978 if(!isWasmInitialized) {
17979 throw new Error("initializeWasm() must be awaited first!");
17981 const nativeResponseValue = wasm.TS_PaymentPurpose_spontaneous_payment(a);
17982 return nativeResponseValue;
17984 // bool PaymentPurpose_eq(const struct LDKPaymentPurpose *NONNULL_PTR a, const struct LDKPaymentPurpose *NONNULL_PTR b);
17986 export function PaymentPurpose_eq(a: bigint, b: bigint): boolean {
17987 if(!isWasmInitialized) {
17988 throw new Error("initializeWasm() must be awaited first!");
17990 const nativeResponseValue = wasm.TS_PaymentPurpose_eq(a, b);
17991 return nativeResponseValue;
17993 // struct LDKCVec_u8Z PaymentPurpose_write(const struct LDKPaymentPurpose *NONNULL_PTR obj);
17995 export function PaymentPurpose_write(obj: bigint): number {
17996 if(!isWasmInitialized) {
17997 throw new Error("initializeWasm() must be awaited first!");
17999 const nativeResponseValue = wasm.TS_PaymentPurpose_write(obj);
18000 return nativeResponseValue;
18002 // struct LDKCResult_PaymentPurposeDecodeErrorZ PaymentPurpose_read(struct LDKu8slice ser);
18004 export function PaymentPurpose_read(ser: number): bigint {
18005 if(!isWasmInitialized) {
18006 throw new Error("initializeWasm() must be awaited first!");
18008 const nativeResponseValue = wasm.TS_PaymentPurpose_read(ser);
18009 return nativeResponseValue;
18011 // void PathFailure_free(struct LDKPathFailure this_ptr);
18013 export function PathFailure_free(this_ptr: bigint): void {
18014 if(!isWasmInitialized) {
18015 throw new Error("initializeWasm() must be awaited first!");
18017 const nativeResponseValue = wasm.TS_PathFailure_free(this_ptr);
18018 // debug statements here
18020 // uint64_t PathFailure_clone_ptr(LDKPathFailure *NONNULL_PTR arg);
18022 export function PathFailure_clone_ptr(arg: bigint): bigint {
18023 if(!isWasmInitialized) {
18024 throw new Error("initializeWasm() must be awaited first!");
18026 const nativeResponseValue = wasm.TS_PathFailure_clone_ptr(arg);
18027 return nativeResponseValue;
18029 // struct LDKPathFailure PathFailure_clone(const struct LDKPathFailure *NONNULL_PTR orig);
18031 export function PathFailure_clone(orig: bigint): bigint {
18032 if(!isWasmInitialized) {
18033 throw new Error("initializeWasm() must be awaited first!");
18035 const nativeResponseValue = wasm.TS_PathFailure_clone(orig);
18036 return nativeResponseValue;
18038 // struct LDKPathFailure PathFailure_initial_send(struct LDKAPIError err);
18040 export function PathFailure_initial_send(err: bigint): bigint {
18041 if(!isWasmInitialized) {
18042 throw new Error("initializeWasm() must be awaited first!");
18044 const nativeResponseValue = wasm.TS_PathFailure_initial_send(err);
18045 return nativeResponseValue;
18047 // struct LDKPathFailure PathFailure_on_path(struct LDKCOption_NetworkUpdateZ network_update);
18049 export function PathFailure_on_path(network_update: bigint): bigint {
18050 if(!isWasmInitialized) {
18051 throw new Error("initializeWasm() must be awaited first!");
18053 const nativeResponseValue = wasm.TS_PathFailure_on_path(network_update);
18054 return nativeResponseValue;
18056 // bool PathFailure_eq(const struct LDKPathFailure *NONNULL_PTR a, const struct LDKPathFailure *NONNULL_PTR b);
18058 export function PathFailure_eq(a: bigint, b: bigint): boolean {
18059 if(!isWasmInitialized) {
18060 throw new Error("initializeWasm() must be awaited first!");
18062 const nativeResponseValue = wasm.TS_PathFailure_eq(a, b);
18063 return nativeResponseValue;
18065 // struct LDKCVec_u8Z PathFailure_write(const struct LDKPathFailure *NONNULL_PTR obj);
18067 export function PathFailure_write(obj: bigint): number {
18068 if(!isWasmInitialized) {
18069 throw new Error("initializeWasm() must be awaited first!");
18071 const nativeResponseValue = wasm.TS_PathFailure_write(obj);
18072 return nativeResponseValue;
18074 // struct LDKCResult_COption_PathFailureZDecodeErrorZ PathFailure_read(struct LDKu8slice ser);
18076 export function PathFailure_read(ser: number): bigint {
18077 if(!isWasmInitialized) {
18078 throw new Error("initializeWasm() must be awaited first!");
18080 const nativeResponseValue = wasm.TS_PathFailure_read(ser);
18081 return nativeResponseValue;
18083 // void ClosureReason_free(struct LDKClosureReason this_ptr);
18085 export function ClosureReason_free(this_ptr: bigint): void {
18086 if(!isWasmInitialized) {
18087 throw new Error("initializeWasm() must be awaited first!");
18089 const nativeResponseValue = wasm.TS_ClosureReason_free(this_ptr);
18090 // debug statements here
18092 // uint64_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg);
18094 export function ClosureReason_clone_ptr(arg: bigint): bigint {
18095 if(!isWasmInitialized) {
18096 throw new Error("initializeWasm() must be awaited first!");
18098 const nativeResponseValue = wasm.TS_ClosureReason_clone_ptr(arg);
18099 return nativeResponseValue;
18101 // struct LDKClosureReason ClosureReason_clone(const struct LDKClosureReason *NONNULL_PTR orig);
18103 export function ClosureReason_clone(orig: bigint): bigint {
18104 if(!isWasmInitialized) {
18105 throw new Error("initializeWasm() must be awaited first!");
18107 const nativeResponseValue = wasm.TS_ClosureReason_clone(orig);
18108 return nativeResponseValue;
18110 // struct LDKClosureReason ClosureReason_counterparty_force_closed(struct LDKStr peer_msg);
18112 export function ClosureReason_counterparty_force_closed(peer_msg: number): bigint {
18113 if(!isWasmInitialized) {
18114 throw new Error("initializeWasm() must be awaited first!");
18116 const nativeResponseValue = wasm.TS_ClosureReason_counterparty_force_closed(peer_msg);
18117 return nativeResponseValue;
18119 // struct LDKClosureReason ClosureReason_holder_force_closed(void);
18121 export function ClosureReason_holder_force_closed(): bigint {
18122 if(!isWasmInitialized) {
18123 throw new Error("initializeWasm() must be awaited first!");
18125 const nativeResponseValue = wasm.TS_ClosureReason_holder_force_closed();
18126 return nativeResponseValue;
18128 // struct LDKClosureReason ClosureReason_cooperative_closure(void);
18130 export function ClosureReason_cooperative_closure(): bigint {
18131 if(!isWasmInitialized) {
18132 throw new Error("initializeWasm() must be awaited first!");
18134 const nativeResponseValue = wasm.TS_ClosureReason_cooperative_closure();
18135 return nativeResponseValue;
18137 // struct LDKClosureReason ClosureReason_commitment_tx_confirmed(void);
18139 export function ClosureReason_commitment_tx_confirmed(): bigint {
18140 if(!isWasmInitialized) {
18141 throw new Error("initializeWasm() must be awaited first!");
18143 const nativeResponseValue = wasm.TS_ClosureReason_commitment_tx_confirmed();
18144 return nativeResponseValue;
18146 // struct LDKClosureReason ClosureReason_funding_timed_out(void);
18148 export function ClosureReason_funding_timed_out(): bigint {
18149 if(!isWasmInitialized) {
18150 throw new Error("initializeWasm() must be awaited first!");
18152 const nativeResponseValue = wasm.TS_ClosureReason_funding_timed_out();
18153 return nativeResponseValue;
18155 // struct LDKClosureReason ClosureReason_processing_error(struct LDKStr err);
18157 export function ClosureReason_processing_error(err: number): bigint {
18158 if(!isWasmInitialized) {
18159 throw new Error("initializeWasm() must be awaited first!");
18161 const nativeResponseValue = wasm.TS_ClosureReason_processing_error(err);
18162 return nativeResponseValue;
18164 // struct LDKClosureReason ClosureReason_disconnected_peer(void);
18166 export function ClosureReason_disconnected_peer(): bigint {
18167 if(!isWasmInitialized) {
18168 throw new Error("initializeWasm() must be awaited first!");
18170 const nativeResponseValue = wasm.TS_ClosureReason_disconnected_peer();
18171 return nativeResponseValue;
18173 // struct LDKClosureReason ClosureReason_outdated_channel_manager(void);
18175 export function ClosureReason_outdated_channel_manager(): bigint {
18176 if(!isWasmInitialized) {
18177 throw new Error("initializeWasm() must be awaited first!");
18179 const nativeResponseValue = wasm.TS_ClosureReason_outdated_channel_manager();
18180 return nativeResponseValue;
18182 // bool ClosureReason_eq(const struct LDKClosureReason *NONNULL_PTR a, const struct LDKClosureReason *NONNULL_PTR b);
18184 export function ClosureReason_eq(a: bigint, b: bigint): boolean {
18185 if(!isWasmInitialized) {
18186 throw new Error("initializeWasm() must be awaited first!");
18188 const nativeResponseValue = wasm.TS_ClosureReason_eq(a, b);
18189 return nativeResponseValue;
18191 // struct LDKCVec_u8Z ClosureReason_write(const struct LDKClosureReason *NONNULL_PTR obj);
18193 export function ClosureReason_write(obj: bigint): number {
18194 if(!isWasmInitialized) {
18195 throw new Error("initializeWasm() must be awaited first!");
18197 const nativeResponseValue = wasm.TS_ClosureReason_write(obj);
18198 return nativeResponseValue;
18200 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ ClosureReason_read(struct LDKu8slice ser);
18202 export function ClosureReason_read(ser: number): bigint {
18203 if(!isWasmInitialized) {
18204 throw new Error("initializeWasm() must be awaited first!");
18206 const nativeResponseValue = wasm.TS_ClosureReason_read(ser);
18207 return nativeResponseValue;
18209 // void HTLCDestination_free(struct LDKHTLCDestination this_ptr);
18211 export function HTLCDestination_free(this_ptr: bigint): void {
18212 if(!isWasmInitialized) {
18213 throw new Error("initializeWasm() must be awaited first!");
18215 const nativeResponseValue = wasm.TS_HTLCDestination_free(this_ptr);
18216 // debug statements here
18218 // uint64_t HTLCDestination_clone_ptr(LDKHTLCDestination *NONNULL_PTR arg);
18220 export function HTLCDestination_clone_ptr(arg: bigint): bigint {
18221 if(!isWasmInitialized) {
18222 throw new Error("initializeWasm() must be awaited first!");
18224 const nativeResponseValue = wasm.TS_HTLCDestination_clone_ptr(arg);
18225 return nativeResponseValue;
18227 // struct LDKHTLCDestination HTLCDestination_clone(const struct LDKHTLCDestination *NONNULL_PTR orig);
18229 export function HTLCDestination_clone(orig: bigint): bigint {
18230 if(!isWasmInitialized) {
18231 throw new Error("initializeWasm() must be awaited first!");
18233 const nativeResponseValue = wasm.TS_HTLCDestination_clone(orig);
18234 return nativeResponseValue;
18236 // struct LDKHTLCDestination HTLCDestination_next_hop_channel(struct LDKPublicKey node_id, struct LDKThirtyTwoBytes channel_id);
18238 export function HTLCDestination_next_hop_channel(node_id: number, channel_id: number): bigint {
18239 if(!isWasmInitialized) {
18240 throw new Error("initializeWasm() must be awaited first!");
18242 const nativeResponseValue = wasm.TS_HTLCDestination_next_hop_channel(node_id, channel_id);
18243 return nativeResponseValue;
18245 // struct LDKHTLCDestination HTLCDestination_unknown_next_hop(uint64_t requested_forward_scid);
18247 export function HTLCDestination_unknown_next_hop(requested_forward_scid: bigint): bigint {
18248 if(!isWasmInitialized) {
18249 throw new Error("initializeWasm() must be awaited first!");
18251 const nativeResponseValue = wasm.TS_HTLCDestination_unknown_next_hop(requested_forward_scid);
18252 return nativeResponseValue;
18254 // struct LDKHTLCDestination HTLCDestination_invalid_forward(uint64_t requested_forward_scid);
18256 export function HTLCDestination_invalid_forward(requested_forward_scid: bigint): bigint {
18257 if(!isWasmInitialized) {
18258 throw new Error("initializeWasm() must be awaited first!");
18260 const nativeResponseValue = wasm.TS_HTLCDestination_invalid_forward(requested_forward_scid);
18261 return nativeResponseValue;
18263 // struct LDKHTLCDestination HTLCDestination_failed_payment(struct LDKThirtyTwoBytes payment_hash);
18265 export function HTLCDestination_failed_payment(payment_hash: number): bigint {
18266 if(!isWasmInitialized) {
18267 throw new Error("initializeWasm() must be awaited first!");
18269 const nativeResponseValue = wasm.TS_HTLCDestination_failed_payment(payment_hash);
18270 return nativeResponseValue;
18272 // bool HTLCDestination_eq(const struct LDKHTLCDestination *NONNULL_PTR a, const struct LDKHTLCDestination *NONNULL_PTR b);
18274 export function HTLCDestination_eq(a: bigint, b: bigint): boolean {
18275 if(!isWasmInitialized) {
18276 throw new Error("initializeWasm() must be awaited first!");
18278 const nativeResponseValue = wasm.TS_HTLCDestination_eq(a, b);
18279 return nativeResponseValue;
18281 // struct LDKCVec_u8Z HTLCDestination_write(const struct LDKHTLCDestination *NONNULL_PTR obj);
18283 export function HTLCDestination_write(obj: bigint): number {
18284 if(!isWasmInitialized) {
18285 throw new Error("initializeWasm() must be awaited first!");
18287 const nativeResponseValue = wasm.TS_HTLCDestination_write(obj);
18288 return nativeResponseValue;
18290 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ HTLCDestination_read(struct LDKu8slice ser);
18292 export function HTLCDestination_read(ser: number): bigint {
18293 if(!isWasmInitialized) {
18294 throw new Error("initializeWasm() must be awaited first!");
18296 const nativeResponseValue = wasm.TS_HTLCDestination_read(ser);
18297 return nativeResponseValue;
18299 // void Event_free(struct LDKEvent this_ptr);
18301 export function Event_free(this_ptr: bigint): void {
18302 if(!isWasmInitialized) {
18303 throw new Error("initializeWasm() must be awaited first!");
18305 const nativeResponseValue = wasm.TS_Event_free(this_ptr);
18306 // debug statements here
18308 // uint64_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg);
18310 export function Event_clone_ptr(arg: bigint): bigint {
18311 if(!isWasmInitialized) {
18312 throw new Error("initializeWasm() must be awaited first!");
18314 const nativeResponseValue = wasm.TS_Event_clone_ptr(arg);
18315 return nativeResponseValue;
18317 // struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
18319 export function Event_clone(orig: bigint): bigint {
18320 if(!isWasmInitialized) {
18321 throw new Error("initializeWasm() must be awaited first!");
18323 const nativeResponseValue = wasm.TS_Event_clone(orig);
18324 return nativeResponseValue;
18326 // 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, struct LDKU128 user_channel_id);
18328 export function Event_funding_generation_ready(temporary_channel_id: number, counterparty_node_id: number, channel_value_satoshis: bigint, output_script: number, user_channel_id: number): bigint {
18329 if(!isWasmInitialized) {
18330 throw new Error("initializeWasm() must be awaited first!");
18332 const nativeResponseValue = wasm.TS_Event_funding_generation_ready(temporary_channel_id, counterparty_node_id, channel_value_satoshis, output_script, user_channel_id);
18333 return nativeResponseValue;
18335 // struct LDKEvent Event_payment_claimable(struct LDKPublicKey receiver_node_id, struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose, struct LDKThirtyTwoBytes via_channel_id, struct LDKCOption_u128Z via_user_channel_id);
18337 export function Event_payment_claimable(receiver_node_id: number, payment_hash: number, amount_msat: bigint, purpose: bigint, via_channel_id: number, via_user_channel_id: bigint): bigint {
18338 if(!isWasmInitialized) {
18339 throw new Error("initializeWasm() must be awaited first!");
18341 const nativeResponseValue = wasm.TS_Event_payment_claimable(receiver_node_id, payment_hash, amount_msat, purpose, via_channel_id, via_user_channel_id);
18342 return nativeResponseValue;
18344 // struct LDKEvent Event_payment_claimed(struct LDKPublicKey receiver_node_id, struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose);
18346 export function Event_payment_claimed(receiver_node_id: number, payment_hash: number, amount_msat: bigint, purpose: bigint): bigint {
18347 if(!isWasmInitialized) {
18348 throw new Error("initializeWasm() must be awaited first!");
18350 const nativeResponseValue = wasm.TS_Event_payment_claimed(receiver_node_id, payment_hash, amount_msat, purpose);
18351 return nativeResponseValue;
18353 // struct LDKEvent Event_payment_sent(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z fee_paid_msat);
18355 export function Event_payment_sent(payment_id: number, payment_preimage: number, payment_hash: number, fee_paid_msat: bigint): bigint {
18356 if(!isWasmInitialized) {
18357 throw new Error("initializeWasm() must be awaited first!");
18359 const nativeResponseValue = wasm.TS_Event_payment_sent(payment_id, payment_preimage, payment_hash, fee_paid_msat);
18360 return nativeResponseValue;
18362 // struct LDKEvent Event_payment_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash);
18364 export function Event_payment_failed(payment_id: number, payment_hash: number): bigint {
18365 if(!isWasmInitialized) {
18366 throw new Error("initializeWasm() must be awaited first!");
18368 const nativeResponseValue = wasm.TS_Event_payment_failed(payment_id, payment_hash);
18369 return nativeResponseValue;
18371 // struct LDKEvent Event_payment_path_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path);
18373 export function Event_payment_path_successful(payment_id: number, payment_hash: number, path: number): bigint {
18374 if(!isWasmInitialized) {
18375 throw new Error("initializeWasm() must be awaited first!");
18377 const nativeResponseValue = wasm.TS_Event_payment_path_successful(payment_id, payment_hash, path);
18378 return nativeResponseValue;
18380 // struct LDKEvent Event_payment_path_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, bool payment_failed_permanently, struct LDKPathFailure failure, struct LDKCVec_RouteHopZ path, struct LDKCOption_u64Z short_channel_id, struct LDKRouteParameters retry);
18382 export function Event_payment_path_failed(payment_id: number, payment_hash: number, payment_failed_permanently: boolean, failure: bigint, path: number, short_channel_id: bigint, retry: bigint): bigint {
18383 if(!isWasmInitialized) {
18384 throw new Error("initializeWasm() must be awaited first!");
18386 const nativeResponseValue = wasm.TS_Event_payment_path_failed(payment_id, payment_hash, payment_failed_permanently, failure, path, short_channel_id, retry);
18387 return nativeResponseValue;
18389 // struct LDKEvent Event_probe_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path);
18391 export function Event_probe_successful(payment_id: number, payment_hash: number, path: number): bigint {
18392 if(!isWasmInitialized) {
18393 throw new Error("initializeWasm() must be awaited first!");
18395 const nativeResponseValue = wasm.TS_Event_probe_successful(payment_id, payment_hash, path);
18396 return nativeResponseValue;
18398 // struct LDKEvent Event_probe_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path, struct LDKCOption_u64Z short_channel_id);
18400 export function Event_probe_failed(payment_id: number, payment_hash: number, path: number, short_channel_id: bigint): bigint {
18401 if(!isWasmInitialized) {
18402 throw new Error("initializeWasm() must be awaited first!");
18404 const nativeResponseValue = wasm.TS_Event_probe_failed(payment_id, payment_hash, path, short_channel_id);
18405 return nativeResponseValue;
18407 // struct LDKEvent Event_pending_htlcs_forwardable(uint64_t time_forwardable);
18409 export function Event_pending_htlcs_forwardable(time_forwardable: bigint): bigint {
18410 if(!isWasmInitialized) {
18411 throw new Error("initializeWasm() must be awaited first!");
18413 const nativeResponseValue = wasm.TS_Event_pending_htlcs_forwardable(time_forwardable);
18414 return nativeResponseValue;
18416 // struct LDKEvent Event_htlcintercepted(struct LDKThirtyTwoBytes intercept_id, uint64_t requested_next_hop_scid, struct LDKThirtyTwoBytes payment_hash, uint64_t inbound_amount_msat, uint64_t expected_outbound_amount_msat);
18418 export function Event_htlcintercepted(intercept_id: number, requested_next_hop_scid: bigint, payment_hash: number, inbound_amount_msat: bigint, expected_outbound_amount_msat: bigint): bigint {
18419 if(!isWasmInitialized) {
18420 throw new Error("initializeWasm() must be awaited first!");
18422 const nativeResponseValue = wasm.TS_Event_htlcintercepted(intercept_id, requested_next_hop_scid, payment_hash, inbound_amount_msat, expected_outbound_amount_msat);
18423 return nativeResponseValue;
18425 // struct LDKEvent Event_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ outputs);
18427 export function Event_spendable_outputs(outputs: number): bigint {
18428 if(!isWasmInitialized) {
18429 throw new Error("initializeWasm() must be awaited first!");
18431 const nativeResponseValue = wasm.TS_Event_spendable_outputs(outputs);
18432 return nativeResponseValue;
18434 // 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);
18436 export function Event_payment_forwarded(prev_channel_id: number, next_channel_id: number, fee_earned_msat: bigint, claim_from_onchain_tx: boolean): bigint {
18437 if(!isWasmInitialized) {
18438 throw new Error("initializeWasm() must be awaited first!");
18440 const nativeResponseValue = wasm.TS_Event_payment_forwarded(prev_channel_id, next_channel_id, fee_earned_msat, claim_from_onchain_tx);
18441 return nativeResponseValue;
18443 // struct LDKEvent Event_channel_ready(struct LDKThirtyTwoBytes channel_id, struct LDKU128 user_channel_id, struct LDKPublicKey counterparty_node_id, struct LDKChannelTypeFeatures channel_type);
18445 export function Event_channel_ready(channel_id: number, user_channel_id: number, counterparty_node_id: number, channel_type: bigint): bigint {
18446 if(!isWasmInitialized) {
18447 throw new Error("initializeWasm() must be awaited first!");
18449 const nativeResponseValue = wasm.TS_Event_channel_ready(channel_id, user_channel_id, counterparty_node_id, channel_type);
18450 return nativeResponseValue;
18452 // struct LDKEvent Event_channel_closed(struct LDKThirtyTwoBytes channel_id, struct LDKU128 user_channel_id, struct LDKClosureReason reason);
18454 export function Event_channel_closed(channel_id: number, user_channel_id: number, reason: bigint): bigint {
18455 if(!isWasmInitialized) {
18456 throw new Error("initializeWasm() must be awaited first!");
18458 const nativeResponseValue = wasm.TS_Event_channel_closed(channel_id, user_channel_id, reason);
18459 return nativeResponseValue;
18461 // struct LDKEvent Event_discard_funding(struct LDKThirtyTwoBytes channel_id, struct LDKTransaction transaction);
18463 export function Event_discard_funding(channel_id: number, transaction: number): bigint {
18464 if(!isWasmInitialized) {
18465 throw new Error("initializeWasm() must be awaited first!");
18467 const nativeResponseValue = wasm.TS_Event_discard_funding(channel_id, transaction);
18468 return nativeResponseValue;
18470 // 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);
18472 export function Event_open_channel_request(temporary_channel_id: number, counterparty_node_id: number, funding_satoshis: bigint, push_msat: bigint, channel_type: bigint): bigint {
18473 if(!isWasmInitialized) {
18474 throw new Error("initializeWasm() must be awaited first!");
18476 const nativeResponseValue = wasm.TS_Event_open_channel_request(temporary_channel_id, counterparty_node_id, funding_satoshis, push_msat, channel_type);
18477 return nativeResponseValue;
18479 // struct LDKEvent Event_htlchandling_failed(struct LDKThirtyTwoBytes prev_channel_id, struct LDKHTLCDestination failed_next_destination);
18481 export function Event_htlchandling_failed(prev_channel_id: number, failed_next_destination: bigint): bigint {
18482 if(!isWasmInitialized) {
18483 throw new Error("initializeWasm() must be awaited first!");
18485 const nativeResponseValue = wasm.TS_Event_htlchandling_failed(prev_channel_id, failed_next_destination);
18486 return nativeResponseValue;
18488 // bool Event_eq(const struct LDKEvent *NONNULL_PTR a, const struct LDKEvent *NONNULL_PTR b);
18490 export function Event_eq(a: bigint, b: bigint): boolean {
18491 if(!isWasmInitialized) {
18492 throw new Error("initializeWasm() must be awaited first!");
18494 const nativeResponseValue = wasm.TS_Event_eq(a, b);
18495 return nativeResponseValue;
18497 // struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
18499 export function Event_write(obj: bigint): number {
18500 if(!isWasmInitialized) {
18501 throw new Error("initializeWasm() must be awaited first!");
18503 const nativeResponseValue = wasm.TS_Event_write(obj);
18504 return nativeResponseValue;
18506 // struct LDKCResult_COption_EventZDecodeErrorZ Event_read(struct LDKu8slice ser);
18508 export function Event_read(ser: number): bigint {
18509 if(!isWasmInitialized) {
18510 throw new Error("initializeWasm() must be awaited first!");
18512 const nativeResponseValue = wasm.TS_Event_read(ser);
18513 return nativeResponseValue;
18515 // void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
18517 export function MessageSendEvent_free(this_ptr: bigint): void {
18518 if(!isWasmInitialized) {
18519 throw new Error("initializeWasm() must be awaited first!");
18521 const nativeResponseValue = wasm.TS_MessageSendEvent_free(this_ptr);
18522 // debug statements here
18524 // uint64_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg);
18526 export function MessageSendEvent_clone_ptr(arg: bigint): bigint {
18527 if(!isWasmInitialized) {
18528 throw new Error("initializeWasm() must be awaited first!");
18530 const nativeResponseValue = wasm.TS_MessageSendEvent_clone_ptr(arg);
18531 return nativeResponseValue;
18533 // struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
18535 export function MessageSendEvent_clone(orig: bigint): bigint {
18536 if(!isWasmInitialized) {
18537 throw new Error("initializeWasm() must be awaited first!");
18539 const nativeResponseValue = wasm.TS_MessageSendEvent_clone(orig);
18540 return nativeResponseValue;
18542 // struct LDKMessageSendEvent MessageSendEvent_send_accept_channel(struct LDKPublicKey node_id, struct LDKAcceptChannel msg);
18544 export function MessageSendEvent_send_accept_channel(node_id: number, msg: bigint): bigint {
18545 if(!isWasmInitialized) {
18546 throw new Error("initializeWasm() must be awaited first!");
18548 const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel(node_id, msg);
18549 return nativeResponseValue;
18551 // struct LDKMessageSendEvent MessageSendEvent_send_open_channel(struct LDKPublicKey node_id, struct LDKOpenChannel msg);
18553 export function MessageSendEvent_send_open_channel(node_id: number, msg: bigint): bigint {
18554 if(!isWasmInitialized) {
18555 throw new Error("initializeWasm() must be awaited first!");
18557 const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel(node_id, msg);
18558 return nativeResponseValue;
18560 // struct LDKMessageSendEvent MessageSendEvent_send_funding_created(struct LDKPublicKey node_id, struct LDKFundingCreated msg);
18562 export function MessageSendEvent_send_funding_created(node_id: number, msg: bigint): bigint {
18563 if(!isWasmInitialized) {
18564 throw new Error("initializeWasm() must be awaited first!");
18566 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_created(node_id, msg);
18567 return nativeResponseValue;
18569 // struct LDKMessageSendEvent MessageSendEvent_send_funding_signed(struct LDKPublicKey node_id, struct LDKFundingSigned msg);
18571 export function MessageSendEvent_send_funding_signed(node_id: number, msg: bigint): bigint {
18572 if(!isWasmInitialized) {
18573 throw new Error("initializeWasm() must be awaited first!");
18575 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_signed(node_id, msg);
18576 return nativeResponseValue;
18578 // struct LDKMessageSendEvent MessageSendEvent_send_channel_ready(struct LDKPublicKey node_id, struct LDKChannelReady msg);
18580 export function MessageSendEvent_send_channel_ready(node_id: number, msg: bigint): bigint {
18581 if(!isWasmInitialized) {
18582 throw new Error("initializeWasm() must be awaited first!");
18584 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_ready(node_id, msg);
18585 return nativeResponseValue;
18587 // struct LDKMessageSendEvent MessageSendEvent_send_announcement_signatures(struct LDKPublicKey node_id, struct LDKAnnouncementSignatures msg);
18589 export function MessageSendEvent_send_announcement_signatures(node_id: number, msg: bigint): bigint {
18590 if(!isWasmInitialized) {
18591 throw new Error("initializeWasm() must be awaited first!");
18593 const nativeResponseValue = wasm.TS_MessageSendEvent_send_announcement_signatures(node_id, msg);
18594 return nativeResponseValue;
18596 // struct LDKMessageSendEvent MessageSendEvent_update_htlcs(struct LDKPublicKey node_id, struct LDKCommitmentUpdate updates);
18598 export function MessageSendEvent_update_htlcs(node_id: number, updates: bigint): bigint {
18599 if(!isWasmInitialized) {
18600 throw new Error("initializeWasm() must be awaited first!");
18602 const nativeResponseValue = wasm.TS_MessageSendEvent_update_htlcs(node_id, updates);
18603 return nativeResponseValue;
18605 // struct LDKMessageSendEvent MessageSendEvent_send_revoke_and_ack(struct LDKPublicKey node_id, struct LDKRevokeAndACK msg);
18607 export function MessageSendEvent_send_revoke_and_ack(node_id: number, msg: bigint): bigint {
18608 if(!isWasmInitialized) {
18609 throw new Error("initializeWasm() must be awaited first!");
18611 const nativeResponseValue = wasm.TS_MessageSendEvent_send_revoke_and_ack(node_id, msg);
18612 return nativeResponseValue;
18614 // struct LDKMessageSendEvent MessageSendEvent_send_closing_signed(struct LDKPublicKey node_id, struct LDKClosingSigned msg);
18616 export function MessageSendEvent_send_closing_signed(node_id: number, msg: bigint): bigint {
18617 if(!isWasmInitialized) {
18618 throw new Error("initializeWasm() must be awaited first!");
18620 const nativeResponseValue = wasm.TS_MessageSendEvent_send_closing_signed(node_id, msg);
18621 return nativeResponseValue;
18623 // struct LDKMessageSendEvent MessageSendEvent_send_shutdown(struct LDKPublicKey node_id, struct LDKShutdown msg);
18625 export function MessageSendEvent_send_shutdown(node_id: number, msg: bigint): bigint {
18626 if(!isWasmInitialized) {
18627 throw new Error("initializeWasm() must be awaited first!");
18629 const nativeResponseValue = wasm.TS_MessageSendEvent_send_shutdown(node_id, msg);
18630 return nativeResponseValue;
18632 // struct LDKMessageSendEvent MessageSendEvent_send_channel_reestablish(struct LDKPublicKey node_id, struct LDKChannelReestablish msg);
18634 export function MessageSendEvent_send_channel_reestablish(node_id: number, msg: bigint): bigint {
18635 if(!isWasmInitialized) {
18636 throw new Error("initializeWasm() must be awaited first!");
18638 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_reestablish(node_id, msg);
18639 return nativeResponseValue;
18641 // struct LDKMessageSendEvent MessageSendEvent_send_channel_announcement(struct LDKPublicKey node_id, struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
18643 export function MessageSendEvent_send_channel_announcement(node_id: number, msg: bigint, update_msg: bigint): bigint {
18644 if(!isWasmInitialized) {
18645 throw new Error("initializeWasm() must be awaited first!");
18647 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_announcement(node_id, msg, update_msg);
18648 return nativeResponseValue;
18650 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_announcement(struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
18652 export function MessageSendEvent_broadcast_channel_announcement(msg: bigint, update_msg: bigint): bigint {
18653 if(!isWasmInitialized) {
18654 throw new Error("initializeWasm() must be awaited first!");
18656 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_announcement(msg, update_msg);
18657 return nativeResponseValue;
18659 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_update(struct LDKChannelUpdate msg);
18661 export function MessageSendEvent_broadcast_channel_update(msg: bigint): bigint {
18662 if(!isWasmInitialized) {
18663 throw new Error("initializeWasm() must be awaited first!");
18665 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_update(msg);
18666 return nativeResponseValue;
18668 // struct LDKMessageSendEvent MessageSendEvent_broadcast_node_announcement(struct LDKNodeAnnouncement msg);
18670 export function MessageSendEvent_broadcast_node_announcement(msg: bigint): bigint {
18671 if(!isWasmInitialized) {
18672 throw new Error("initializeWasm() must be awaited first!");
18674 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_node_announcement(msg);
18675 return nativeResponseValue;
18677 // struct LDKMessageSendEvent MessageSendEvent_send_channel_update(struct LDKPublicKey node_id, struct LDKChannelUpdate msg);
18679 export function MessageSendEvent_send_channel_update(node_id: number, msg: bigint): bigint {
18680 if(!isWasmInitialized) {
18681 throw new Error("initializeWasm() must be awaited first!");
18683 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_update(node_id, msg);
18684 return nativeResponseValue;
18686 // struct LDKMessageSendEvent MessageSendEvent_handle_error(struct LDKPublicKey node_id, struct LDKErrorAction action);
18688 export function MessageSendEvent_handle_error(node_id: number, action: bigint): bigint {
18689 if(!isWasmInitialized) {
18690 throw new Error("initializeWasm() must be awaited first!");
18692 const nativeResponseValue = wasm.TS_MessageSendEvent_handle_error(node_id, action);
18693 return nativeResponseValue;
18695 // struct LDKMessageSendEvent MessageSendEvent_send_channel_range_query(struct LDKPublicKey node_id, struct LDKQueryChannelRange msg);
18697 export function MessageSendEvent_send_channel_range_query(node_id: number, msg: bigint): bigint {
18698 if(!isWasmInitialized) {
18699 throw new Error("initializeWasm() must be awaited first!");
18701 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_range_query(node_id, msg);
18702 return nativeResponseValue;
18704 // struct LDKMessageSendEvent MessageSendEvent_send_short_ids_query(struct LDKPublicKey node_id, struct LDKQueryShortChannelIds msg);
18706 export function MessageSendEvent_send_short_ids_query(node_id: number, msg: bigint): bigint {
18707 if(!isWasmInitialized) {
18708 throw new Error("initializeWasm() must be awaited first!");
18710 const nativeResponseValue = wasm.TS_MessageSendEvent_send_short_ids_query(node_id, msg);
18711 return nativeResponseValue;
18713 // struct LDKMessageSendEvent MessageSendEvent_send_reply_channel_range(struct LDKPublicKey node_id, struct LDKReplyChannelRange msg);
18715 export function MessageSendEvent_send_reply_channel_range(node_id: number, msg: bigint): bigint {
18716 if(!isWasmInitialized) {
18717 throw new Error("initializeWasm() must be awaited first!");
18719 const nativeResponseValue = wasm.TS_MessageSendEvent_send_reply_channel_range(node_id, msg);
18720 return nativeResponseValue;
18722 // struct LDKMessageSendEvent MessageSendEvent_send_gossip_timestamp_filter(struct LDKPublicKey node_id, struct LDKGossipTimestampFilter msg);
18724 export function MessageSendEvent_send_gossip_timestamp_filter(node_id: number, msg: bigint): bigint {
18725 if(!isWasmInitialized) {
18726 throw new Error("initializeWasm() must be awaited first!");
18728 const nativeResponseValue = wasm.TS_MessageSendEvent_send_gossip_timestamp_filter(node_id, msg);
18729 return nativeResponseValue;
18731 // void MessageSendEventsProvider_free(struct LDKMessageSendEventsProvider this_ptr);
18733 export function MessageSendEventsProvider_free(this_ptr: bigint): void {
18734 if(!isWasmInitialized) {
18735 throw new Error("initializeWasm() must be awaited first!");
18737 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_free(this_ptr);
18738 // debug statements here
18740 // void OnionMessageProvider_free(struct LDKOnionMessageProvider this_ptr);
18742 export function OnionMessageProvider_free(this_ptr: bigint): void {
18743 if(!isWasmInitialized) {
18744 throw new Error("initializeWasm() must be awaited first!");
18746 const nativeResponseValue = wasm.TS_OnionMessageProvider_free(this_ptr);
18747 // debug statements here
18749 // void EventsProvider_free(struct LDKEventsProvider this_ptr);
18751 export function EventsProvider_free(this_ptr: bigint): void {
18752 if(!isWasmInitialized) {
18753 throw new Error("initializeWasm() must be awaited first!");
18755 const nativeResponseValue = wasm.TS_EventsProvider_free(this_ptr);
18756 // debug statements here
18758 // void EventHandler_free(struct LDKEventHandler this_ptr);
18760 export function EventHandler_free(this_ptr: bigint): void {
18761 if(!isWasmInitialized) {
18762 throw new Error("initializeWasm() must be awaited first!");
18764 const nativeResponseValue = wasm.TS_EventHandler_free(this_ptr);
18765 // debug statements here
18767 // void APIError_free(struct LDKAPIError this_ptr);
18769 export function APIError_free(this_ptr: bigint): void {
18770 if(!isWasmInitialized) {
18771 throw new Error("initializeWasm() must be awaited first!");
18773 const nativeResponseValue = wasm.TS_APIError_free(this_ptr);
18774 // debug statements here
18776 // uint64_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg);
18778 export function APIError_clone_ptr(arg: bigint): bigint {
18779 if(!isWasmInitialized) {
18780 throw new Error("initializeWasm() must be awaited first!");
18782 const nativeResponseValue = wasm.TS_APIError_clone_ptr(arg);
18783 return nativeResponseValue;
18785 // struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
18787 export function APIError_clone(orig: bigint): bigint {
18788 if(!isWasmInitialized) {
18789 throw new Error("initializeWasm() must be awaited first!");
18791 const nativeResponseValue = wasm.TS_APIError_clone(orig);
18792 return nativeResponseValue;
18794 // struct LDKAPIError APIError_apimisuse_error(struct LDKStr err);
18796 export function APIError_apimisuse_error(err: number): bigint {
18797 if(!isWasmInitialized) {
18798 throw new Error("initializeWasm() must be awaited first!");
18800 const nativeResponseValue = wasm.TS_APIError_apimisuse_error(err);
18801 return nativeResponseValue;
18803 // struct LDKAPIError APIError_fee_rate_too_high(struct LDKStr err, uint32_t feerate);
18805 export function APIError_fee_rate_too_high(err: number, feerate: number): bigint {
18806 if(!isWasmInitialized) {
18807 throw new Error("initializeWasm() must be awaited first!");
18809 const nativeResponseValue = wasm.TS_APIError_fee_rate_too_high(err, feerate);
18810 return nativeResponseValue;
18812 // struct LDKAPIError APIError_invalid_route(struct LDKStr err);
18814 export function APIError_invalid_route(err: number): bigint {
18815 if(!isWasmInitialized) {
18816 throw new Error("initializeWasm() must be awaited first!");
18818 const nativeResponseValue = wasm.TS_APIError_invalid_route(err);
18819 return nativeResponseValue;
18821 // struct LDKAPIError APIError_channel_unavailable(struct LDKStr err);
18823 export function APIError_channel_unavailable(err: number): bigint {
18824 if(!isWasmInitialized) {
18825 throw new Error("initializeWasm() must be awaited first!");
18827 const nativeResponseValue = wasm.TS_APIError_channel_unavailable(err);
18828 return nativeResponseValue;
18830 // struct LDKAPIError APIError_monitor_update_in_progress(void);
18832 export function APIError_monitor_update_in_progress(): bigint {
18833 if(!isWasmInitialized) {
18834 throw new Error("initializeWasm() must be awaited first!");
18836 const nativeResponseValue = wasm.TS_APIError_monitor_update_in_progress();
18837 return nativeResponseValue;
18839 // struct LDKAPIError APIError_incompatible_shutdown_script(struct LDKShutdownScript script);
18841 export function APIError_incompatible_shutdown_script(script: bigint): bigint {
18842 if(!isWasmInitialized) {
18843 throw new Error("initializeWasm() must be awaited first!");
18845 const nativeResponseValue = wasm.TS_APIError_incompatible_shutdown_script(script);
18846 return nativeResponseValue;
18848 // bool APIError_eq(const struct LDKAPIError *NONNULL_PTR a, const struct LDKAPIError *NONNULL_PTR b);
18850 export function APIError_eq(a: bigint, b: bigint): boolean {
18851 if(!isWasmInitialized) {
18852 throw new Error("initializeWasm() must be awaited first!");
18854 const nativeResponseValue = wasm.TS_APIError_eq(a, b);
18855 return nativeResponseValue;
18857 // struct LDKCVec_u8Z APIError_write(const struct LDKAPIError *NONNULL_PTR obj);
18859 export function APIError_write(obj: bigint): number {
18860 if(!isWasmInitialized) {
18861 throw new Error("initializeWasm() must be awaited first!");
18863 const nativeResponseValue = wasm.TS_APIError_write(obj);
18864 return nativeResponseValue;
18866 // struct LDKCResult_COption_APIErrorZDecodeErrorZ APIError_read(struct LDKu8slice ser);
18868 export function APIError_read(ser: number): bigint {
18869 if(!isWasmInitialized) {
18870 throw new Error("initializeWasm() must be awaited first!");
18872 const nativeResponseValue = wasm.TS_APIError_read(ser);
18873 return nativeResponseValue;
18875 // void BigSize_free(struct LDKBigSize this_obj);
18877 export function BigSize_free(this_obj: bigint): void {
18878 if(!isWasmInitialized) {
18879 throw new Error("initializeWasm() must be awaited first!");
18881 const nativeResponseValue = wasm.TS_BigSize_free(this_obj);
18882 // debug statements here
18884 // uint64_t BigSize_get_a(const struct LDKBigSize *NONNULL_PTR this_ptr);
18886 export function BigSize_get_a(this_ptr: bigint): bigint {
18887 if(!isWasmInitialized) {
18888 throw new Error("initializeWasm() must be awaited first!");
18890 const nativeResponseValue = wasm.TS_BigSize_get_a(this_ptr);
18891 return nativeResponseValue;
18893 // void BigSize_set_a(struct LDKBigSize *NONNULL_PTR this_ptr, uint64_t val);
18895 export function BigSize_set_a(this_ptr: bigint, val: bigint): void {
18896 if(!isWasmInitialized) {
18897 throw new Error("initializeWasm() must be awaited first!");
18899 const nativeResponseValue = wasm.TS_BigSize_set_a(this_ptr, val);
18900 // debug statements here
18902 // MUST_USE_RES struct LDKBigSize BigSize_new(uint64_t a_arg);
18904 export function BigSize_new(a_arg: bigint): bigint {
18905 if(!isWasmInitialized) {
18906 throw new Error("initializeWasm() must be awaited first!");
18908 const nativeResponseValue = wasm.TS_BigSize_new(a_arg);
18909 return nativeResponseValue;
18911 // void Hostname_free(struct LDKHostname this_obj);
18913 export function Hostname_free(this_obj: bigint): void {
18914 if(!isWasmInitialized) {
18915 throw new Error("initializeWasm() must be awaited first!");
18917 const nativeResponseValue = wasm.TS_Hostname_free(this_obj);
18918 // debug statements here
18920 // uint64_t Hostname_clone_ptr(LDKHostname *NONNULL_PTR arg);
18922 export function Hostname_clone_ptr(arg: bigint): bigint {
18923 if(!isWasmInitialized) {
18924 throw new Error("initializeWasm() must be awaited first!");
18926 const nativeResponseValue = wasm.TS_Hostname_clone_ptr(arg);
18927 return nativeResponseValue;
18929 // struct LDKHostname Hostname_clone(const struct LDKHostname *NONNULL_PTR orig);
18931 export function Hostname_clone(orig: bigint): bigint {
18932 if(!isWasmInitialized) {
18933 throw new Error("initializeWasm() must be awaited first!");
18935 const nativeResponseValue = wasm.TS_Hostname_clone(orig);
18936 return nativeResponseValue;
18938 // bool Hostname_eq(const struct LDKHostname *NONNULL_PTR a, const struct LDKHostname *NONNULL_PTR b);
18940 export function Hostname_eq(a: bigint, b: bigint): boolean {
18941 if(!isWasmInitialized) {
18942 throw new Error("initializeWasm() must be awaited first!");
18944 const nativeResponseValue = wasm.TS_Hostname_eq(a, b);
18945 return nativeResponseValue;
18947 // MUST_USE_RES uint8_t Hostname_len(const struct LDKHostname *NONNULL_PTR this_arg);
18949 export function Hostname_len(this_arg: bigint): number {
18950 if(!isWasmInitialized) {
18951 throw new Error("initializeWasm() must be awaited first!");
18953 const nativeResponseValue = wasm.TS_Hostname_len(this_arg);
18954 return nativeResponseValue;
18956 // struct LDKCResult_StringErrorZ sign(struct LDKu8slice msg, const uint8_t (*sk)[32]);
18958 export function sign(msg: number, sk: number): bigint {
18959 if(!isWasmInitialized) {
18960 throw new Error("initializeWasm() must be awaited first!");
18962 const nativeResponseValue = wasm.TS_sign(msg, sk);
18963 return nativeResponseValue;
18965 // struct LDKCResult_PublicKeyErrorZ recover_pk(struct LDKu8slice msg, struct LDKStr sig);
18967 export function recover_pk(msg: number, sig: number): bigint {
18968 if(!isWasmInitialized) {
18969 throw new Error("initializeWasm() must be awaited first!");
18971 const nativeResponseValue = wasm.TS_recover_pk(msg, sig);
18972 return nativeResponseValue;
18974 // bool verify(struct LDKu8slice msg, struct LDKStr sig, struct LDKPublicKey pk);
18976 export function verify(msg: number, sig: number, pk: number): boolean {
18977 if(!isWasmInitialized) {
18978 throw new Error("initializeWasm() must be awaited first!");
18980 const nativeResponseValue = wasm.TS_verify(msg, sig, pk);
18981 return nativeResponseValue;
18983 // struct LDKCVec_u8Z construct_invoice_preimage(struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z data_without_signature);
18985 export function construct_invoice_preimage(hrp_bytes: number, data_without_signature: number): number {
18986 if(!isWasmInitialized) {
18987 throw new Error("initializeWasm() must be awaited first!");
18989 const nativeResponseValue = wasm.TS_construct_invoice_preimage(hrp_bytes, data_without_signature);
18990 return nativeResponseValue;
18992 // void Persister_free(struct LDKPersister this_ptr);
18994 export function Persister_free(this_ptr: bigint): void {
18995 if(!isWasmInitialized) {
18996 throw new Error("initializeWasm() must be awaited first!");
18998 const nativeResponseValue = wasm.TS_Persister_free(this_ptr);
18999 // debug statements here
19001 // void PrintableString_free(struct LDKPrintableString this_obj);
19003 export function PrintableString_free(this_obj: bigint): void {
19004 if(!isWasmInitialized) {
19005 throw new Error("initializeWasm() must be awaited first!");
19007 const nativeResponseValue = wasm.TS_PrintableString_free(this_obj);
19008 // debug statements here
19010 // struct LDKStr PrintableString_get_a(const struct LDKPrintableString *NONNULL_PTR this_ptr);
19012 export function PrintableString_get_a(this_ptr: bigint): number {
19013 if(!isWasmInitialized) {
19014 throw new Error("initializeWasm() must be awaited first!");
19016 const nativeResponseValue = wasm.TS_PrintableString_get_a(this_ptr);
19017 return nativeResponseValue;
19019 // void PrintableString_set_a(struct LDKPrintableString *NONNULL_PTR this_ptr, struct LDKStr val);
19021 export function PrintableString_set_a(this_ptr: bigint, val: number): void {
19022 if(!isWasmInitialized) {
19023 throw new Error("initializeWasm() must be awaited first!");
19025 const nativeResponseValue = wasm.TS_PrintableString_set_a(this_ptr, val);
19026 // debug statements here
19028 // MUST_USE_RES struct LDKPrintableString PrintableString_new(struct LDKStr a_arg);
19030 export function PrintableString_new(a_arg: number): bigint {
19031 if(!isWasmInitialized) {
19032 throw new Error("initializeWasm() must be awaited first!");
19034 const nativeResponseValue = wasm.TS_PrintableString_new(a_arg);
19035 return nativeResponseValue;
19037 // void FutureCallback_free(struct LDKFutureCallback this_ptr);
19039 export function FutureCallback_free(this_ptr: bigint): void {
19040 if(!isWasmInitialized) {
19041 throw new Error("initializeWasm() must be awaited first!");
19043 const nativeResponseValue = wasm.TS_FutureCallback_free(this_ptr);
19044 // debug statements here
19046 // void Future_free(struct LDKFuture this_obj);
19048 export function Future_free(this_obj: bigint): void {
19049 if(!isWasmInitialized) {
19050 throw new Error("initializeWasm() must be awaited first!");
19052 const nativeResponseValue = wasm.TS_Future_free(this_obj);
19053 // debug statements here
19055 // void Future_register_callback_fn(const struct LDKFuture *NONNULL_PTR this_arg, struct LDKFutureCallback callback);
19057 export function Future_register_callback_fn(this_arg: bigint, callback: bigint): void {
19058 if(!isWasmInitialized) {
19059 throw new Error("initializeWasm() must be awaited first!");
19061 const nativeResponseValue = wasm.TS_Future_register_callback_fn(this_arg, callback);
19062 // debug statements here
19064 // enum LDKLevel Level_clone(const enum LDKLevel *NONNULL_PTR orig);
19066 export function Level_clone(orig: bigint): Level {
19067 if(!isWasmInitialized) {
19068 throw new Error("initializeWasm() must be awaited first!");
19070 const nativeResponseValue = wasm.TS_Level_clone(orig);
19071 return nativeResponseValue;
19073 // enum LDKLevel Level_gossip(void);
19075 export function Level_gossip(): Level {
19076 if(!isWasmInitialized) {
19077 throw new Error("initializeWasm() must be awaited first!");
19079 const nativeResponseValue = wasm.TS_Level_gossip();
19080 return nativeResponseValue;
19082 // enum LDKLevel Level_trace(void);
19084 export function Level_trace(): Level {
19085 if(!isWasmInitialized) {
19086 throw new Error("initializeWasm() must be awaited first!");
19088 const nativeResponseValue = wasm.TS_Level_trace();
19089 return nativeResponseValue;
19091 // enum LDKLevel Level_debug(void);
19093 export function Level_debug(): Level {
19094 if(!isWasmInitialized) {
19095 throw new Error("initializeWasm() must be awaited first!");
19097 const nativeResponseValue = wasm.TS_Level_debug();
19098 return nativeResponseValue;
19100 // enum LDKLevel Level_info(void);
19102 export function Level_info(): Level {
19103 if(!isWasmInitialized) {
19104 throw new Error("initializeWasm() must be awaited first!");
19106 const nativeResponseValue = wasm.TS_Level_info();
19107 return nativeResponseValue;
19109 // enum LDKLevel Level_warn(void);
19111 export function Level_warn(): Level {
19112 if(!isWasmInitialized) {
19113 throw new Error("initializeWasm() must be awaited first!");
19115 const nativeResponseValue = wasm.TS_Level_warn();
19116 return nativeResponseValue;
19118 // enum LDKLevel Level_error(void);
19120 export function Level_error(): Level {
19121 if(!isWasmInitialized) {
19122 throw new Error("initializeWasm() must be awaited first!");
19124 const nativeResponseValue = wasm.TS_Level_error();
19125 return nativeResponseValue;
19127 // bool Level_eq(const enum LDKLevel *NONNULL_PTR a, const enum LDKLevel *NONNULL_PTR b);
19129 export function Level_eq(a: bigint, b: bigint): boolean {
19130 if(!isWasmInitialized) {
19131 throw new Error("initializeWasm() must be awaited first!");
19133 const nativeResponseValue = wasm.TS_Level_eq(a, b);
19134 return nativeResponseValue;
19136 // uint64_t Level_hash(const enum LDKLevel *NONNULL_PTR o);
19138 export function Level_hash(o: bigint): bigint {
19139 if(!isWasmInitialized) {
19140 throw new Error("initializeWasm() must be awaited first!");
19142 const nativeResponseValue = wasm.TS_Level_hash(o);
19143 return nativeResponseValue;
19145 // MUST_USE_RES enum LDKLevel Level_max(void);
19147 export function Level_max(): Level {
19148 if(!isWasmInitialized) {
19149 throw new Error("initializeWasm() must be awaited first!");
19151 const nativeResponseValue = wasm.TS_Level_max();
19152 return nativeResponseValue;
19154 // void Record_free(struct LDKRecord this_obj);
19156 export function Record_free(this_obj: bigint): void {
19157 if(!isWasmInitialized) {
19158 throw new Error("initializeWasm() must be awaited first!");
19160 const nativeResponseValue = wasm.TS_Record_free(this_obj);
19161 // debug statements here
19163 // enum LDKLevel Record_get_level(const struct LDKRecord *NONNULL_PTR this_ptr);
19165 export function Record_get_level(this_ptr: bigint): Level {
19166 if(!isWasmInitialized) {
19167 throw new Error("initializeWasm() must be awaited first!");
19169 const nativeResponseValue = wasm.TS_Record_get_level(this_ptr);
19170 return nativeResponseValue;
19172 // void Record_set_level(struct LDKRecord *NONNULL_PTR this_ptr, enum LDKLevel val);
19174 export function Record_set_level(this_ptr: bigint, val: Level): void {
19175 if(!isWasmInitialized) {
19176 throw new Error("initializeWasm() must be awaited first!");
19178 const nativeResponseValue = wasm.TS_Record_set_level(this_ptr, val);
19179 // debug statements here
19181 // struct LDKStr Record_get_args(const struct LDKRecord *NONNULL_PTR this_ptr);
19183 export function Record_get_args(this_ptr: bigint): number {
19184 if(!isWasmInitialized) {
19185 throw new Error("initializeWasm() must be awaited first!");
19187 const nativeResponseValue = wasm.TS_Record_get_args(this_ptr);
19188 return nativeResponseValue;
19190 // void Record_set_args(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
19192 export function Record_set_args(this_ptr: bigint, val: number): void {
19193 if(!isWasmInitialized) {
19194 throw new Error("initializeWasm() must be awaited first!");
19196 const nativeResponseValue = wasm.TS_Record_set_args(this_ptr, val);
19197 // debug statements here
19199 // struct LDKStr Record_get_module_path(const struct LDKRecord *NONNULL_PTR this_ptr);
19201 export function Record_get_module_path(this_ptr: bigint): number {
19202 if(!isWasmInitialized) {
19203 throw new Error("initializeWasm() must be awaited first!");
19205 const nativeResponseValue = wasm.TS_Record_get_module_path(this_ptr);
19206 return nativeResponseValue;
19208 // void Record_set_module_path(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
19210 export function Record_set_module_path(this_ptr: bigint, val: number): void {
19211 if(!isWasmInitialized) {
19212 throw new Error("initializeWasm() must be awaited first!");
19214 const nativeResponseValue = wasm.TS_Record_set_module_path(this_ptr, val);
19215 // debug statements here
19217 // struct LDKStr Record_get_file(const struct LDKRecord *NONNULL_PTR this_ptr);
19219 export function Record_get_file(this_ptr: bigint): number {
19220 if(!isWasmInitialized) {
19221 throw new Error("initializeWasm() must be awaited first!");
19223 const nativeResponseValue = wasm.TS_Record_get_file(this_ptr);
19224 return nativeResponseValue;
19226 // void Record_set_file(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
19228 export function Record_set_file(this_ptr: bigint, val: number): void {
19229 if(!isWasmInitialized) {
19230 throw new Error("initializeWasm() must be awaited first!");
19232 const nativeResponseValue = wasm.TS_Record_set_file(this_ptr, val);
19233 // debug statements here
19235 // uint32_t Record_get_line(const struct LDKRecord *NONNULL_PTR this_ptr);
19237 export function Record_get_line(this_ptr: bigint): number {
19238 if(!isWasmInitialized) {
19239 throw new Error("initializeWasm() must be awaited first!");
19241 const nativeResponseValue = wasm.TS_Record_get_line(this_ptr);
19242 return nativeResponseValue;
19244 // void Record_set_line(struct LDKRecord *NONNULL_PTR this_ptr, uint32_t val);
19246 export function Record_set_line(this_ptr: bigint, val: number): void {
19247 if(!isWasmInitialized) {
19248 throw new Error("initializeWasm() must be awaited first!");
19250 const nativeResponseValue = wasm.TS_Record_set_line(this_ptr, val);
19251 // debug statements here
19253 // uint64_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg);
19255 export function Record_clone_ptr(arg: bigint): bigint {
19256 if(!isWasmInitialized) {
19257 throw new Error("initializeWasm() must be awaited first!");
19259 const nativeResponseValue = wasm.TS_Record_clone_ptr(arg);
19260 return nativeResponseValue;
19262 // struct LDKRecord Record_clone(const struct LDKRecord *NONNULL_PTR orig);
19264 export function Record_clone(orig: bigint): bigint {
19265 if(!isWasmInitialized) {
19266 throw new Error("initializeWasm() must be awaited first!");
19268 const nativeResponseValue = wasm.TS_Record_clone(orig);
19269 return nativeResponseValue;
19271 // void Logger_free(struct LDKLogger this_ptr);
19273 export function Logger_free(this_ptr: bigint): void {
19274 if(!isWasmInitialized) {
19275 throw new Error("initializeWasm() must be awaited first!");
19277 const nativeResponseValue = wasm.TS_Logger_free(this_ptr);
19278 // debug statements here
19280 // void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_obj);
19282 export function ChannelHandshakeConfig_free(this_obj: bigint): void {
19283 if(!isWasmInitialized) {
19284 throw new Error("initializeWasm() must be awaited first!");
19286 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_free(this_obj);
19287 // debug statements here
19289 // uint32_t ChannelHandshakeConfig_get_minimum_depth(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
19291 export function ChannelHandshakeConfig_get_minimum_depth(this_ptr: bigint): number {
19292 if(!isWasmInitialized) {
19293 throw new Error("initializeWasm() must be awaited first!");
19295 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_minimum_depth(this_ptr);
19296 return nativeResponseValue;
19298 // void ChannelHandshakeConfig_set_minimum_depth(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
19300 export function ChannelHandshakeConfig_set_minimum_depth(this_ptr: bigint, val: number): void {
19301 if(!isWasmInitialized) {
19302 throw new Error("initializeWasm() must be awaited first!");
19304 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_minimum_depth(this_ptr, val);
19305 // debug statements here
19307 // uint16_t ChannelHandshakeConfig_get_our_to_self_delay(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
19309 export function ChannelHandshakeConfig_get_our_to_self_delay(this_ptr: bigint): number {
19310 if(!isWasmInitialized) {
19311 throw new Error("initializeWasm() must be awaited first!");
19313 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_to_self_delay(this_ptr);
19314 return nativeResponseValue;
19316 // void ChannelHandshakeConfig_set_our_to_self_delay(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
19318 export function ChannelHandshakeConfig_set_our_to_self_delay(this_ptr: bigint, val: number): void {
19319 if(!isWasmInitialized) {
19320 throw new Error("initializeWasm() must be awaited first!");
19322 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_to_self_delay(this_ptr, val);
19323 // debug statements here
19325 // uint64_t ChannelHandshakeConfig_get_our_htlc_minimum_msat(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
19327 export function ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr: bigint): bigint {
19328 if(!isWasmInitialized) {
19329 throw new Error("initializeWasm() must be awaited first!");
19331 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr);
19332 return nativeResponseValue;
19334 // void ChannelHandshakeConfig_set_our_htlc_minimum_msat(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint64_t val);
19336 export function ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
19337 if(!isWasmInitialized) {
19338 throw new Error("initializeWasm() must be awaited first!");
19340 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr, val);
19341 // debug statements here
19343 // uint8_t ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
19345 export function ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: bigint): number {
19346 if(!isWasmInitialized) {
19347 throw new Error("initializeWasm() must be awaited first!");
19349 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr);
19350 return nativeResponseValue;
19352 // void ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint8_t val);
19354 export function ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: bigint, val: number): void {
19355 if(!isWasmInitialized) {
19356 throw new Error("initializeWasm() must be awaited first!");
19358 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr, val);
19359 // debug statements here
19361 // bool ChannelHandshakeConfig_get_negotiate_scid_privacy(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
19363 export function ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr: bigint): boolean {
19364 if(!isWasmInitialized) {
19365 throw new Error("initializeWasm() must be awaited first!");
19367 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr);
19368 return nativeResponseValue;
19370 // void ChannelHandshakeConfig_set_negotiate_scid_privacy(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
19372 export function ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr: bigint, val: boolean): void {
19373 if(!isWasmInitialized) {
19374 throw new Error("initializeWasm() must be awaited first!");
19376 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr, val);
19377 // debug statements here
19379 // bool ChannelHandshakeConfig_get_announced_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
19381 export function ChannelHandshakeConfig_get_announced_channel(this_ptr: bigint): boolean {
19382 if(!isWasmInitialized) {
19383 throw new Error("initializeWasm() must be awaited first!");
19385 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_announced_channel(this_ptr);
19386 return nativeResponseValue;
19388 // void ChannelHandshakeConfig_set_announced_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
19390 export function ChannelHandshakeConfig_set_announced_channel(this_ptr: bigint, val: boolean): void {
19391 if(!isWasmInitialized) {
19392 throw new Error("initializeWasm() must be awaited first!");
19394 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_announced_channel(this_ptr, val);
19395 // debug statements here
19397 // bool ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
19399 export function ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr: bigint): boolean {
19400 if(!isWasmInitialized) {
19401 throw new Error("initializeWasm() must be awaited first!");
19403 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr);
19404 return nativeResponseValue;
19406 // void ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
19408 export function ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr: bigint, val: boolean): void {
19409 if(!isWasmInitialized) {
19410 throw new Error("initializeWasm() must be awaited first!");
19412 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr, val);
19413 // debug statements here
19415 // uint32_t ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
19417 export function ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(this_ptr: bigint): number {
19418 if(!isWasmInitialized) {
19419 throw new Error("initializeWasm() must be awaited first!");
19421 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(this_ptr);
19422 return nativeResponseValue;
19424 // void ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
19426 export function ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(this_ptr: bigint, val: number): void {
19427 if(!isWasmInitialized) {
19428 throw new Error("initializeWasm() must be awaited first!");
19430 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(this_ptr, val);
19431 // debug statements here
19433 // 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);
19435 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 {
19436 if(!isWasmInitialized) {
19437 throw new Error("initializeWasm() must be awaited first!");
19439 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);
19440 return nativeResponseValue;
19442 // uint64_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg);
19444 export function ChannelHandshakeConfig_clone_ptr(arg: bigint): bigint {
19445 if(!isWasmInitialized) {
19446 throw new Error("initializeWasm() must be awaited first!");
19448 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone_ptr(arg);
19449 return nativeResponseValue;
19451 // struct LDKChannelHandshakeConfig ChannelHandshakeConfig_clone(const struct LDKChannelHandshakeConfig *NONNULL_PTR orig);
19453 export function ChannelHandshakeConfig_clone(orig: bigint): bigint {
19454 if(!isWasmInitialized) {
19455 throw new Error("initializeWasm() must be awaited first!");
19457 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone(orig);
19458 return nativeResponseValue;
19460 // MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void);
19462 export function ChannelHandshakeConfig_default(): bigint {
19463 if(!isWasmInitialized) {
19464 throw new Error("initializeWasm() must be awaited first!");
19466 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_default();
19467 return nativeResponseValue;
19469 // void ChannelHandshakeLimits_free(struct LDKChannelHandshakeLimits this_obj);
19471 export function ChannelHandshakeLimits_free(this_obj: bigint): void {
19472 if(!isWasmInitialized) {
19473 throw new Error("initializeWasm() must be awaited first!");
19475 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_free(this_obj);
19476 // debug statements here
19478 // uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
19480 export function ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr: bigint): bigint {
19481 if(!isWasmInitialized) {
19482 throw new Error("initializeWasm() must be awaited first!");
19484 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr);
19485 return nativeResponseValue;
19487 // void ChannelHandshakeLimits_set_min_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
19489 export function ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr: bigint, val: bigint): void {
19490 if(!isWasmInitialized) {
19491 throw new Error("initializeWasm() must be awaited first!");
19493 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr, val);
19494 // debug statements here
19496 // uint64_t ChannelHandshakeLimits_get_max_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
19498 export function ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr: bigint): bigint {
19499 if(!isWasmInitialized) {
19500 throw new Error("initializeWasm() must be awaited first!");
19502 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr);
19503 return nativeResponseValue;
19505 // void ChannelHandshakeLimits_set_max_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
19507 export function ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr: bigint, val: bigint): void {
19508 if(!isWasmInitialized) {
19509 throw new Error("initializeWasm() must be awaited first!");
19511 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr, val);
19512 // debug statements here
19514 // uint64_t ChannelHandshakeLimits_get_max_htlc_minimum_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
19516 export function ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr: bigint): bigint {
19517 if(!isWasmInitialized) {
19518 throw new Error("initializeWasm() must be awaited first!");
19520 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr);
19521 return nativeResponseValue;
19523 // void ChannelHandshakeLimits_set_max_htlc_minimum_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
19525 export function ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
19526 if(!isWasmInitialized) {
19527 throw new Error("initializeWasm() must be awaited first!");
19529 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr, val);
19530 // debug statements here
19532 // uint64_t ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
19534 export function ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
19535 if(!isWasmInitialized) {
19536 throw new Error("initializeWasm() must be awaited first!");
19538 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr);
19539 return nativeResponseValue;
19541 // void ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
19543 export function ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
19544 if(!isWasmInitialized) {
19545 throw new Error("initializeWasm() must be awaited first!");
19547 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr, val);
19548 // debug statements here
19550 // uint64_t ChannelHandshakeLimits_get_max_channel_reserve_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
19552 export function ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr: bigint): bigint {
19553 if(!isWasmInitialized) {
19554 throw new Error("initializeWasm() must be awaited first!");
19556 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr);
19557 return nativeResponseValue;
19559 // void ChannelHandshakeLimits_set_max_channel_reserve_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
19561 export function ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
19562 if(!isWasmInitialized) {
19563 throw new Error("initializeWasm() must be awaited first!");
19565 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr, val);
19566 // debug statements here
19568 // uint16_t ChannelHandshakeLimits_get_min_max_accepted_htlcs(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
19570 export function ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr: bigint): number {
19571 if(!isWasmInitialized) {
19572 throw new Error("initializeWasm() must be awaited first!");
19574 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr);
19575 return nativeResponseValue;
19577 // void ChannelHandshakeLimits_set_min_max_accepted_htlcs(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
19579 export function ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr: bigint, val: number): void {
19580 if(!isWasmInitialized) {
19581 throw new Error("initializeWasm() must be awaited first!");
19583 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr, val);
19584 // debug statements here
19586 // uint32_t ChannelHandshakeLimits_get_max_minimum_depth(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
19588 export function ChannelHandshakeLimits_get_max_minimum_depth(this_ptr: bigint): number {
19589 if(!isWasmInitialized) {
19590 throw new Error("initializeWasm() must be awaited first!");
19592 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_minimum_depth(this_ptr);
19593 return nativeResponseValue;
19595 // void ChannelHandshakeLimits_set_max_minimum_depth(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint32_t val);
19597 export function ChannelHandshakeLimits_set_max_minimum_depth(this_ptr: bigint, val: number): void {
19598 if(!isWasmInitialized) {
19599 throw new Error("initializeWasm() must be awaited first!");
19601 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_minimum_depth(this_ptr, val);
19602 // debug statements here
19604 // bool ChannelHandshakeLimits_get_trust_own_funding_0conf(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
19606 export function ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr: bigint): boolean {
19607 if(!isWasmInitialized) {
19608 throw new Error("initializeWasm() must be awaited first!");
19610 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr);
19611 return nativeResponseValue;
19613 // void ChannelHandshakeLimits_set_trust_own_funding_0conf(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
19615 export function ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr: bigint, val: boolean): void {
19616 if(!isWasmInitialized) {
19617 throw new Error("initializeWasm() must be awaited first!");
19619 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr, val);
19620 // debug statements here
19622 // bool ChannelHandshakeLimits_get_force_announced_channel_preference(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
19624 export function ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr: bigint): boolean {
19625 if(!isWasmInitialized) {
19626 throw new Error("initializeWasm() must be awaited first!");
19628 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr);
19629 return nativeResponseValue;
19631 // void ChannelHandshakeLimits_set_force_announced_channel_preference(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
19633 export function ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr: bigint, val: boolean): void {
19634 if(!isWasmInitialized) {
19635 throw new Error("initializeWasm() must be awaited first!");
19637 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr, val);
19638 // debug statements here
19640 // uint16_t ChannelHandshakeLimits_get_their_to_self_delay(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
19642 export function ChannelHandshakeLimits_get_their_to_self_delay(this_ptr: bigint): number {
19643 if(!isWasmInitialized) {
19644 throw new Error("initializeWasm() must be awaited first!");
19646 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_their_to_self_delay(this_ptr);
19647 return nativeResponseValue;
19649 // void ChannelHandshakeLimits_set_their_to_self_delay(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
19651 export function ChannelHandshakeLimits_set_their_to_self_delay(this_ptr: bigint, val: number): void {
19652 if(!isWasmInitialized) {
19653 throw new Error("initializeWasm() must be awaited first!");
19655 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_their_to_self_delay(this_ptr, val);
19656 // debug statements here
19658 // 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);
19660 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 {
19661 if(!isWasmInitialized) {
19662 throw new Error("initializeWasm() must be awaited first!");
19664 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);
19665 return nativeResponseValue;
19667 // uint64_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg);
19669 export function ChannelHandshakeLimits_clone_ptr(arg: bigint): bigint {
19670 if(!isWasmInitialized) {
19671 throw new Error("initializeWasm() must be awaited first!");
19673 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone_ptr(arg);
19674 return nativeResponseValue;
19676 // struct LDKChannelHandshakeLimits ChannelHandshakeLimits_clone(const struct LDKChannelHandshakeLimits *NONNULL_PTR orig);
19678 export function ChannelHandshakeLimits_clone(orig: bigint): bigint {
19679 if(!isWasmInitialized) {
19680 throw new Error("initializeWasm() must be awaited first!");
19682 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone(orig);
19683 return nativeResponseValue;
19685 // MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_default(void);
19687 export function ChannelHandshakeLimits_default(): bigint {
19688 if(!isWasmInitialized) {
19689 throw new Error("initializeWasm() must be awaited first!");
19691 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_default();
19692 return nativeResponseValue;
19694 // void ChannelConfig_free(struct LDKChannelConfig this_obj);
19696 export function ChannelConfig_free(this_obj: bigint): void {
19697 if(!isWasmInitialized) {
19698 throw new Error("initializeWasm() must be awaited first!");
19700 const nativeResponseValue = wasm.TS_ChannelConfig_free(this_obj);
19701 // debug statements here
19703 // uint32_t ChannelConfig_get_forwarding_fee_proportional_millionths(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
19705 export function ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr: bigint): number {
19706 if(!isWasmInitialized) {
19707 throw new Error("initializeWasm() must be awaited first!");
19709 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr);
19710 return nativeResponseValue;
19712 // void ChannelConfig_set_forwarding_fee_proportional_millionths(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
19714 export function ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr: bigint, val: number): void {
19715 if(!isWasmInitialized) {
19716 throw new Error("initializeWasm() must be awaited first!");
19718 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr, val);
19719 // debug statements here
19721 // uint32_t ChannelConfig_get_forwarding_fee_base_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
19723 export function ChannelConfig_get_forwarding_fee_base_msat(this_ptr: bigint): number {
19724 if(!isWasmInitialized) {
19725 throw new Error("initializeWasm() must be awaited first!");
19727 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_base_msat(this_ptr);
19728 return nativeResponseValue;
19730 // void ChannelConfig_set_forwarding_fee_base_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
19732 export function ChannelConfig_set_forwarding_fee_base_msat(this_ptr: bigint, val: number): void {
19733 if(!isWasmInitialized) {
19734 throw new Error("initializeWasm() must be awaited first!");
19736 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_base_msat(this_ptr, val);
19737 // debug statements here
19739 // uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
19741 export function ChannelConfig_get_cltv_expiry_delta(this_ptr: bigint): number {
19742 if(!isWasmInitialized) {
19743 throw new Error("initializeWasm() must be awaited first!");
19745 const nativeResponseValue = wasm.TS_ChannelConfig_get_cltv_expiry_delta(this_ptr);
19746 return nativeResponseValue;
19748 // void ChannelConfig_set_cltv_expiry_delta(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint16_t val);
19750 export function ChannelConfig_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
19751 if(!isWasmInitialized) {
19752 throw new Error("initializeWasm() must be awaited first!");
19754 const nativeResponseValue = wasm.TS_ChannelConfig_set_cltv_expiry_delta(this_ptr, val);
19755 // debug statements here
19757 // uint64_t ChannelConfig_get_max_dust_htlc_exposure_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
19759 export function ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr: bigint): bigint {
19760 if(!isWasmInitialized) {
19761 throw new Error("initializeWasm() must be awaited first!");
19763 const nativeResponseValue = wasm.TS_ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr);
19764 return nativeResponseValue;
19766 // void ChannelConfig_set_max_dust_htlc_exposure_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
19768 export function ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr: bigint, val: bigint): void {
19769 if(!isWasmInitialized) {
19770 throw new Error("initializeWasm() must be awaited first!");
19772 const nativeResponseValue = wasm.TS_ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr, val);
19773 // debug statements here
19775 // uint64_t ChannelConfig_get_force_close_avoidance_max_fee_satoshis(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
19777 export function ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr: bigint): bigint {
19778 if(!isWasmInitialized) {
19779 throw new Error("initializeWasm() must be awaited first!");
19781 const nativeResponseValue = wasm.TS_ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr);
19782 return nativeResponseValue;
19784 // void ChannelConfig_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
19786 export function ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr: bigint, val: bigint): void {
19787 if(!isWasmInitialized) {
19788 throw new Error("initializeWasm() must be awaited first!");
19790 const nativeResponseValue = wasm.TS_ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr, val);
19791 // debug statements here
19793 // 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);
19795 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 {
19796 if(!isWasmInitialized) {
19797 throw new Error("initializeWasm() must be awaited first!");
19799 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);
19800 return nativeResponseValue;
19802 // uint64_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg);
19804 export function ChannelConfig_clone_ptr(arg: bigint): bigint {
19805 if(!isWasmInitialized) {
19806 throw new Error("initializeWasm() must be awaited first!");
19808 const nativeResponseValue = wasm.TS_ChannelConfig_clone_ptr(arg);
19809 return nativeResponseValue;
19811 // struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
19813 export function ChannelConfig_clone(orig: bigint): bigint {
19814 if(!isWasmInitialized) {
19815 throw new Error("initializeWasm() must be awaited first!");
19817 const nativeResponseValue = wasm.TS_ChannelConfig_clone(orig);
19818 return nativeResponseValue;
19820 // bool ChannelConfig_eq(const struct LDKChannelConfig *NONNULL_PTR a, const struct LDKChannelConfig *NONNULL_PTR b);
19822 export function ChannelConfig_eq(a: bigint, b: bigint): boolean {
19823 if(!isWasmInitialized) {
19824 throw new Error("initializeWasm() must be awaited first!");
19826 const nativeResponseValue = wasm.TS_ChannelConfig_eq(a, b);
19827 return nativeResponseValue;
19829 // MUST_USE_RES struct LDKChannelConfig ChannelConfig_default(void);
19831 export function ChannelConfig_default(): bigint {
19832 if(!isWasmInitialized) {
19833 throw new Error("initializeWasm() must be awaited first!");
19835 const nativeResponseValue = wasm.TS_ChannelConfig_default();
19836 return nativeResponseValue;
19838 // struct LDKCVec_u8Z ChannelConfig_write(const struct LDKChannelConfig *NONNULL_PTR obj);
19840 export function ChannelConfig_write(obj: bigint): number {
19841 if(!isWasmInitialized) {
19842 throw new Error("initializeWasm() must be awaited first!");
19844 const nativeResponseValue = wasm.TS_ChannelConfig_write(obj);
19845 return nativeResponseValue;
19847 // struct LDKCResult_ChannelConfigDecodeErrorZ ChannelConfig_read(struct LDKu8slice ser);
19849 export function ChannelConfig_read(ser: number): bigint {
19850 if(!isWasmInitialized) {
19851 throw new Error("initializeWasm() must be awaited first!");
19853 const nativeResponseValue = wasm.TS_ChannelConfig_read(ser);
19854 return nativeResponseValue;
19856 // void UserConfig_free(struct LDKUserConfig this_obj);
19858 export function UserConfig_free(this_obj: bigint): void {
19859 if(!isWasmInitialized) {
19860 throw new Error("initializeWasm() must be awaited first!");
19862 const nativeResponseValue = wasm.TS_UserConfig_free(this_obj);
19863 // debug statements here
19865 // struct LDKChannelHandshakeConfig UserConfig_get_channel_handshake_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
19867 export function UserConfig_get_channel_handshake_config(this_ptr: bigint): bigint {
19868 if(!isWasmInitialized) {
19869 throw new Error("initializeWasm() must be awaited first!");
19871 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_config(this_ptr);
19872 return nativeResponseValue;
19874 // void UserConfig_set_channel_handshake_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeConfig val);
19876 export function UserConfig_set_channel_handshake_config(this_ptr: bigint, val: bigint): void {
19877 if(!isWasmInitialized) {
19878 throw new Error("initializeWasm() must be awaited first!");
19880 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_config(this_ptr, val);
19881 // debug statements here
19883 // struct LDKChannelHandshakeLimits UserConfig_get_channel_handshake_limits(const struct LDKUserConfig *NONNULL_PTR this_ptr);
19885 export function UserConfig_get_channel_handshake_limits(this_ptr: bigint): bigint {
19886 if(!isWasmInitialized) {
19887 throw new Error("initializeWasm() must be awaited first!");
19889 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_limits(this_ptr);
19890 return nativeResponseValue;
19892 // void UserConfig_set_channel_handshake_limits(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeLimits val);
19894 export function UserConfig_set_channel_handshake_limits(this_ptr: bigint, val: bigint): void {
19895 if(!isWasmInitialized) {
19896 throw new Error("initializeWasm() must be awaited first!");
19898 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_limits(this_ptr, val);
19899 // debug statements here
19901 // struct LDKChannelConfig UserConfig_get_channel_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
19903 export function UserConfig_get_channel_config(this_ptr: bigint): bigint {
19904 if(!isWasmInitialized) {
19905 throw new Error("initializeWasm() must be awaited first!");
19907 const nativeResponseValue = wasm.TS_UserConfig_get_channel_config(this_ptr);
19908 return nativeResponseValue;
19910 // void UserConfig_set_channel_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
19912 export function UserConfig_set_channel_config(this_ptr: bigint, val: bigint): void {
19913 if(!isWasmInitialized) {
19914 throw new Error("initializeWasm() must be awaited first!");
19916 const nativeResponseValue = wasm.TS_UserConfig_set_channel_config(this_ptr, val);
19917 // debug statements here
19919 // bool UserConfig_get_accept_forwards_to_priv_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
19921 export function UserConfig_get_accept_forwards_to_priv_channels(this_ptr: bigint): boolean {
19922 if(!isWasmInitialized) {
19923 throw new Error("initializeWasm() must be awaited first!");
19925 const nativeResponseValue = wasm.TS_UserConfig_get_accept_forwards_to_priv_channels(this_ptr);
19926 return nativeResponseValue;
19928 // void UserConfig_set_accept_forwards_to_priv_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
19930 export function UserConfig_set_accept_forwards_to_priv_channels(this_ptr: bigint, val: boolean): void {
19931 if(!isWasmInitialized) {
19932 throw new Error("initializeWasm() must be awaited first!");
19934 const nativeResponseValue = wasm.TS_UserConfig_set_accept_forwards_to_priv_channels(this_ptr, val);
19935 // debug statements here
19937 // bool UserConfig_get_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
19939 export function UserConfig_get_accept_inbound_channels(this_ptr: bigint): boolean {
19940 if(!isWasmInitialized) {
19941 throw new Error("initializeWasm() must be awaited first!");
19943 const nativeResponseValue = wasm.TS_UserConfig_get_accept_inbound_channels(this_ptr);
19944 return nativeResponseValue;
19946 // void UserConfig_set_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
19948 export function UserConfig_set_accept_inbound_channels(this_ptr: bigint, val: boolean): void {
19949 if(!isWasmInitialized) {
19950 throw new Error("initializeWasm() must be awaited first!");
19952 const nativeResponseValue = wasm.TS_UserConfig_set_accept_inbound_channels(this_ptr, val);
19953 // debug statements here
19955 // bool UserConfig_get_manually_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
19957 export function UserConfig_get_manually_accept_inbound_channels(this_ptr: bigint): boolean {
19958 if(!isWasmInitialized) {
19959 throw new Error("initializeWasm() must be awaited first!");
19961 const nativeResponseValue = wasm.TS_UserConfig_get_manually_accept_inbound_channels(this_ptr);
19962 return nativeResponseValue;
19964 // void UserConfig_set_manually_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
19966 export function UserConfig_set_manually_accept_inbound_channels(this_ptr: bigint, val: boolean): void {
19967 if(!isWasmInitialized) {
19968 throw new Error("initializeWasm() must be awaited first!");
19970 const nativeResponseValue = wasm.TS_UserConfig_set_manually_accept_inbound_channels(this_ptr, val);
19971 // debug statements here
19973 // bool UserConfig_get_accept_intercept_htlcs(const struct LDKUserConfig *NONNULL_PTR this_ptr);
19975 export function UserConfig_get_accept_intercept_htlcs(this_ptr: bigint): boolean {
19976 if(!isWasmInitialized) {
19977 throw new Error("initializeWasm() must be awaited first!");
19979 const nativeResponseValue = wasm.TS_UserConfig_get_accept_intercept_htlcs(this_ptr);
19980 return nativeResponseValue;
19982 // void UserConfig_set_accept_intercept_htlcs(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
19984 export function UserConfig_set_accept_intercept_htlcs(this_ptr: bigint, val: boolean): void {
19985 if(!isWasmInitialized) {
19986 throw new Error("initializeWasm() must be awaited first!");
19988 const nativeResponseValue = wasm.TS_UserConfig_set_accept_intercept_htlcs(this_ptr, val);
19989 // debug statements here
19991 // 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, bool accept_intercept_htlcs_arg);
19993 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, accept_intercept_htlcs_arg: boolean): bigint {
19994 if(!isWasmInitialized) {
19995 throw new Error("initializeWasm() must be awaited first!");
19997 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, accept_intercept_htlcs_arg);
19998 return nativeResponseValue;
20000 // uint64_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg);
20002 export function UserConfig_clone_ptr(arg: bigint): bigint {
20003 if(!isWasmInitialized) {
20004 throw new Error("initializeWasm() must be awaited first!");
20006 const nativeResponseValue = wasm.TS_UserConfig_clone_ptr(arg);
20007 return nativeResponseValue;
20009 // struct LDKUserConfig UserConfig_clone(const struct LDKUserConfig *NONNULL_PTR orig);
20011 export function UserConfig_clone(orig: bigint): bigint {
20012 if(!isWasmInitialized) {
20013 throw new Error("initializeWasm() must be awaited first!");
20015 const nativeResponseValue = wasm.TS_UserConfig_clone(orig);
20016 return nativeResponseValue;
20018 // MUST_USE_RES struct LDKUserConfig UserConfig_default(void);
20020 export function UserConfig_default(): bigint {
20021 if(!isWasmInitialized) {
20022 throw new Error("initializeWasm() must be awaited first!");
20024 const nativeResponseValue = wasm.TS_UserConfig_default();
20025 return nativeResponseValue;
20027 // void BestBlock_free(struct LDKBestBlock this_obj);
20029 export function BestBlock_free(this_obj: bigint): void {
20030 if(!isWasmInitialized) {
20031 throw new Error("initializeWasm() must be awaited first!");
20033 const nativeResponseValue = wasm.TS_BestBlock_free(this_obj);
20034 // debug statements here
20036 // uint64_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg);
20038 export function BestBlock_clone_ptr(arg: bigint): bigint {
20039 if(!isWasmInitialized) {
20040 throw new Error("initializeWasm() must be awaited first!");
20042 const nativeResponseValue = wasm.TS_BestBlock_clone_ptr(arg);
20043 return nativeResponseValue;
20045 // struct LDKBestBlock BestBlock_clone(const struct LDKBestBlock *NONNULL_PTR orig);
20047 export function BestBlock_clone(orig: bigint): bigint {
20048 if(!isWasmInitialized) {
20049 throw new Error("initializeWasm() must be awaited first!");
20051 const nativeResponseValue = wasm.TS_BestBlock_clone(orig);
20052 return nativeResponseValue;
20054 // bool BestBlock_eq(const struct LDKBestBlock *NONNULL_PTR a, const struct LDKBestBlock *NONNULL_PTR b);
20056 export function BestBlock_eq(a: bigint, b: bigint): boolean {
20057 if(!isWasmInitialized) {
20058 throw new Error("initializeWasm() must be awaited first!");
20060 const nativeResponseValue = wasm.TS_BestBlock_eq(a, b);
20061 return nativeResponseValue;
20063 // MUST_USE_RES struct LDKBestBlock BestBlock_from_network(enum LDKNetwork network);
20065 export function BestBlock_from_network(network: Network): bigint {
20066 if(!isWasmInitialized) {
20067 throw new Error("initializeWasm() must be awaited first!");
20069 const nativeResponseValue = wasm.TS_BestBlock_from_network(network);
20070 return nativeResponseValue;
20072 // MUST_USE_RES struct LDKBestBlock BestBlock_new(struct LDKThirtyTwoBytes block_hash, uint32_t height);
20074 export function BestBlock_new(block_hash: number, height: number): bigint {
20075 if(!isWasmInitialized) {
20076 throw new Error("initializeWasm() must be awaited first!");
20078 const nativeResponseValue = wasm.TS_BestBlock_new(block_hash, height);
20079 return nativeResponseValue;
20081 // MUST_USE_RES struct LDKThirtyTwoBytes BestBlock_block_hash(const struct LDKBestBlock *NONNULL_PTR this_arg);
20083 export function BestBlock_block_hash(this_arg: bigint): number {
20084 if(!isWasmInitialized) {
20085 throw new Error("initializeWasm() must be awaited first!");
20087 const nativeResponseValue = wasm.TS_BestBlock_block_hash(this_arg);
20088 return nativeResponseValue;
20090 // MUST_USE_RES uint32_t BestBlock_height(const struct LDKBestBlock *NONNULL_PTR this_arg);
20092 export function BestBlock_height(this_arg: bigint): number {
20093 if(!isWasmInitialized) {
20094 throw new Error("initializeWasm() must be awaited first!");
20096 const nativeResponseValue = wasm.TS_BestBlock_height(this_arg);
20097 return nativeResponseValue;
20099 // void Listen_free(struct LDKListen this_ptr);
20101 export function Listen_free(this_ptr: bigint): void {
20102 if(!isWasmInitialized) {
20103 throw new Error("initializeWasm() must be awaited first!");
20105 const nativeResponseValue = wasm.TS_Listen_free(this_ptr);
20106 // debug statements here
20108 // void Confirm_free(struct LDKConfirm this_ptr);
20110 export function Confirm_free(this_ptr: bigint): void {
20111 if(!isWasmInitialized) {
20112 throw new Error("initializeWasm() must be awaited first!");
20114 const nativeResponseValue = wasm.TS_Confirm_free(this_ptr);
20115 // debug statements here
20117 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_clone(const enum LDKChannelMonitorUpdateStatus *NONNULL_PTR orig);
20119 export function ChannelMonitorUpdateStatus_clone(orig: bigint): ChannelMonitorUpdateStatus {
20120 if(!isWasmInitialized) {
20121 throw new Error("initializeWasm() must be awaited first!");
20123 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_clone(orig);
20124 return nativeResponseValue;
20126 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_completed(void);
20128 export function ChannelMonitorUpdateStatus_completed(): ChannelMonitorUpdateStatus {
20129 if(!isWasmInitialized) {
20130 throw new Error("initializeWasm() must be awaited first!");
20132 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_completed();
20133 return nativeResponseValue;
20135 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_in_progress(void);
20137 export function ChannelMonitorUpdateStatus_in_progress(): ChannelMonitorUpdateStatus {
20138 if(!isWasmInitialized) {
20139 throw new Error("initializeWasm() must be awaited first!");
20141 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_in_progress();
20142 return nativeResponseValue;
20144 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_permanent_failure(void);
20146 export function ChannelMonitorUpdateStatus_permanent_failure(): ChannelMonitorUpdateStatus {
20147 if(!isWasmInitialized) {
20148 throw new Error("initializeWasm() must be awaited first!");
20150 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_permanent_failure();
20151 return nativeResponseValue;
20153 // bool ChannelMonitorUpdateStatus_eq(const enum LDKChannelMonitorUpdateStatus *NONNULL_PTR a, const enum LDKChannelMonitorUpdateStatus *NONNULL_PTR b);
20155 export function ChannelMonitorUpdateStatus_eq(a: bigint, b: bigint): boolean {
20156 if(!isWasmInitialized) {
20157 throw new Error("initializeWasm() must be awaited first!");
20159 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_eq(a, b);
20160 return nativeResponseValue;
20162 // void Watch_free(struct LDKWatch this_ptr);
20164 export function Watch_free(this_ptr: bigint): void {
20165 if(!isWasmInitialized) {
20166 throw new Error("initializeWasm() must be awaited first!");
20168 const nativeResponseValue = wasm.TS_Watch_free(this_ptr);
20169 // debug statements here
20171 // void Filter_free(struct LDKFilter this_ptr);
20173 export function Filter_free(this_ptr: bigint): void {
20174 if(!isWasmInitialized) {
20175 throw new Error("initializeWasm() must be awaited first!");
20177 const nativeResponseValue = wasm.TS_Filter_free(this_ptr);
20178 // debug statements here
20180 // void WatchedOutput_free(struct LDKWatchedOutput this_obj);
20182 export function WatchedOutput_free(this_obj: bigint): void {
20183 if(!isWasmInitialized) {
20184 throw new Error("initializeWasm() must be awaited first!");
20186 const nativeResponseValue = wasm.TS_WatchedOutput_free(this_obj);
20187 // debug statements here
20189 // struct LDKThirtyTwoBytes WatchedOutput_get_block_hash(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
20191 export function WatchedOutput_get_block_hash(this_ptr: bigint): number {
20192 if(!isWasmInitialized) {
20193 throw new Error("initializeWasm() must be awaited first!");
20195 const nativeResponseValue = wasm.TS_WatchedOutput_get_block_hash(this_ptr);
20196 return nativeResponseValue;
20198 // void WatchedOutput_set_block_hash(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20200 export function WatchedOutput_set_block_hash(this_ptr: bigint, val: number): void {
20201 if(!isWasmInitialized) {
20202 throw new Error("initializeWasm() must be awaited first!");
20204 const nativeResponseValue = wasm.TS_WatchedOutput_set_block_hash(this_ptr, val);
20205 // debug statements here
20207 // struct LDKOutPoint WatchedOutput_get_outpoint(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
20209 export function WatchedOutput_get_outpoint(this_ptr: bigint): bigint {
20210 if(!isWasmInitialized) {
20211 throw new Error("initializeWasm() must be awaited first!");
20213 const nativeResponseValue = wasm.TS_WatchedOutput_get_outpoint(this_ptr);
20214 return nativeResponseValue;
20216 // void WatchedOutput_set_outpoint(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
20218 export function WatchedOutput_set_outpoint(this_ptr: bigint, val: bigint): void {
20219 if(!isWasmInitialized) {
20220 throw new Error("initializeWasm() must be awaited first!");
20222 const nativeResponseValue = wasm.TS_WatchedOutput_set_outpoint(this_ptr, val);
20223 // debug statements here
20225 // struct LDKu8slice WatchedOutput_get_script_pubkey(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
20227 export function WatchedOutput_get_script_pubkey(this_ptr: bigint): number {
20228 if(!isWasmInitialized) {
20229 throw new Error("initializeWasm() must be awaited first!");
20231 const nativeResponseValue = wasm.TS_WatchedOutput_get_script_pubkey(this_ptr);
20232 return nativeResponseValue;
20234 // void WatchedOutput_set_script_pubkey(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
20236 export function WatchedOutput_set_script_pubkey(this_ptr: bigint, val: number): void {
20237 if(!isWasmInitialized) {
20238 throw new Error("initializeWasm() must be awaited first!");
20240 const nativeResponseValue = wasm.TS_WatchedOutput_set_script_pubkey(this_ptr, val);
20241 // debug statements here
20243 // MUST_USE_RES struct LDKWatchedOutput WatchedOutput_new(struct LDKThirtyTwoBytes block_hash_arg, struct LDKOutPoint outpoint_arg, struct LDKCVec_u8Z script_pubkey_arg);
20245 export function WatchedOutput_new(block_hash_arg: number, outpoint_arg: bigint, script_pubkey_arg: number): bigint {
20246 if(!isWasmInitialized) {
20247 throw new Error("initializeWasm() must be awaited first!");
20249 const nativeResponseValue = wasm.TS_WatchedOutput_new(block_hash_arg, outpoint_arg, script_pubkey_arg);
20250 return nativeResponseValue;
20252 // uint64_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg);
20254 export function WatchedOutput_clone_ptr(arg: bigint): bigint {
20255 if(!isWasmInitialized) {
20256 throw new Error("initializeWasm() must be awaited first!");
20258 const nativeResponseValue = wasm.TS_WatchedOutput_clone_ptr(arg);
20259 return nativeResponseValue;
20261 // struct LDKWatchedOutput WatchedOutput_clone(const struct LDKWatchedOutput *NONNULL_PTR orig);
20263 export function WatchedOutput_clone(orig: bigint): bigint {
20264 if(!isWasmInitialized) {
20265 throw new Error("initializeWasm() must be awaited first!");
20267 const nativeResponseValue = wasm.TS_WatchedOutput_clone(orig);
20268 return nativeResponseValue;
20270 // bool WatchedOutput_eq(const struct LDKWatchedOutput *NONNULL_PTR a, const struct LDKWatchedOutput *NONNULL_PTR b);
20272 export function WatchedOutput_eq(a: bigint, b: bigint): boolean {
20273 if(!isWasmInitialized) {
20274 throw new Error("initializeWasm() must be awaited first!");
20276 const nativeResponseValue = wasm.TS_WatchedOutput_eq(a, b);
20277 return nativeResponseValue;
20279 // uint64_t WatchedOutput_hash(const struct LDKWatchedOutput *NONNULL_PTR o);
20281 export function WatchedOutput_hash(o: bigint): bigint {
20282 if(!isWasmInitialized) {
20283 throw new Error("initializeWasm() must be awaited first!");
20285 const nativeResponseValue = wasm.TS_WatchedOutput_hash(o);
20286 return nativeResponseValue;
20288 // void BroadcasterInterface_free(struct LDKBroadcasterInterface this_ptr);
20290 export function BroadcasterInterface_free(this_ptr: bigint): void {
20291 if(!isWasmInitialized) {
20292 throw new Error("initializeWasm() must be awaited first!");
20294 const nativeResponseValue = wasm.TS_BroadcasterInterface_free(this_ptr);
20295 // debug statements here
20297 // enum LDKConfirmationTarget ConfirmationTarget_clone(const enum LDKConfirmationTarget *NONNULL_PTR orig);
20299 export function ConfirmationTarget_clone(orig: bigint): ConfirmationTarget {
20300 if(!isWasmInitialized) {
20301 throw new Error("initializeWasm() must be awaited first!");
20303 const nativeResponseValue = wasm.TS_ConfirmationTarget_clone(orig);
20304 return nativeResponseValue;
20306 // enum LDKConfirmationTarget ConfirmationTarget_background(void);
20308 export function ConfirmationTarget_background(): ConfirmationTarget {
20309 if(!isWasmInitialized) {
20310 throw new Error("initializeWasm() must be awaited first!");
20312 const nativeResponseValue = wasm.TS_ConfirmationTarget_background();
20313 return nativeResponseValue;
20315 // enum LDKConfirmationTarget ConfirmationTarget_normal(void);
20317 export function ConfirmationTarget_normal(): ConfirmationTarget {
20318 if(!isWasmInitialized) {
20319 throw new Error("initializeWasm() must be awaited first!");
20321 const nativeResponseValue = wasm.TS_ConfirmationTarget_normal();
20322 return nativeResponseValue;
20324 // enum LDKConfirmationTarget ConfirmationTarget_high_priority(void);
20326 export function ConfirmationTarget_high_priority(): ConfirmationTarget {
20327 if(!isWasmInitialized) {
20328 throw new Error("initializeWasm() must be awaited first!");
20330 const nativeResponseValue = wasm.TS_ConfirmationTarget_high_priority();
20331 return nativeResponseValue;
20333 // uint64_t ConfirmationTarget_hash(const enum LDKConfirmationTarget *NONNULL_PTR o);
20335 export function ConfirmationTarget_hash(o: bigint): bigint {
20336 if(!isWasmInitialized) {
20337 throw new Error("initializeWasm() must be awaited first!");
20339 const nativeResponseValue = wasm.TS_ConfirmationTarget_hash(o);
20340 return nativeResponseValue;
20342 // bool ConfirmationTarget_eq(const enum LDKConfirmationTarget *NONNULL_PTR a, const enum LDKConfirmationTarget *NONNULL_PTR b);
20344 export function ConfirmationTarget_eq(a: bigint, b: bigint): boolean {
20345 if(!isWasmInitialized) {
20346 throw new Error("initializeWasm() must be awaited first!");
20348 const nativeResponseValue = wasm.TS_ConfirmationTarget_eq(a, b);
20349 return nativeResponseValue;
20351 // void FeeEstimator_free(struct LDKFeeEstimator this_ptr);
20353 export function FeeEstimator_free(this_ptr: bigint): void {
20354 if(!isWasmInitialized) {
20355 throw new Error("initializeWasm() must be awaited first!");
20357 const nativeResponseValue = wasm.TS_FeeEstimator_free(this_ptr);
20358 // debug statements here
20360 // void MonitorUpdateId_free(struct LDKMonitorUpdateId this_obj);
20362 export function MonitorUpdateId_free(this_obj: bigint): void {
20363 if(!isWasmInitialized) {
20364 throw new Error("initializeWasm() must be awaited first!");
20366 const nativeResponseValue = wasm.TS_MonitorUpdateId_free(this_obj);
20367 // debug statements here
20369 // uint64_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg);
20371 export function MonitorUpdateId_clone_ptr(arg: bigint): bigint {
20372 if(!isWasmInitialized) {
20373 throw new Error("initializeWasm() must be awaited first!");
20375 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone_ptr(arg);
20376 return nativeResponseValue;
20378 // struct LDKMonitorUpdateId MonitorUpdateId_clone(const struct LDKMonitorUpdateId *NONNULL_PTR orig);
20380 export function MonitorUpdateId_clone(orig: bigint): bigint {
20381 if(!isWasmInitialized) {
20382 throw new Error("initializeWasm() must be awaited first!");
20384 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone(orig);
20385 return nativeResponseValue;
20387 // uint64_t MonitorUpdateId_hash(const struct LDKMonitorUpdateId *NONNULL_PTR o);
20389 export function MonitorUpdateId_hash(o: bigint): bigint {
20390 if(!isWasmInitialized) {
20391 throw new Error("initializeWasm() must be awaited first!");
20393 const nativeResponseValue = wasm.TS_MonitorUpdateId_hash(o);
20394 return nativeResponseValue;
20396 // bool MonitorUpdateId_eq(const struct LDKMonitorUpdateId *NONNULL_PTR a, const struct LDKMonitorUpdateId *NONNULL_PTR b);
20398 export function MonitorUpdateId_eq(a: bigint, b: bigint): boolean {
20399 if(!isWasmInitialized) {
20400 throw new Error("initializeWasm() must be awaited first!");
20402 const nativeResponseValue = wasm.TS_MonitorUpdateId_eq(a, b);
20403 return nativeResponseValue;
20405 // void Persist_free(struct LDKPersist this_ptr);
20407 export function Persist_free(this_ptr: bigint): void {
20408 if(!isWasmInitialized) {
20409 throw new Error("initializeWasm() must be awaited first!");
20411 const nativeResponseValue = wasm.TS_Persist_free(this_ptr);
20412 // debug statements here
20414 // void LockedChannelMonitor_free(struct LDKLockedChannelMonitor this_obj);
20416 export function LockedChannelMonitor_free(this_obj: bigint): void {
20417 if(!isWasmInitialized) {
20418 throw new Error("initializeWasm() must be awaited first!");
20420 const nativeResponseValue = wasm.TS_LockedChannelMonitor_free(this_obj);
20421 // debug statements here
20423 // void ChainMonitor_free(struct LDKChainMonitor this_obj);
20425 export function ChainMonitor_free(this_obj: bigint): void {
20426 if(!isWasmInitialized) {
20427 throw new Error("initializeWasm() must be awaited first!");
20429 const nativeResponseValue = wasm.TS_ChainMonitor_free(this_obj);
20430 // debug statements here
20432 // MUST_USE_RES struct LDKChainMonitor ChainMonitor_new(struct LDKCOption_FilterZ chain_source, struct LDKBroadcasterInterface broadcaster, struct LDKLogger logger, struct LDKFeeEstimator feeest, struct LDKPersist persister);
20434 export function ChainMonitor_new(chain_source: bigint, broadcaster: bigint, logger: bigint, feeest: bigint, persister: bigint): bigint {
20435 if(!isWasmInitialized) {
20436 throw new Error("initializeWasm() must be awaited first!");
20438 const nativeResponseValue = wasm.TS_ChainMonitor_new(chain_source, broadcaster, logger, feeest, persister);
20439 return nativeResponseValue;
20441 // MUST_USE_RES struct LDKCVec_BalanceZ ChainMonitor_get_claimable_balances(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKCVec_ChannelDetailsZ ignored_channels);
20443 export function ChainMonitor_get_claimable_balances(this_arg: bigint, ignored_channels: number): number {
20444 if(!isWasmInitialized) {
20445 throw new Error("initializeWasm() must be awaited first!");
20447 const nativeResponseValue = wasm.TS_ChainMonitor_get_claimable_balances(this_arg, ignored_channels);
20448 return nativeResponseValue;
20450 // MUST_USE_RES struct LDKCResult_LockedChannelMonitorNoneZ ChainMonitor_get_monitor(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo);
20452 export function ChainMonitor_get_monitor(this_arg: bigint, funding_txo: bigint): bigint {
20453 if(!isWasmInitialized) {
20454 throw new Error("initializeWasm() must be awaited first!");
20456 const nativeResponseValue = wasm.TS_ChainMonitor_get_monitor(this_arg, funding_txo);
20457 return nativeResponseValue;
20459 // MUST_USE_RES struct LDKCVec_OutPointZ ChainMonitor_list_monitors(const struct LDKChainMonitor *NONNULL_PTR this_arg);
20461 export function ChainMonitor_list_monitors(this_arg: bigint): number {
20462 if(!isWasmInitialized) {
20463 throw new Error("initializeWasm() must be awaited first!");
20465 const nativeResponseValue = wasm.TS_ChainMonitor_list_monitors(this_arg);
20466 return nativeResponseValue;
20468 // MUST_USE_RES struct LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ ChainMonitor_list_pending_monitor_updates(const struct LDKChainMonitor *NONNULL_PTR this_arg);
20470 export function ChainMonitor_list_pending_monitor_updates(this_arg: bigint): number {
20471 if(!isWasmInitialized) {
20472 throw new Error("initializeWasm() must be awaited first!");
20474 const nativeResponseValue = wasm.TS_ChainMonitor_list_pending_monitor_updates(this_arg);
20475 return nativeResponseValue;
20477 // 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);
20479 export function ChainMonitor_channel_monitor_updated(this_arg: bigint, funding_txo: bigint, completed_update_id: bigint): bigint {
20480 if(!isWasmInitialized) {
20481 throw new Error("initializeWasm() must be awaited first!");
20483 const nativeResponseValue = wasm.TS_ChainMonitor_channel_monitor_updated(this_arg, funding_txo, completed_update_id);
20484 return nativeResponseValue;
20486 // struct LDKListen ChainMonitor_as_Listen(const struct LDKChainMonitor *NONNULL_PTR this_arg);
20488 export function ChainMonitor_as_Listen(this_arg: bigint): bigint {
20489 if(!isWasmInitialized) {
20490 throw new Error("initializeWasm() must be awaited first!");
20492 const nativeResponseValue = wasm.TS_ChainMonitor_as_Listen(this_arg);
20493 return nativeResponseValue;
20495 // struct LDKConfirm ChainMonitor_as_Confirm(const struct LDKChainMonitor *NONNULL_PTR this_arg);
20497 export function ChainMonitor_as_Confirm(this_arg: bigint): bigint {
20498 if(!isWasmInitialized) {
20499 throw new Error("initializeWasm() must be awaited first!");
20501 const nativeResponseValue = wasm.TS_ChainMonitor_as_Confirm(this_arg);
20502 return nativeResponseValue;
20504 // struct LDKWatch ChainMonitor_as_Watch(const struct LDKChainMonitor *NONNULL_PTR this_arg);
20506 export function ChainMonitor_as_Watch(this_arg: bigint): bigint {
20507 if(!isWasmInitialized) {
20508 throw new Error("initializeWasm() must be awaited first!");
20510 const nativeResponseValue = wasm.TS_ChainMonitor_as_Watch(this_arg);
20511 return nativeResponseValue;
20513 // struct LDKEventsProvider ChainMonitor_as_EventsProvider(const struct LDKChainMonitor *NONNULL_PTR this_arg);
20515 export function ChainMonitor_as_EventsProvider(this_arg: bigint): bigint {
20516 if(!isWasmInitialized) {
20517 throw new Error("initializeWasm() must be awaited first!");
20519 const nativeResponseValue = wasm.TS_ChainMonitor_as_EventsProvider(this_arg);
20520 return nativeResponseValue;
20522 // void ChannelMonitorUpdate_free(struct LDKChannelMonitorUpdate this_obj);
20524 export function ChannelMonitorUpdate_free(this_obj: bigint): void {
20525 if(!isWasmInitialized) {
20526 throw new Error("initializeWasm() must be awaited first!");
20528 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_free(this_obj);
20529 // debug statements here
20531 // uint64_t ChannelMonitorUpdate_get_update_id(const struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr);
20533 export function ChannelMonitorUpdate_get_update_id(this_ptr: bigint): bigint {
20534 if(!isWasmInitialized) {
20535 throw new Error("initializeWasm() must be awaited first!");
20537 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_get_update_id(this_ptr);
20538 return nativeResponseValue;
20540 // void ChannelMonitorUpdate_set_update_id(struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr, uint64_t val);
20542 export function ChannelMonitorUpdate_set_update_id(this_ptr: bigint, val: bigint): void {
20543 if(!isWasmInitialized) {
20544 throw new Error("initializeWasm() must be awaited first!");
20546 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_set_update_id(this_ptr, val);
20547 // debug statements here
20549 // uint64_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg);
20551 export function ChannelMonitorUpdate_clone_ptr(arg: bigint): bigint {
20552 if(!isWasmInitialized) {
20553 throw new Error("initializeWasm() must be awaited first!");
20555 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone_ptr(arg);
20556 return nativeResponseValue;
20558 // struct LDKChannelMonitorUpdate ChannelMonitorUpdate_clone(const struct LDKChannelMonitorUpdate *NONNULL_PTR orig);
20560 export function ChannelMonitorUpdate_clone(orig: bigint): bigint {
20561 if(!isWasmInitialized) {
20562 throw new Error("initializeWasm() must be awaited first!");
20564 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone(orig);
20565 return nativeResponseValue;
20567 // struct LDKCVec_u8Z ChannelMonitorUpdate_write(const struct LDKChannelMonitorUpdate *NONNULL_PTR obj);
20569 export function ChannelMonitorUpdate_write(obj: bigint): number {
20570 if(!isWasmInitialized) {
20571 throw new Error("initializeWasm() must be awaited first!");
20573 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_write(obj);
20574 return nativeResponseValue;
20576 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ ChannelMonitorUpdate_read(struct LDKu8slice ser);
20578 export function ChannelMonitorUpdate_read(ser: number): bigint {
20579 if(!isWasmInitialized) {
20580 throw new Error("initializeWasm() must be awaited first!");
20582 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_read(ser);
20583 return nativeResponseValue;
20585 // void MonitorEvent_free(struct LDKMonitorEvent this_ptr);
20587 export function MonitorEvent_free(this_ptr: bigint): void {
20588 if(!isWasmInitialized) {
20589 throw new Error("initializeWasm() must be awaited first!");
20591 const nativeResponseValue = wasm.TS_MonitorEvent_free(this_ptr);
20592 // debug statements here
20594 // uint64_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg);
20596 export function MonitorEvent_clone_ptr(arg: bigint): bigint {
20597 if(!isWasmInitialized) {
20598 throw new Error("initializeWasm() must be awaited first!");
20600 const nativeResponseValue = wasm.TS_MonitorEvent_clone_ptr(arg);
20601 return nativeResponseValue;
20603 // struct LDKMonitorEvent MonitorEvent_clone(const struct LDKMonitorEvent *NONNULL_PTR orig);
20605 export function MonitorEvent_clone(orig: bigint): bigint {
20606 if(!isWasmInitialized) {
20607 throw new Error("initializeWasm() must be awaited first!");
20609 const nativeResponseValue = wasm.TS_MonitorEvent_clone(orig);
20610 return nativeResponseValue;
20612 // struct LDKMonitorEvent MonitorEvent_htlcevent(struct LDKHTLCUpdate a);
20614 export function MonitorEvent_htlcevent(a: bigint): bigint {
20615 if(!isWasmInitialized) {
20616 throw new Error("initializeWasm() must be awaited first!");
20618 const nativeResponseValue = wasm.TS_MonitorEvent_htlcevent(a);
20619 return nativeResponseValue;
20621 // struct LDKMonitorEvent MonitorEvent_commitment_tx_confirmed(struct LDKOutPoint a);
20623 export function MonitorEvent_commitment_tx_confirmed(a: bigint): bigint {
20624 if(!isWasmInitialized) {
20625 throw new Error("initializeWasm() must be awaited first!");
20627 const nativeResponseValue = wasm.TS_MonitorEvent_commitment_tx_confirmed(a);
20628 return nativeResponseValue;
20630 // struct LDKMonitorEvent MonitorEvent_completed(struct LDKOutPoint funding_txo, uint64_t monitor_update_id);
20632 export function MonitorEvent_completed(funding_txo: bigint, monitor_update_id: bigint): bigint {
20633 if(!isWasmInitialized) {
20634 throw new Error("initializeWasm() must be awaited first!");
20636 const nativeResponseValue = wasm.TS_MonitorEvent_completed(funding_txo, monitor_update_id);
20637 return nativeResponseValue;
20639 // struct LDKMonitorEvent MonitorEvent_update_failed(struct LDKOutPoint a);
20641 export function MonitorEvent_update_failed(a: bigint): bigint {
20642 if(!isWasmInitialized) {
20643 throw new Error("initializeWasm() must be awaited first!");
20645 const nativeResponseValue = wasm.TS_MonitorEvent_update_failed(a);
20646 return nativeResponseValue;
20648 // bool MonitorEvent_eq(const struct LDKMonitorEvent *NONNULL_PTR a, const struct LDKMonitorEvent *NONNULL_PTR b);
20650 export function MonitorEvent_eq(a: bigint, b: bigint): boolean {
20651 if(!isWasmInitialized) {
20652 throw new Error("initializeWasm() must be awaited first!");
20654 const nativeResponseValue = wasm.TS_MonitorEvent_eq(a, b);
20655 return nativeResponseValue;
20657 // struct LDKCVec_u8Z MonitorEvent_write(const struct LDKMonitorEvent *NONNULL_PTR obj);
20659 export function MonitorEvent_write(obj: bigint): number {
20660 if(!isWasmInitialized) {
20661 throw new Error("initializeWasm() must be awaited first!");
20663 const nativeResponseValue = wasm.TS_MonitorEvent_write(obj);
20664 return nativeResponseValue;
20666 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ MonitorEvent_read(struct LDKu8slice ser);
20668 export function MonitorEvent_read(ser: number): bigint {
20669 if(!isWasmInitialized) {
20670 throw new Error("initializeWasm() must be awaited first!");
20672 const nativeResponseValue = wasm.TS_MonitorEvent_read(ser);
20673 return nativeResponseValue;
20675 // void HTLCUpdate_free(struct LDKHTLCUpdate this_obj);
20677 export function HTLCUpdate_free(this_obj: bigint): void {
20678 if(!isWasmInitialized) {
20679 throw new Error("initializeWasm() must be awaited first!");
20681 const nativeResponseValue = wasm.TS_HTLCUpdate_free(this_obj);
20682 // debug statements here
20684 // uint64_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg);
20686 export function HTLCUpdate_clone_ptr(arg: bigint): bigint {
20687 if(!isWasmInitialized) {
20688 throw new Error("initializeWasm() must be awaited first!");
20690 const nativeResponseValue = wasm.TS_HTLCUpdate_clone_ptr(arg);
20691 return nativeResponseValue;
20693 // struct LDKHTLCUpdate HTLCUpdate_clone(const struct LDKHTLCUpdate *NONNULL_PTR orig);
20695 export function HTLCUpdate_clone(orig: bigint): bigint {
20696 if(!isWasmInitialized) {
20697 throw new Error("initializeWasm() must be awaited first!");
20699 const nativeResponseValue = wasm.TS_HTLCUpdate_clone(orig);
20700 return nativeResponseValue;
20702 // bool HTLCUpdate_eq(const struct LDKHTLCUpdate *NONNULL_PTR a, const struct LDKHTLCUpdate *NONNULL_PTR b);
20704 export function HTLCUpdate_eq(a: bigint, b: bigint): boolean {
20705 if(!isWasmInitialized) {
20706 throw new Error("initializeWasm() must be awaited first!");
20708 const nativeResponseValue = wasm.TS_HTLCUpdate_eq(a, b);
20709 return nativeResponseValue;
20711 // struct LDKCVec_u8Z HTLCUpdate_write(const struct LDKHTLCUpdate *NONNULL_PTR obj);
20713 export function HTLCUpdate_write(obj: bigint): number {
20714 if(!isWasmInitialized) {
20715 throw new Error("initializeWasm() must be awaited first!");
20717 const nativeResponseValue = wasm.TS_HTLCUpdate_write(obj);
20718 return nativeResponseValue;
20720 // struct LDKCResult_HTLCUpdateDecodeErrorZ HTLCUpdate_read(struct LDKu8slice ser);
20722 export function HTLCUpdate_read(ser: number): bigint {
20723 if(!isWasmInitialized) {
20724 throw new Error("initializeWasm() must be awaited first!");
20726 const nativeResponseValue = wasm.TS_HTLCUpdate_read(ser);
20727 return nativeResponseValue;
20729 // void Balance_free(struct LDKBalance this_ptr);
20731 export function Balance_free(this_ptr: bigint): void {
20732 if(!isWasmInitialized) {
20733 throw new Error("initializeWasm() must be awaited first!");
20735 const nativeResponseValue = wasm.TS_Balance_free(this_ptr);
20736 // debug statements here
20738 // uint64_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg);
20740 export function Balance_clone_ptr(arg: bigint): bigint {
20741 if(!isWasmInitialized) {
20742 throw new Error("initializeWasm() must be awaited first!");
20744 const nativeResponseValue = wasm.TS_Balance_clone_ptr(arg);
20745 return nativeResponseValue;
20747 // struct LDKBalance Balance_clone(const struct LDKBalance *NONNULL_PTR orig);
20749 export function Balance_clone(orig: bigint): bigint {
20750 if(!isWasmInitialized) {
20751 throw new Error("initializeWasm() must be awaited first!");
20753 const nativeResponseValue = wasm.TS_Balance_clone(orig);
20754 return nativeResponseValue;
20756 // struct LDKBalance Balance_claimable_on_channel_close(uint64_t claimable_amount_satoshis);
20758 export function Balance_claimable_on_channel_close(claimable_amount_satoshis: bigint): bigint {
20759 if(!isWasmInitialized) {
20760 throw new Error("initializeWasm() must be awaited first!");
20762 const nativeResponseValue = wasm.TS_Balance_claimable_on_channel_close(claimable_amount_satoshis);
20763 return nativeResponseValue;
20765 // struct LDKBalance Balance_claimable_awaiting_confirmations(uint64_t claimable_amount_satoshis, uint32_t confirmation_height);
20767 export function Balance_claimable_awaiting_confirmations(claimable_amount_satoshis: bigint, confirmation_height: number): bigint {
20768 if(!isWasmInitialized) {
20769 throw new Error("initializeWasm() must be awaited first!");
20771 const nativeResponseValue = wasm.TS_Balance_claimable_awaiting_confirmations(claimable_amount_satoshis, confirmation_height);
20772 return nativeResponseValue;
20774 // struct LDKBalance Balance_contentious_claimable(uint64_t claimable_amount_satoshis, uint32_t timeout_height);
20776 export function Balance_contentious_claimable(claimable_amount_satoshis: bigint, timeout_height: number): bigint {
20777 if(!isWasmInitialized) {
20778 throw new Error("initializeWasm() must be awaited first!");
20780 const nativeResponseValue = wasm.TS_Balance_contentious_claimable(claimable_amount_satoshis, timeout_height);
20781 return nativeResponseValue;
20783 // struct LDKBalance Balance_maybe_timeout_claimable_htlc(uint64_t claimable_amount_satoshis, uint32_t claimable_height);
20785 export function Balance_maybe_timeout_claimable_htlc(claimable_amount_satoshis: bigint, claimable_height: number): bigint {
20786 if(!isWasmInitialized) {
20787 throw new Error("initializeWasm() must be awaited first!");
20789 const nativeResponseValue = wasm.TS_Balance_maybe_timeout_claimable_htlc(claimable_amount_satoshis, claimable_height);
20790 return nativeResponseValue;
20792 // struct LDKBalance Balance_maybe_preimage_claimable_htlc(uint64_t claimable_amount_satoshis, uint32_t expiry_height);
20794 export function Balance_maybe_preimage_claimable_htlc(claimable_amount_satoshis: bigint, expiry_height: number): bigint {
20795 if(!isWasmInitialized) {
20796 throw new Error("initializeWasm() must be awaited first!");
20798 const nativeResponseValue = wasm.TS_Balance_maybe_preimage_claimable_htlc(claimable_amount_satoshis, expiry_height);
20799 return nativeResponseValue;
20801 // struct LDKBalance Balance_counterparty_revoked_output_claimable(uint64_t claimable_amount_satoshis);
20803 export function Balance_counterparty_revoked_output_claimable(claimable_amount_satoshis: bigint): bigint {
20804 if(!isWasmInitialized) {
20805 throw new Error("initializeWasm() must be awaited first!");
20807 const nativeResponseValue = wasm.TS_Balance_counterparty_revoked_output_claimable(claimable_amount_satoshis);
20808 return nativeResponseValue;
20810 // bool Balance_eq(const struct LDKBalance *NONNULL_PTR a, const struct LDKBalance *NONNULL_PTR b);
20812 export function Balance_eq(a: bigint, b: bigint): boolean {
20813 if(!isWasmInitialized) {
20814 throw new Error("initializeWasm() must be awaited first!");
20816 const nativeResponseValue = wasm.TS_Balance_eq(a, b);
20817 return nativeResponseValue;
20819 // void ChannelMonitor_free(struct LDKChannelMonitor this_obj);
20821 export function ChannelMonitor_free(this_obj: bigint): void {
20822 if(!isWasmInitialized) {
20823 throw new Error("initializeWasm() must be awaited first!");
20825 const nativeResponseValue = wasm.TS_ChannelMonitor_free(this_obj);
20826 // debug statements here
20828 // uint64_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg);
20830 export function ChannelMonitor_clone_ptr(arg: bigint): bigint {
20831 if(!isWasmInitialized) {
20832 throw new Error("initializeWasm() must be awaited first!");
20834 const nativeResponseValue = wasm.TS_ChannelMonitor_clone_ptr(arg);
20835 return nativeResponseValue;
20837 // struct LDKChannelMonitor ChannelMonitor_clone(const struct LDKChannelMonitor *NONNULL_PTR orig);
20839 export function ChannelMonitor_clone(orig: bigint): bigint {
20840 if(!isWasmInitialized) {
20841 throw new Error("initializeWasm() must be awaited first!");
20843 const nativeResponseValue = wasm.TS_ChannelMonitor_clone(orig);
20844 return nativeResponseValue;
20846 // struct LDKCVec_u8Z ChannelMonitor_write(const struct LDKChannelMonitor *NONNULL_PTR obj);
20848 export function ChannelMonitor_write(obj: bigint): number {
20849 if(!isWasmInitialized) {
20850 throw new Error("initializeWasm() must be awaited first!");
20852 const nativeResponseValue = wasm.TS_ChannelMonitor_write(obj);
20853 return nativeResponseValue;
20855 // 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);
20857 export function ChannelMonitor_update_monitor(this_arg: bigint, updates: bigint, broadcaster: bigint, fee_estimator: bigint, logger: bigint): bigint {
20858 if(!isWasmInitialized) {
20859 throw new Error("initializeWasm() must be awaited first!");
20861 const nativeResponseValue = wasm.TS_ChannelMonitor_update_monitor(this_arg, updates, broadcaster, fee_estimator, logger);
20862 return nativeResponseValue;
20864 // MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
20866 export function ChannelMonitor_get_latest_update_id(this_arg: bigint): bigint {
20867 if(!isWasmInitialized) {
20868 throw new Error("initializeWasm() must be awaited first!");
20870 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_update_id(this_arg);
20871 return nativeResponseValue;
20873 // MUST_USE_RES struct LDKC2Tuple_OutPointScriptZ ChannelMonitor_get_funding_txo(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
20875 export function ChannelMonitor_get_funding_txo(this_arg: bigint): bigint {
20876 if(!isWasmInitialized) {
20877 throw new Error("initializeWasm() must be awaited first!");
20879 const nativeResponseValue = wasm.TS_ChannelMonitor_get_funding_txo(this_arg);
20880 return nativeResponseValue;
20882 // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ChannelMonitor_get_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
20884 export function ChannelMonitor_get_outputs_to_watch(this_arg: bigint): number {
20885 if(!isWasmInitialized) {
20886 throw new Error("initializeWasm() must be awaited first!");
20888 const nativeResponseValue = wasm.TS_ChannelMonitor_get_outputs_to_watch(this_arg);
20889 return nativeResponseValue;
20891 // void ChannelMonitor_load_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKFilter *NONNULL_PTR filter);
20893 export function ChannelMonitor_load_outputs_to_watch(this_arg: bigint, filter: bigint): void {
20894 if(!isWasmInitialized) {
20895 throw new Error("initializeWasm() must be awaited first!");
20897 const nativeResponseValue = wasm.TS_ChannelMonitor_load_outputs_to_watch(this_arg, filter);
20898 // debug statements here
20900 // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
20902 export function ChannelMonitor_get_and_clear_pending_monitor_events(this_arg: bigint): number {
20903 if(!isWasmInitialized) {
20904 throw new Error("initializeWasm() must be awaited first!");
20906 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_monitor_events(this_arg);
20907 return nativeResponseValue;
20909 // MUST_USE_RES struct LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
20911 export function ChannelMonitor_get_and_clear_pending_events(this_arg: bigint): number {
20912 if(!isWasmInitialized) {
20913 throw new Error("initializeWasm() must be awaited first!");
20915 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_events(this_arg);
20916 return nativeResponseValue;
20918 // MUST_USE_RES struct LDKPublicKey ChannelMonitor_get_counterparty_node_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
20920 export function ChannelMonitor_get_counterparty_node_id(this_arg: bigint): number {
20921 if(!isWasmInitialized) {
20922 throw new Error("initializeWasm() must be awaited first!");
20924 const nativeResponseValue = wasm.TS_ChannelMonitor_get_counterparty_node_id(this_arg);
20925 return nativeResponseValue;
20927 // 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);
20929 export function ChannelMonitor_get_latest_holder_commitment_txn(this_arg: bigint, logger: bigint): number {
20930 if(!isWasmInitialized) {
20931 throw new Error("initializeWasm() must be awaited first!");
20933 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_holder_commitment_txn(this_arg, logger);
20934 return nativeResponseValue;
20936 // 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);
20938 export function ChannelMonitor_block_connected(this_arg: bigint, header: number, txdata: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
20939 if(!isWasmInitialized) {
20940 throw new Error("initializeWasm() must be awaited first!");
20942 const nativeResponseValue = wasm.TS_ChannelMonitor_block_connected(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
20943 return nativeResponseValue;
20945 // 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);
20947 export function ChannelMonitor_block_disconnected(this_arg: bigint, header: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
20948 if(!isWasmInitialized) {
20949 throw new Error("initializeWasm() must be awaited first!");
20951 const nativeResponseValue = wasm.TS_ChannelMonitor_block_disconnected(this_arg, header, height, broadcaster, fee_estimator, logger);
20952 // debug statements here
20954 // 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);
20956 export function ChannelMonitor_transactions_confirmed(this_arg: bigint, header: number, txdata: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
20957 if(!isWasmInitialized) {
20958 throw new Error("initializeWasm() must be awaited first!");
20960 const nativeResponseValue = wasm.TS_ChannelMonitor_transactions_confirmed(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
20961 return nativeResponseValue;
20963 // 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);
20965 export function ChannelMonitor_transaction_unconfirmed(this_arg: bigint, txid: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
20966 if(!isWasmInitialized) {
20967 throw new Error("initializeWasm() must be awaited first!");
20969 const nativeResponseValue = wasm.TS_ChannelMonitor_transaction_unconfirmed(this_arg, txid, broadcaster, fee_estimator, logger);
20970 // debug statements here
20972 // 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);
20974 export function ChannelMonitor_best_block_updated(this_arg: bigint, header: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
20975 if(!isWasmInitialized) {
20976 throw new Error("initializeWasm() must be awaited first!");
20978 const nativeResponseValue = wasm.TS_ChannelMonitor_best_block_updated(this_arg, header, height, broadcaster, fee_estimator, logger);
20979 return nativeResponseValue;
20981 // MUST_USE_RES struct LDKCVec_C2Tuple_TxidBlockHashZZ ChannelMonitor_get_relevant_txids(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
20983 export function ChannelMonitor_get_relevant_txids(this_arg: bigint): number {
20984 if(!isWasmInitialized) {
20985 throw new Error("initializeWasm() must be awaited first!");
20987 const nativeResponseValue = wasm.TS_ChannelMonitor_get_relevant_txids(this_arg);
20988 return nativeResponseValue;
20990 // MUST_USE_RES struct LDKBestBlock ChannelMonitor_current_best_block(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
20992 export function ChannelMonitor_current_best_block(this_arg: bigint): bigint {
20993 if(!isWasmInitialized) {
20994 throw new Error("initializeWasm() must be awaited first!");
20996 const nativeResponseValue = wasm.TS_ChannelMonitor_current_best_block(this_arg);
20997 return nativeResponseValue;
20999 // MUST_USE_RES struct LDKCVec_BalanceZ ChannelMonitor_get_claimable_balances(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
21001 export function ChannelMonitor_get_claimable_balances(this_arg: bigint): number {
21002 if(!isWasmInitialized) {
21003 throw new Error("initializeWasm() must be awaited first!");
21005 const nativeResponseValue = wasm.TS_ChannelMonitor_get_claimable_balances(this_arg);
21006 return nativeResponseValue;
21008 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ C2Tuple_BlockHashChannelMonitorZ_read(struct LDKu8slice ser, const struct LDKEntropySource *NONNULL_PTR arg_a, const struct LDKSignerProvider *NONNULL_PTR arg_b);
21010 export function C2Tuple_BlockHashChannelMonitorZ_read(ser: number, arg_a: bigint, arg_b: bigint): bigint {
21011 if(!isWasmInitialized) {
21012 throw new Error("initializeWasm() must be awaited first!");
21014 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_read(ser, arg_a, arg_b);
21015 return nativeResponseValue;
21017 // void OutPoint_free(struct LDKOutPoint this_obj);
21019 export function OutPoint_free(this_obj: bigint): void {
21020 if(!isWasmInitialized) {
21021 throw new Error("initializeWasm() must be awaited first!");
21023 const nativeResponseValue = wasm.TS_OutPoint_free(this_obj);
21024 // debug statements here
21026 // const uint8_t (*OutPoint_get_txid(const struct LDKOutPoint *NONNULL_PTR this_ptr))[32];
21028 export function OutPoint_get_txid(this_ptr: bigint): number {
21029 if(!isWasmInitialized) {
21030 throw new Error("initializeWasm() must be awaited first!");
21032 const nativeResponseValue = wasm.TS_OutPoint_get_txid(this_ptr);
21033 return nativeResponseValue;
21035 // void OutPoint_set_txid(struct LDKOutPoint *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21037 export function OutPoint_set_txid(this_ptr: bigint, val: number): void {
21038 if(!isWasmInitialized) {
21039 throw new Error("initializeWasm() must be awaited first!");
21041 const nativeResponseValue = wasm.TS_OutPoint_set_txid(this_ptr, val);
21042 // debug statements here
21044 // uint16_t OutPoint_get_index(const struct LDKOutPoint *NONNULL_PTR this_ptr);
21046 export function OutPoint_get_index(this_ptr: bigint): number {
21047 if(!isWasmInitialized) {
21048 throw new Error("initializeWasm() must be awaited first!");
21050 const nativeResponseValue = wasm.TS_OutPoint_get_index(this_ptr);
21051 return nativeResponseValue;
21053 // void OutPoint_set_index(struct LDKOutPoint *NONNULL_PTR this_ptr, uint16_t val);
21055 export function OutPoint_set_index(this_ptr: bigint, val: number): void {
21056 if(!isWasmInitialized) {
21057 throw new Error("initializeWasm() must be awaited first!");
21059 const nativeResponseValue = wasm.TS_OutPoint_set_index(this_ptr, val);
21060 // debug statements here
21062 // MUST_USE_RES struct LDKOutPoint OutPoint_new(struct LDKThirtyTwoBytes txid_arg, uint16_t index_arg);
21064 export function OutPoint_new(txid_arg: number, index_arg: number): bigint {
21065 if(!isWasmInitialized) {
21066 throw new Error("initializeWasm() must be awaited first!");
21068 const nativeResponseValue = wasm.TS_OutPoint_new(txid_arg, index_arg);
21069 return nativeResponseValue;
21071 // uint64_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg);
21073 export function OutPoint_clone_ptr(arg: bigint): bigint {
21074 if(!isWasmInitialized) {
21075 throw new Error("initializeWasm() must be awaited first!");
21077 const nativeResponseValue = wasm.TS_OutPoint_clone_ptr(arg);
21078 return nativeResponseValue;
21080 // struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig);
21082 export function OutPoint_clone(orig: bigint): bigint {
21083 if(!isWasmInitialized) {
21084 throw new Error("initializeWasm() must be awaited first!");
21086 const nativeResponseValue = wasm.TS_OutPoint_clone(orig);
21087 return nativeResponseValue;
21089 // bool OutPoint_eq(const struct LDKOutPoint *NONNULL_PTR a, const struct LDKOutPoint *NONNULL_PTR b);
21091 export function OutPoint_eq(a: bigint, b: bigint): boolean {
21092 if(!isWasmInitialized) {
21093 throw new Error("initializeWasm() must be awaited first!");
21095 const nativeResponseValue = wasm.TS_OutPoint_eq(a, b);
21096 return nativeResponseValue;
21098 // uint64_t OutPoint_hash(const struct LDKOutPoint *NONNULL_PTR o);
21100 export function OutPoint_hash(o: bigint): bigint {
21101 if(!isWasmInitialized) {
21102 throw new Error("initializeWasm() must be awaited first!");
21104 const nativeResponseValue = wasm.TS_OutPoint_hash(o);
21105 return nativeResponseValue;
21107 // MUST_USE_RES struct LDKThirtyTwoBytes OutPoint_to_channel_id(const struct LDKOutPoint *NONNULL_PTR this_arg);
21109 export function OutPoint_to_channel_id(this_arg: bigint): number {
21110 if(!isWasmInitialized) {
21111 throw new Error("initializeWasm() must be awaited first!");
21113 const nativeResponseValue = wasm.TS_OutPoint_to_channel_id(this_arg);
21114 return nativeResponseValue;
21116 // struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj);
21118 export function OutPoint_write(obj: bigint): number {
21119 if(!isWasmInitialized) {
21120 throw new Error("initializeWasm() must be awaited first!");
21122 const nativeResponseValue = wasm.TS_OutPoint_write(obj);
21123 return nativeResponseValue;
21125 // struct LDKCResult_OutPointDecodeErrorZ OutPoint_read(struct LDKu8slice ser);
21127 export function OutPoint_read(ser: number): bigint {
21128 if(!isWasmInitialized) {
21129 throw new Error("initializeWasm() must be awaited first!");
21131 const nativeResponseValue = wasm.TS_OutPoint_read(ser);
21132 return nativeResponseValue;
21134 // void DelayedPaymentOutputDescriptor_free(struct LDKDelayedPaymentOutputDescriptor this_obj);
21136 export function DelayedPaymentOutputDescriptor_free(this_obj: bigint): void {
21137 if(!isWasmInitialized) {
21138 throw new Error("initializeWasm() must be awaited first!");
21140 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_free(this_obj);
21141 // debug statements here
21143 // struct LDKOutPoint DelayedPaymentOutputDescriptor_get_outpoint(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
21145 export function DelayedPaymentOutputDescriptor_get_outpoint(this_ptr: bigint): bigint {
21146 if(!isWasmInitialized) {
21147 throw new Error("initializeWasm() must be awaited first!");
21149 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_outpoint(this_ptr);
21150 return nativeResponseValue;
21152 // void DelayedPaymentOutputDescriptor_set_outpoint(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
21154 export function DelayedPaymentOutputDescriptor_set_outpoint(this_ptr: bigint, val: bigint): void {
21155 if(!isWasmInitialized) {
21156 throw new Error("initializeWasm() must be awaited first!");
21158 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_outpoint(this_ptr, val);
21159 // debug statements here
21161 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_per_commitment_point(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
21163 export function DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr: bigint): number {
21164 if(!isWasmInitialized) {
21165 throw new Error("initializeWasm() must be awaited first!");
21167 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr);
21168 return nativeResponseValue;
21170 // void DelayedPaymentOutputDescriptor_set_per_commitment_point(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21172 export function DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr: bigint, val: number): void {
21173 if(!isWasmInitialized) {
21174 throw new Error("initializeWasm() must be awaited first!");
21176 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr, val);
21177 // debug statements here
21179 // uint16_t DelayedPaymentOutputDescriptor_get_to_self_delay(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
21181 export function DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr: bigint): number {
21182 if(!isWasmInitialized) {
21183 throw new Error("initializeWasm() must be awaited first!");
21185 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr);
21186 return nativeResponseValue;
21188 // void DelayedPaymentOutputDescriptor_set_to_self_delay(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint16_t val);
21190 export function DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr: bigint, val: number): void {
21191 if(!isWasmInitialized) {
21192 throw new Error("initializeWasm() must be awaited first!");
21194 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr, val);
21195 // debug statements here
21197 // struct LDKTxOut DelayedPaymentOutputDescriptor_get_output(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
21199 export function DelayedPaymentOutputDescriptor_get_output(this_ptr: bigint): bigint {
21200 if(!isWasmInitialized) {
21201 throw new Error("initializeWasm() must be awaited first!");
21203 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_output(this_ptr);
21204 return nativeResponseValue;
21206 // void DelayedPaymentOutputDescriptor_set_output(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
21208 export function DelayedPaymentOutputDescriptor_set_output(this_ptr: bigint, val: bigint): void {
21209 if(!isWasmInitialized) {
21210 throw new Error("initializeWasm() must be awaited first!");
21212 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_output(this_ptr, val);
21213 // debug statements here
21215 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_revocation_pubkey(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
21217 export function DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr: bigint): number {
21218 if(!isWasmInitialized) {
21219 throw new Error("initializeWasm() must be awaited first!");
21221 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr);
21222 return nativeResponseValue;
21224 // void DelayedPaymentOutputDescriptor_set_revocation_pubkey(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21226 export function DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr: bigint, val: number): void {
21227 if(!isWasmInitialized) {
21228 throw new Error("initializeWasm() must be awaited first!");
21230 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr, val);
21231 // debug statements here
21233 // const uint8_t (*DelayedPaymentOutputDescriptor_get_channel_keys_id(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
21235 export function DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr: bigint): number {
21236 if(!isWasmInitialized) {
21237 throw new Error("initializeWasm() must be awaited first!");
21239 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
21240 return nativeResponseValue;
21242 // void DelayedPaymentOutputDescriptor_set_channel_keys_id(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21244 export function DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr: bigint, val: number): void {
21245 if(!isWasmInitialized) {
21246 throw new Error("initializeWasm() must be awaited first!");
21248 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
21249 // debug statements here
21251 // uint64_t DelayedPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
21253 export function DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: bigint): bigint {
21254 if(!isWasmInitialized) {
21255 throw new Error("initializeWasm() must be awaited first!");
21257 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
21258 return nativeResponseValue;
21260 // void DelayedPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
21262 export function DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
21263 if(!isWasmInitialized) {
21264 throw new Error("initializeWasm() must be awaited first!");
21266 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
21267 // debug statements here
21269 // 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);
21271 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 {
21272 if(!isWasmInitialized) {
21273 throw new Error("initializeWasm() must be awaited first!");
21275 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);
21276 return nativeResponseValue;
21278 // uint64_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg);
21280 export function DelayedPaymentOutputDescriptor_clone_ptr(arg: bigint): bigint {
21281 if(!isWasmInitialized) {
21282 throw new Error("initializeWasm() must be awaited first!");
21284 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone_ptr(arg);
21285 return nativeResponseValue;
21287 // struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_clone(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR orig);
21289 export function DelayedPaymentOutputDescriptor_clone(orig: bigint): bigint {
21290 if(!isWasmInitialized) {
21291 throw new Error("initializeWasm() must be awaited first!");
21293 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone(orig);
21294 return nativeResponseValue;
21296 // bool DelayedPaymentOutputDescriptor_eq(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR a, const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR b);
21298 export function DelayedPaymentOutputDescriptor_eq(a: bigint, b: bigint): boolean {
21299 if(!isWasmInitialized) {
21300 throw new Error("initializeWasm() must be awaited first!");
21302 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_eq(a, b);
21303 return nativeResponseValue;
21305 // struct LDKCVec_u8Z DelayedPaymentOutputDescriptor_write(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR obj);
21307 export function DelayedPaymentOutputDescriptor_write(obj: bigint): number {
21308 if(!isWasmInitialized) {
21309 throw new Error("initializeWasm() must be awaited first!");
21311 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_write(obj);
21312 return nativeResponseValue;
21314 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ DelayedPaymentOutputDescriptor_read(struct LDKu8slice ser);
21316 export function DelayedPaymentOutputDescriptor_read(ser: number): bigint {
21317 if(!isWasmInitialized) {
21318 throw new Error("initializeWasm() must be awaited first!");
21320 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_read(ser);
21321 return nativeResponseValue;
21323 // void StaticPaymentOutputDescriptor_free(struct LDKStaticPaymentOutputDescriptor this_obj);
21325 export function StaticPaymentOutputDescriptor_free(this_obj: bigint): void {
21326 if(!isWasmInitialized) {
21327 throw new Error("initializeWasm() must be awaited first!");
21329 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_free(this_obj);
21330 // debug statements here
21332 // struct LDKOutPoint StaticPaymentOutputDescriptor_get_outpoint(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
21334 export function StaticPaymentOutputDescriptor_get_outpoint(this_ptr: bigint): bigint {
21335 if(!isWasmInitialized) {
21336 throw new Error("initializeWasm() must be awaited first!");
21338 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_outpoint(this_ptr);
21339 return nativeResponseValue;
21341 // void StaticPaymentOutputDescriptor_set_outpoint(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
21343 export function StaticPaymentOutputDescriptor_set_outpoint(this_ptr: bigint, val: bigint): void {
21344 if(!isWasmInitialized) {
21345 throw new Error("initializeWasm() must be awaited first!");
21347 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_outpoint(this_ptr, val);
21348 // debug statements here
21350 // struct LDKTxOut StaticPaymentOutputDescriptor_get_output(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
21352 export function StaticPaymentOutputDescriptor_get_output(this_ptr: bigint): bigint {
21353 if(!isWasmInitialized) {
21354 throw new Error("initializeWasm() must be awaited first!");
21356 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_output(this_ptr);
21357 return nativeResponseValue;
21359 // void StaticPaymentOutputDescriptor_set_output(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
21361 export function StaticPaymentOutputDescriptor_set_output(this_ptr: bigint, val: bigint): void {
21362 if(!isWasmInitialized) {
21363 throw new Error("initializeWasm() must be awaited first!");
21365 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_output(this_ptr, val);
21366 // debug statements here
21368 // const uint8_t (*StaticPaymentOutputDescriptor_get_channel_keys_id(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
21370 export function StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr: bigint): number {
21371 if(!isWasmInitialized) {
21372 throw new Error("initializeWasm() must be awaited first!");
21374 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
21375 return nativeResponseValue;
21377 // void StaticPaymentOutputDescriptor_set_channel_keys_id(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21379 export function StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr: bigint, val: number): void {
21380 if(!isWasmInitialized) {
21381 throw new Error("initializeWasm() must be awaited first!");
21383 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
21384 // debug statements here
21386 // uint64_t StaticPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
21388 export function StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: bigint): bigint {
21389 if(!isWasmInitialized) {
21390 throw new Error("initializeWasm() must be awaited first!");
21392 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
21393 return nativeResponseValue;
21395 // void StaticPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
21397 export function StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
21398 if(!isWasmInitialized) {
21399 throw new Error("initializeWasm() must be awaited first!");
21401 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
21402 // debug statements here
21404 // 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);
21406 export function StaticPaymentOutputDescriptor_new(outpoint_arg: bigint, output_arg: bigint, channel_keys_id_arg: number, channel_value_satoshis_arg: bigint): bigint {
21407 if(!isWasmInitialized) {
21408 throw new Error("initializeWasm() must be awaited first!");
21410 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_new(outpoint_arg, output_arg, channel_keys_id_arg, channel_value_satoshis_arg);
21411 return nativeResponseValue;
21413 // uint64_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg);
21415 export function StaticPaymentOutputDescriptor_clone_ptr(arg: bigint): bigint {
21416 if(!isWasmInitialized) {
21417 throw new Error("initializeWasm() must be awaited first!");
21419 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone_ptr(arg);
21420 return nativeResponseValue;
21422 // struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_clone(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR orig);
21424 export function StaticPaymentOutputDescriptor_clone(orig: bigint): bigint {
21425 if(!isWasmInitialized) {
21426 throw new Error("initializeWasm() must be awaited first!");
21428 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone(orig);
21429 return nativeResponseValue;
21431 // bool StaticPaymentOutputDescriptor_eq(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR a, const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR b);
21433 export function StaticPaymentOutputDescriptor_eq(a: bigint, b: bigint): boolean {
21434 if(!isWasmInitialized) {
21435 throw new Error("initializeWasm() must be awaited first!");
21437 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_eq(a, b);
21438 return nativeResponseValue;
21440 // struct LDKCVec_u8Z StaticPaymentOutputDescriptor_write(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR obj);
21442 export function StaticPaymentOutputDescriptor_write(obj: bigint): number {
21443 if(!isWasmInitialized) {
21444 throw new Error("initializeWasm() must be awaited first!");
21446 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_write(obj);
21447 return nativeResponseValue;
21449 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ StaticPaymentOutputDescriptor_read(struct LDKu8slice ser);
21451 export function StaticPaymentOutputDescriptor_read(ser: number): bigint {
21452 if(!isWasmInitialized) {
21453 throw new Error("initializeWasm() must be awaited first!");
21455 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_read(ser);
21456 return nativeResponseValue;
21458 // void SpendableOutputDescriptor_free(struct LDKSpendableOutputDescriptor this_ptr);
21460 export function SpendableOutputDescriptor_free(this_ptr: bigint): void {
21461 if(!isWasmInitialized) {
21462 throw new Error("initializeWasm() must be awaited first!");
21464 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_free(this_ptr);
21465 // debug statements here
21467 // uint64_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg);
21469 export function SpendableOutputDescriptor_clone_ptr(arg: bigint): bigint {
21470 if(!isWasmInitialized) {
21471 throw new Error("initializeWasm() must be awaited first!");
21473 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone_ptr(arg);
21474 return nativeResponseValue;
21476 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_clone(const struct LDKSpendableOutputDescriptor *NONNULL_PTR orig);
21478 export function SpendableOutputDescriptor_clone(orig: bigint): bigint {
21479 if(!isWasmInitialized) {
21480 throw new Error("initializeWasm() must be awaited first!");
21482 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone(orig);
21483 return nativeResponseValue;
21485 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_output(struct LDKOutPoint outpoint, struct LDKTxOut output);
21487 export function SpendableOutputDescriptor_static_output(outpoint: bigint, output: bigint): bigint {
21488 if(!isWasmInitialized) {
21489 throw new Error("initializeWasm() must be awaited first!");
21491 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_output(outpoint, output);
21492 return nativeResponseValue;
21494 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_delayed_payment_output(struct LDKDelayedPaymentOutputDescriptor a);
21496 export function SpendableOutputDescriptor_delayed_payment_output(a: bigint): bigint {
21497 if(!isWasmInitialized) {
21498 throw new Error("initializeWasm() must be awaited first!");
21500 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_delayed_payment_output(a);
21501 return nativeResponseValue;
21503 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_payment_output(struct LDKStaticPaymentOutputDescriptor a);
21505 export function SpendableOutputDescriptor_static_payment_output(a: bigint): bigint {
21506 if(!isWasmInitialized) {
21507 throw new Error("initializeWasm() must be awaited first!");
21509 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_payment_output(a);
21510 return nativeResponseValue;
21512 // bool SpendableOutputDescriptor_eq(const struct LDKSpendableOutputDescriptor *NONNULL_PTR a, const struct LDKSpendableOutputDescriptor *NONNULL_PTR b);
21514 export function SpendableOutputDescriptor_eq(a: bigint, b: bigint): boolean {
21515 if(!isWasmInitialized) {
21516 throw new Error("initializeWasm() must be awaited first!");
21518 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_eq(a, b);
21519 return nativeResponseValue;
21521 // struct LDKCVec_u8Z SpendableOutputDescriptor_write(const struct LDKSpendableOutputDescriptor *NONNULL_PTR obj);
21523 export function SpendableOutputDescriptor_write(obj: bigint): number {
21524 if(!isWasmInitialized) {
21525 throw new Error("initializeWasm() must be awaited first!");
21527 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_write(obj);
21528 return nativeResponseValue;
21530 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ SpendableOutputDescriptor_read(struct LDKu8slice ser);
21532 export function SpendableOutputDescriptor_read(ser: number): bigint {
21533 if(!isWasmInitialized) {
21534 throw new Error("initializeWasm() must be awaited first!");
21536 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_read(ser);
21537 return nativeResponseValue;
21539 // void ChannelSigner_free(struct LDKChannelSigner this_ptr);
21541 export function ChannelSigner_free(this_ptr: bigint): void {
21542 if(!isWasmInitialized) {
21543 throw new Error("initializeWasm() must be awaited first!");
21545 const nativeResponseValue = wasm.TS_ChannelSigner_free(this_ptr);
21546 // debug statements here
21548 // void EcdsaChannelSigner_free(struct LDKEcdsaChannelSigner this_ptr);
21550 export function EcdsaChannelSigner_free(this_ptr: bigint): void {
21551 if(!isWasmInitialized) {
21552 throw new Error("initializeWasm() must be awaited first!");
21554 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_free(this_ptr);
21555 // debug statements here
21557 // uint64_t WriteableEcdsaChannelSigner_clone_ptr(LDKWriteableEcdsaChannelSigner *NONNULL_PTR arg);
21559 export function WriteableEcdsaChannelSigner_clone_ptr(arg: bigint): bigint {
21560 if(!isWasmInitialized) {
21561 throw new Error("initializeWasm() must be awaited first!");
21563 const nativeResponseValue = wasm.TS_WriteableEcdsaChannelSigner_clone_ptr(arg);
21564 return nativeResponseValue;
21566 // struct LDKWriteableEcdsaChannelSigner WriteableEcdsaChannelSigner_clone(const struct LDKWriteableEcdsaChannelSigner *NONNULL_PTR orig);
21568 export function WriteableEcdsaChannelSigner_clone(orig: bigint): bigint {
21569 if(!isWasmInitialized) {
21570 throw new Error("initializeWasm() must be awaited first!");
21572 const nativeResponseValue = wasm.TS_WriteableEcdsaChannelSigner_clone(orig);
21573 return nativeResponseValue;
21575 // void WriteableEcdsaChannelSigner_free(struct LDKWriteableEcdsaChannelSigner this_ptr);
21577 export function WriteableEcdsaChannelSigner_free(this_ptr: bigint): void {
21578 if(!isWasmInitialized) {
21579 throw new Error("initializeWasm() must be awaited first!");
21581 const nativeResponseValue = wasm.TS_WriteableEcdsaChannelSigner_free(this_ptr);
21582 // debug statements here
21584 // enum LDKRecipient Recipient_clone(const enum LDKRecipient *NONNULL_PTR orig);
21586 export function Recipient_clone(orig: bigint): Recipient {
21587 if(!isWasmInitialized) {
21588 throw new Error("initializeWasm() must be awaited first!");
21590 const nativeResponseValue = wasm.TS_Recipient_clone(orig);
21591 return nativeResponseValue;
21593 // enum LDKRecipient Recipient_node(void);
21595 export function Recipient_node(): Recipient {
21596 if(!isWasmInitialized) {
21597 throw new Error("initializeWasm() must be awaited first!");
21599 const nativeResponseValue = wasm.TS_Recipient_node();
21600 return nativeResponseValue;
21602 // enum LDKRecipient Recipient_phantom_node(void);
21604 export function Recipient_phantom_node(): Recipient {
21605 if(!isWasmInitialized) {
21606 throw new Error("initializeWasm() must be awaited first!");
21608 const nativeResponseValue = wasm.TS_Recipient_phantom_node();
21609 return nativeResponseValue;
21611 // void EntropySource_free(struct LDKEntropySource this_ptr);
21613 export function EntropySource_free(this_ptr: bigint): void {
21614 if(!isWasmInitialized) {
21615 throw new Error("initializeWasm() must be awaited first!");
21617 const nativeResponseValue = wasm.TS_EntropySource_free(this_ptr);
21618 // debug statements here
21620 // void NodeSigner_free(struct LDKNodeSigner this_ptr);
21622 export function NodeSigner_free(this_ptr: bigint): void {
21623 if(!isWasmInitialized) {
21624 throw new Error("initializeWasm() must be awaited first!");
21626 const nativeResponseValue = wasm.TS_NodeSigner_free(this_ptr);
21627 // debug statements here
21629 // void SignerProvider_free(struct LDKSignerProvider this_ptr);
21631 export function SignerProvider_free(this_ptr: bigint): void {
21632 if(!isWasmInitialized) {
21633 throw new Error("initializeWasm() must be awaited first!");
21635 const nativeResponseValue = wasm.TS_SignerProvider_free(this_ptr);
21636 // debug statements here
21638 // void InMemorySigner_free(struct LDKInMemorySigner this_obj);
21640 export function InMemorySigner_free(this_obj: bigint): void {
21641 if(!isWasmInitialized) {
21642 throw new Error("initializeWasm() must be awaited first!");
21644 const nativeResponseValue = wasm.TS_InMemorySigner_free(this_obj);
21645 // debug statements here
21647 // const uint8_t (*InMemorySigner_get_funding_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
21649 export function InMemorySigner_get_funding_key(this_ptr: bigint): number {
21650 if(!isWasmInitialized) {
21651 throw new Error("initializeWasm() must be awaited first!");
21653 const nativeResponseValue = wasm.TS_InMemorySigner_get_funding_key(this_ptr);
21654 return nativeResponseValue;
21656 // void InMemorySigner_set_funding_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
21658 export function InMemorySigner_set_funding_key(this_ptr: bigint, val: number): void {
21659 if(!isWasmInitialized) {
21660 throw new Error("initializeWasm() must be awaited first!");
21662 const nativeResponseValue = wasm.TS_InMemorySigner_set_funding_key(this_ptr, val);
21663 // debug statements here
21665 // const uint8_t (*InMemorySigner_get_revocation_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
21667 export function InMemorySigner_get_revocation_base_key(this_ptr: bigint): number {
21668 if(!isWasmInitialized) {
21669 throw new Error("initializeWasm() must be awaited first!");
21671 const nativeResponseValue = wasm.TS_InMemorySigner_get_revocation_base_key(this_ptr);
21672 return nativeResponseValue;
21674 // void InMemorySigner_set_revocation_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
21676 export function InMemorySigner_set_revocation_base_key(this_ptr: bigint, val: number): void {
21677 if(!isWasmInitialized) {
21678 throw new Error("initializeWasm() must be awaited first!");
21680 const nativeResponseValue = wasm.TS_InMemorySigner_set_revocation_base_key(this_ptr, val);
21681 // debug statements here
21683 // const uint8_t (*InMemorySigner_get_payment_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
21685 export function InMemorySigner_get_payment_key(this_ptr: bigint): number {
21686 if(!isWasmInitialized) {
21687 throw new Error("initializeWasm() must be awaited first!");
21689 const nativeResponseValue = wasm.TS_InMemorySigner_get_payment_key(this_ptr);
21690 return nativeResponseValue;
21692 // void InMemorySigner_set_payment_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
21694 export function InMemorySigner_set_payment_key(this_ptr: bigint, val: number): void {
21695 if(!isWasmInitialized) {
21696 throw new Error("initializeWasm() must be awaited first!");
21698 const nativeResponseValue = wasm.TS_InMemorySigner_set_payment_key(this_ptr, val);
21699 // debug statements here
21701 // const uint8_t (*InMemorySigner_get_delayed_payment_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
21703 export function InMemorySigner_get_delayed_payment_base_key(this_ptr: bigint): number {
21704 if(!isWasmInitialized) {
21705 throw new Error("initializeWasm() must be awaited first!");
21707 const nativeResponseValue = wasm.TS_InMemorySigner_get_delayed_payment_base_key(this_ptr);
21708 return nativeResponseValue;
21710 // void InMemorySigner_set_delayed_payment_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
21712 export function InMemorySigner_set_delayed_payment_base_key(this_ptr: bigint, val: number): void {
21713 if(!isWasmInitialized) {
21714 throw new Error("initializeWasm() must be awaited first!");
21716 const nativeResponseValue = wasm.TS_InMemorySigner_set_delayed_payment_base_key(this_ptr, val);
21717 // debug statements here
21719 // const uint8_t (*InMemorySigner_get_htlc_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
21721 export function InMemorySigner_get_htlc_base_key(this_ptr: bigint): number {
21722 if(!isWasmInitialized) {
21723 throw new Error("initializeWasm() must be awaited first!");
21725 const nativeResponseValue = wasm.TS_InMemorySigner_get_htlc_base_key(this_ptr);
21726 return nativeResponseValue;
21728 // void InMemorySigner_set_htlc_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
21730 export function InMemorySigner_set_htlc_base_key(this_ptr: bigint, val: number): void {
21731 if(!isWasmInitialized) {
21732 throw new Error("initializeWasm() must be awaited first!");
21734 const nativeResponseValue = wasm.TS_InMemorySigner_set_htlc_base_key(this_ptr, val);
21735 // debug statements here
21737 // const uint8_t (*InMemorySigner_get_commitment_seed(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
21739 export function InMemorySigner_get_commitment_seed(this_ptr: bigint): number {
21740 if(!isWasmInitialized) {
21741 throw new Error("initializeWasm() must be awaited first!");
21743 const nativeResponseValue = wasm.TS_InMemorySigner_get_commitment_seed(this_ptr);
21744 return nativeResponseValue;
21746 // void InMemorySigner_set_commitment_seed(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21748 export function InMemorySigner_set_commitment_seed(this_ptr: bigint, val: number): void {
21749 if(!isWasmInitialized) {
21750 throw new Error("initializeWasm() must be awaited first!");
21752 const nativeResponseValue = wasm.TS_InMemorySigner_set_commitment_seed(this_ptr, val);
21753 // debug statements here
21755 // uint64_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg);
21757 export function InMemorySigner_clone_ptr(arg: bigint): bigint {
21758 if(!isWasmInitialized) {
21759 throw new Error("initializeWasm() must be awaited first!");
21761 const nativeResponseValue = wasm.TS_InMemorySigner_clone_ptr(arg);
21762 return nativeResponseValue;
21764 // struct LDKInMemorySigner InMemorySigner_clone(const struct LDKInMemorySigner *NONNULL_PTR orig);
21766 export function InMemorySigner_clone(orig: bigint): bigint {
21767 if(!isWasmInitialized) {
21768 throw new Error("initializeWasm() must be awaited first!");
21770 const nativeResponseValue = wasm.TS_InMemorySigner_clone(orig);
21771 return nativeResponseValue;
21773 // MUST_USE_RES struct LDKInMemorySigner InMemorySigner_new(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);
21775 export function InMemorySigner_new(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 {
21776 if(!isWasmInitialized) {
21777 throw new Error("initializeWasm() must be awaited first!");
21779 const nativeResponseValue = wasm.TS_InMemorySigner_new(funding_key, revocation_base_key, payment_key, delayed_payment_base_key, htlc_base_key, commitment_seed, channel_value_satoshis, channel_keys_id);
21780 return nativeResponseValue;
21782 // MUST_USE_RES struct LDKChannelPublicKeys InMemorySigner_counterparty_pubkeys(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
21784 export function InMemorySigner_counterparty_pubkeys(this_arg: bigint): bigint {
21785 if(!isWasmInitialized) {
21786 throw new Error("initializeWasm() must be awaited first!");
21788 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_pubkeys(this_arg);
21789 return nativeResponseValue;
21791 // MUST_USE_RES uint16_t InMemorySigner_counterparty_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
21793 export function InMemorySigner_counterparty_selected_contest_delay(this_arg: bigint): number {
21794 if(!isWasmInitialized) {
21795 throw new Error("initializeWasm() must be awaited first!");
21797 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_selected_contest_delay(this_arg);
21798 return nativeResponseValue;
21800 // MUST_USE_RES uint16_t InMemorySigner_holder_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
21802 export function InMemorySigner_holder_selected_contest_delay(this_arg: bigint): number {
21803 if(!isWasmInitialized) {
21804 throw new Error("initializeWasm() must be awaited first!");
21806 const nativeResponseValue = wasm.TS_InMemorySigner_holder_selected_contest_delay(this_arg);
21807 return nativeResponseValue;
21809 // MUST_USE_RES bool InMemorySigner_is_outbound(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
21811 export function InMemorySigner_is_outbound(this_arg: bigint): boolean {
21812 if(!isWasmInitialized) {
21813 throw new Error("initializeWasm() must be awaited first!");
21815 const nativeResponseValue = wasm.TS_InMemorySigner_is_outbound(this_arg);
21816 return nativeResponseValue;
21818 // MUST_USE_RES struct LDKOutPoint InMemorySigner_funding_outpoint(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
21820 export function InMemorySigner_funding_outpoint(this_arg: bigint): bigint {
21821 if(!isWasmInitialized) {
21822 throw new Error("initializeWasm() must be awaited first!");
21824 const nativeResponseValue = wasm.TS_InMemorySigner_funding_outpoint(this_arg);
21825 return nativeResponseValue;
21827 // MUST_USE_RES struct LDKChannelTransactionParameters InMemorySigner_get_channel_parameters(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
21829 export function InMemorySigner_get_channel_parameters(this_arg: bigint): bigint {
21830 if(!isWasmInitialized) {
21831 throw new Error("initializeWasm() must be awaited first!");
21833 const nativeResponseValue = wasm.TS_InMemorySigner_get_channel_parameters(this_arg);
21834 return nativeResponseValue;
21836 // MUST_USE_RES bool InMemorySigner_opt_anchors(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
21838 export function InMemorySigner_opt_anchors(this_arg: bigint): boolean {
21839 if(!isWasmInitialized) {
21840 throw new Error("initializeWasm() must be awaited first!");
21842 const nativeResponseValue = wasm.TS_InMemorySigner_opt_anchors(this_arg);
21843 return nativeResponseValue;
21845 // 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);
21847 export function InMemorySigner_sign_counterparty_payment_input(this_arg: bigint, spend_tx: number, input_idx: number, descriptor: bigint): bigint {
21848 if(!isWasmInitialized) {
21849 throw new Error("initializeWasm() must be awaited first!");
21851 const nativeResponseValue = wasm.TS_InMemorySigner_sign_counterparty_payment_input(this_arg, spend_tx, input_idx, descriptor);
21852 return nativeResponseValue;
21854 // 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);
21856 export function InMemorySigner_sign_dynamic_p2wsh_input(this_arg: bigint, spend_tx: number, input_idx: number, descriptor: bigint): bigint {
21857 if(!isWasmInitialized) {
21858 throw new Error("initializeWasm() must be awaited first!");
21860 const nativeResponseValue = wasm.TS_InMemorySigner_sign_dynamic_p2wsh_input(this_arg, spend_tx, input_idx, descriptor);
21861 return nativeResponseValue;
21863 // struct LDKChannelSigner InMemorySigner_as_ChannelSigner(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
21865 export function InMemorySigner_as_ChannelSigner(this_arg: bigint): bigint {
21866 if(!isWasmInitialized) {
21867 throw new Error("initializeWasm() must be awaited first!");
21869 const nativeResponseValue = wasm.TS_InMemorySigner_as_ChannelSigner(this_arg);
21870 return nativeResponseValue;
21872 // struct LDKEcdsaChannelSigner InMemorySigner_as_EcdsaChannelSigner(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
21874 export function InMemorySigner_as_EcdsaChannelSigner(this_arg: bigint): bigint {
21875 if(!isWasmInitialized) {
21876 throw new Error("initializeWasm() must be awaited first!");
21878 const nativeResponseValue = wasm.TS_InMemorySigner_as_EcdsaChannelSigner(this_arg);
21879 return nativeResponseValue;
21881 // struct LDKWriteableEcdsaChannelSigner InMemorySigner_as_WriteableEcdsaChannelSigner(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
21883 export function InMemorySigner_as_WriteableEcdsaChannelSigner(this_arg: bigint): bigint {
21884 if(!isWasmInitialized) {
21885 throw new Error("initializeWasm() must be awaited first!");
21887 const nativeResponseValue = wasm.TS_InMemorySigner_as_WriteableEcdsaChannelSigner(this_arg);
21888 return nativeResponseValue;
21890 // struct LDKCVec_u8Z InMemorySigner_write(const struct LDKInMemorySigner *NONNULL_PTR obj);
21892 export function InMemorySigner_write(obj: bigint): number {
21893 if(!isWasmInitialized) {
21894 throw new Error("initializeWasm() must be awaited first!");
21896 const nativeResponseValue = wasm.TS_InMemorySigner_write(obj);
21897 return nativeResponseValue;
21899 // struct LDKCResult_InMemorySignerDecodeErrorZ InMemorySigner_read(struct LDKu8slice ser);
21901 export function InMemorySigner_read(ser: number): bigint {
21902 if(!isWasmInitialized) {
21903 throw new Error("initializeWasm() must be awaited first!");
21905 const nativeResponseValue = wasm.TS_InMemorySigner_read(ser);
21906 return nativeResponseValue;
21908 // void KeysManager_free(struct LDKKeysManager this_obj);
21910 export function KeysManager_free(this_obj: bigint): void {
21911 if(!isWasmInitialized) {
21912 throw new Error("initializeWasm() must be awaited first!");
21914 const nativeResponseValue = wasm.TS_KeysManager_free(this_obj);
21915 // debug statements here
21917 // MUST_USE_RES struct LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], uint64_t starting_time_secs, uint32_t starting_time_nanos);
21919 export function KeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number): bigint {
21920 if(!isWasmInitialized) {
21921 throw new Error("initializeWasm() must be awaited first!");
21923 const nativeResponseValue = wasm.TS_KeysManager_new(seed, starting_time_secs, starting_time_nanos);
21924 return nativeResponseValue;
21926 // MUST_USE_RES struct LDKSecretKey KeysManager_get_node_secret_key(const struct LDKKeysManager *NONNULL_PTR this_arg);
21928 export function KeysManager_get_node_secret_key(this_arg: bigint): number {
21929 if(!isWasmInitialized) {
21930 throw new Error("initializeWasm() must be awaited first!");
21932 const nativeResponseValue = wasm.TS_KeysManager_get_node_secret_key(this_arg);
21933 return nativeResponseValue;
21935 // 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]);
21937 export function KeysManager_derive_channel_keys(this_arg: bigint, channel_value_satoshis: bigint, params: number): bigint {
21938 if(!isWasmInitialized) {
21939 throw new Error("initializeWasm() must be awaited first!");
21941 const nativeResponseValue = wasm.TS_KeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
21942 return nativeResponseValue;
21944 // 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);
21946 export function KeysManager_spend_spendable_outputs(this_arg: bigint, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): bigint {
21947 if(!isWasmInitialized) {
21948 throw new Error("initializeWasm() must be awaited first!");
21950 const nativeResponseValue = wasm.TS_KeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
21951 return nativeResponseValue;
21953 // struct LDKEntropySource KeysManager_as_EntropySource(const struct LDKKeysManager *NONNULL_PTR this_arg);
21955 export function KeysManager_as_EntropySource(this_arg: bigint): bigint {
21956 if(!isWasmInitialized) {
21957 throw new Error("initializeWasm() must be awaited first!");
21959 const nativeResponseValue = wasm.TS_KeysManager_as_EntropySource(this_arg);
21960 return nativeResponseValue;
21962 // struct LDKNodeSigner KeysManager_as_NodeSigner(const struct LDKKeysManager *NONNULL_PTR this_arg);
21964 export function KeysManager_as_NodeSigner(this_arg: bigint): bigint {
21965 if(!isWasmInitialized) {
21966 throw new Error("initializeWasm() must be awaited first!");
21968 const nativeResponseValue = wasm.TS_KeysManager_as_NodeSigner(this_arg);
21969 return nativeResponseValue;
21971 // struct LDKSignerProvider KeysManager_as_SignerProvider(const struct LDKKeysManager *NONNULL_PTR this_arg);
21973 export function KeysManager_as_SignerProvider(this_arg: bigint): bigint {
21974 if(!isWasmInitialized) {
21975 throw new Error("initializeWasm() must be awaited first!");
21977 const nativeResponseValue = wasm.TS_KeysManager_as_SignerProvider(this_arg);
21978 return nativeResponseValue;
21980 // void PhantomKeysManager_free(struct LDKPhantomKeysManager this_obj);
21982 export function PhantomKeysManager_free(this_obj: bigint): void {
21983 if(!isWasmInitialized) {
21984 throw new Error("initializeWasm() must be awaited first!");
21986 const nativeResponseValue = wasm.TS_PhantomKeysManager_free(this_obj);
21987 // debug statements here
21989 // struct LDKEntropySource PhantomKeysManager_as_EntropySource(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
21991 export function PhantomKeysManager_as_EntropySource(this_arg: bigint): bigint {
21992 if(!isWasmInitialized) {
21993 throw new Error("initializeWasm() must be awaited first!");
21995 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_EntropySource(this_arg);
21996 return nativeResponseValue;
21998 // struct LDKNodeSigner PhantomKeysManager_as_NodeSigner(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
22000 export function PhantomKeysManager_as_NodeSigner(this_arg: bigint): bigint {
22001 if(!isWasmInitialized) {
22002 throw new Error("initializeWasm() must be awaited first!");
22004 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_NodeSigner(this_arg);
22005 return nativeResponseValue;
22007 // struct LDKSignerProvider PhantomKeysManager_as_SignerProvider(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
22009 export function PhantomKeysManager_as_SignerProvider(this_arg: bigint): bigint {
22010 if(!isWasmInitialized) {
22011 throw new Error("initializeWasm() must be awaited first!");
22013 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_SignerProvider(this_arg);
22014 return nativeResponseValue;
22016 // 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]);
22018 export function PhantomKeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number, cross_node_seed: number): bigint {
22019 if(!isWasmInitialized) {
22020 throw new Error("initializeWasm() must be awaited first!");
22022 const nativeResponseValue = wasm.TS_PhantomKeysManager_new(seed, starting_time_secs, starting_time_nanos, cross_node_seed);
22023 return nativeResponseValue;
22025 // 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);
22027 export function PhantomKeysManager_spend_spendable_outputs(this_arg: bigint, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): bigint {
22028 if(!isWasmInitialized) {
22029 throw new Error("initializeWasm() must be awaited first!");
22031 const nativeResponseValue = wasm.TS_PhantomKeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
22032 return nativeResponseValue;
22034 // 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]);
22036 export function PhantomKeysManager_derive_channel_keys(this_arg: bigint, channel_value_satoshis: bigint, params: number): bigint {
22037 if(!isWasmInitialized) {
22038 throw new Error("initializeWasm() must be awaited first!");
22040 const nativeResponseValue = wasm.TS_PhantomKeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
22041 return nativeResponseValue;
22043 // MUST_USE_RES struct LDKSecretKey PhantomKeysManager_get_node_secret_key(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
22045 export function PhantomKeysManager_get_node_secret_key(this_arg: bigint): number {
22046 if(!isWasmInitialized) {
22047 throw new Error("initializeWasm() must be awaited first!");
22049 const nativeResponseValue = wasm.TS_PhantomKeysManager_get_node_secret_key(this_arg);
22050 return nativeResponseValue;
22052 // MUST_USE_RES struct LDKSecretKey PhantomKeysManager_get_phantom_node_secret_key(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
22054 export function PhantomKeysManager_get_phantom_node_secret_key(this_arg: bigint): number {
22055 if(!isWasmInitialized) {
22056 throw new Error("initializeWasm() must be awaited first!");
22058 const nativeResponseValue = wasm.TS_PhantomKeysManager_get_phantom_node_secret_key(this_arg);
22059 return nativeResponseValue;
22061 // enum LDKFailureCode FailureCode_clone(const enum LDKFailureCode *NONNULL_PTR orig);
22063 export function FailureCode_clone(orig: bigint): FailureCode {
22064 if(!isWasmInitialized) {
22065 throw new Error("initializeWasm() must be awaited first!");
22067 const nativeResponseValue = wasm.TS_FailureCode_clone(orig);
22068 return nativeResponseValue;
22070 // enum LDKFailureCode FailureCode_temporary_node_failure(void);
22072 export function FailureCode_temporary_node_failure(): FailureCode {
22073 if(!isWasmInitialized) {
22074 throw new Error("initializeWasm() must be awaited first!");
22076 const nativeResponseValue = wasm.TS_FailureCode_temporary_node_failure();
22077 return nativeResponseValue;
22079 // enum LDKFailureCode FailureCode_required_node_feature_missing(void);
22081 export function FailureCode_required_node_feature_missing(): FailureCode {
22082 if(!isWasmInitialized) {
22083 throw new Error("initializeWasm() must be awaited first!");
22085 const nativeResponseValue = wasm.TS_FailureCode_required_node_feature_missing();
22086 return nativeResponseValue;
22088 // enum LDKFailureCode FailureCode_incorrect_or_unknown_payment_details(void);
22090 export function FailureCode_incorrect_or_unknown_payment_details(): FailureCode {
22091 if(!isWasmInitialized) {
22092 throw new Error("initializeWasm() must be awaited first!");
22094 const nativeResponseValue = wasm.TS_FailureCode_incorrect_or_unknown_payment_details();
22095 return nativeResponseValue;
22097 // void ChannelManager_free(struct LDKChannelManager this_obj);
22099 export function ChannelManager_free(this_obj: bigint): void {
22100 if(!isWasmInitialized) {
22101 throw new Error("initializeWasm() must be awaited first!");
22103 const nativeResponseValue = wasm.TS_ChannelManager_free(this_obj);
22104 // debug statements here
22106 // void ChainParameters_free(struct LDKChainParameters this_obj);
22108 export function ChainParameters_free(this_obj: bigint): void {
22109 if(!isWasmInitialized) {
22110 throw new Error("initializeWasm() must be awaited first!");
22112 const nativeResponseValue = wasm.TS_ChainParameters_free(this_obj);
22113 // debug statements here
22115 // enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr);
22117 export function ChainParameters_get_network(this_ptr: bigint): Network {
22118 if(!isWasmInitialized) {
22119 throw new Error("initializeWasm() must be awaited first!");
22121 const nativeResponseValue = wasm.TS_ChainParameters_get_network(this_ptr);
22122 return nativeResponseValue;
22124 // void ChainParameters_set_network(struct LDKChainParameters *NONNULL_PTR this_ptr, enum LDKNetwork val);
22126 export function ChainParameters_set_network(this_ptr: bigint, val: Network): void {
22127 if(!isWasmInitialized) {
22128 throw new Error("initializeWasm() must be awaited first!");
22130 const nativeResponseValue = wasm.TS_ChainParameters_set_network(this_ptr, val);
22131 // debug statements here
22133 // struct LDKBestBlock ChainParameters_get_best_block(const struct LDKChainParameters *NONNULL_PTR this_ptr);
22135 export function ChainParameters_get_best_block(this_ptr: bigint): bigint {
22136 if(!isWasmInitialized) {
22137 throw new Error("initializeWasm() must be awaited first!");
22139 const nativeResponseValue = wasm.TS_ChainParameters_get_best_block(this_ptr);
22140 return nativeResponseValue;
22142 // void ChainParameters_set_best_block(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKBestBlock val);
22144 export function ChainParameters_set_best_block(this_ptr: bigint, val: bigint): void {
22145 if(!isWasmInitialized) {
22146 throw new Error("initializeWasm() must be awaited first!");
22148 const nativeResponseValue = wasm.TS_ChainParameters_set_best_block(this_ptr, val);
22149 // debug statements here
22151 // MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKBestBlock best_block_arg);
22153 export function ChainParameters_new(network_arg: Network, best_block_arg: bigint): bigint {
22154 if(!isWasmInitialized) {
22155 throw new Error("initializeWasm() must be awaited first!");
22157 const nativeResponseValue = wasm.TS_ChainParameters_new(network_arg, best_block_arg);
22158 return nativeResponseValue;
22160 // uint64_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg);
22162 export function ChainParameters_clone_ptr(arg: bigint): bigint {
22163 if(!isWasmInitialized) {
22164 throw new Error("initializeWasm() must be awaited first!");
22166 const nativeResponseValue = wasm.TS_ChainParameters_clone_ptr(arg);
22167 return nativeResponseValue;
22169 // struct LDKChainParameters ChainParameters_clone(const struct LDKChainParameters *NONNULL_PTR orig);
22171 export function ChainParameters_clone(orig: bigint): bigint {
22172 if(!isWasmInitialized) {
22173 throw new Error("initializeWasm() must be awaited first!");
22175 const nativeResponseValue = wasm.TS_ChainParameters_clone(orig);
22176 return nativeResponseValue;
22178 // void CounterpartyForwardingInfo_free(struct LDKCounterpartyForwardingInfo this_obj);
22180 export function CounterpartyForwardingInfo_free(this_obj: bigint): void {
22181 if(!isWasmInitialized) {
22182 throw new Error("initializeWasm() must be awaited first!");
22184 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_free(this_obj);
22185 // debug statements here
22187 // uint32_t CounterpartyForwardingInfo_get_fee_base_msat(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
22189 export function CounterpartyForwardingInfo_get_fee_base_msat(this_ptr: bigint): number {
22190 if(!isWasmInitialized) {
22191 throw new Error("initializeWasm() must be awaited first!");
22193 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_base_msat(this_ptr);
22194 return nativeResponseValue;
22196 // void CounterpartyForwardingInfo_set_fee_base_msat(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
22198 export function CounterpartyForwardingInfo_set_fee_base_msat(this_ptr: bigint, val: number): void {
22199 if(!isWasmInitialized) {
22200 throw new Error("initializeWasm() must be awaited first!");
22202 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_base_msat(this_ptr, val);
22203 // debug statements here
22205 // uint32_t CounterpartyForwardingInfo_get_fee_proportional_millionths(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
22207 export function CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr: bigint): number {
22208 if(!isWasmInitialized) {
22209 throw new Error("initializeWasm() must be awaited first!");
22211 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr);
22212 return nativeResponseValue;
22214 // void CounterpartyForwardingInfo_set_fee_proportional_millionths(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
22216 export function CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
22217 if(!isWasmInitialized) {
22218 throw new Error("initializeWasm() must be awaited first!");
22220 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr, val);
22221 // debug statements here
22223 // uint16_t CounterpartyForwardingInfo_get_cltv_expiry_delta(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
22225 export function CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
22226 if(!isWasmInitialized) {
22227 throw new Error("initializeWasm() must be awaited first!");
22229 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr);
22230 return nativeResponseValue;
22232 // void CounterpartyForwardingInfo_set_cltv_expiry_delta(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint16_t val);
22234 export function CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
22235 if(!isWasmInitialized) {
22236 throw new Error("initializeWasm() must be awaited first!");
22238 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr, val);
22239 // debug statements here
22241 // 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);
22243 export function CounterpartyForwardingInfo_new(fee_base_msat_arg: number, fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number): bigint {
22244 if(!isWasmInitialized) {
22245 throw new Error("initializeWasm() must be awaited first!");
22247 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
22248 return nativeResponseValue;
22250 // uint64_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg);
22252 export function CounterpartyForwardingInfo_clone_ptr(arg: bigint): bigint {
22253 if(!isWasmInitialized) {
22254 throw new Error("initializeWasm() must be awaited first!");
22256 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone_ptr(arg);
22257 return nativeResponseValue;
22259 // struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_clone(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR orig);
22261 export function CounterpartyForwardingInfo_clone(orig: bigint): bigint {
22262 if(!isWasmInitialized) {
22263 throw new Error("initializeWasm() must be awaited first!");
22265 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone(orig);
22266 return nativeResponseValue;
22268 // void ChannelCounterparty_free(struct LDKChannelCounterparty this_obj);
22270 export function ChannelCounterparty_free(this_obj: bigint): void {
22271 if(!isWasmInitialized) {
22272 throw new Error("initializeWasm() must be awaited first!");
22274 const nativeResponseValue = wasm.TS_ChannelCounterparty_free(this_obj);
22275 // debug statements here
22277 // struct LDKPublicKey ChannelCounterparty_get_node_id(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
22279 export function ChannelCounterparty_get_node_id(this_ptr: bigint): number {
22280 if(!isWasmInitialized) {
22281 throw new Error("initializeWasm() must be awaited first!");
22283 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_node_id(this_ptr);
22284 return nativeResponseValue;
22286 // void ChannelCounterparty_set_node_id(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22288 export function ChannelCounterparty_set_node_id(this_ptr: bigint, val: number): void {
22289 if(!isWasmInitialized) {
22290 throw new Error("initializeWasm() must be awaited first!");
22292 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_node_id(this_ptr, val);
22293 // debug statements here
22295 // struct LDKInitFeatures ChannelCounterparty_get_features(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
22297 export function ChannelCounterparty_get_features(this_ptr: bigint): bigint {
22298 if(!isWasmInitialized) {
22299 throw new Error("initializeWasm() must be awaited first!");
22301 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_features(this_ptr);
22302 return nativeResponseValue;
22304 // void ChannelCounterparty_set_features(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
22306 export function ChannelCounterparty_set_features(this_ptr: bigint, val: bigint): void {
22307 if(!isWasmInitialized) {
22308 throw new Error("initializeWasm() must be awaited first!");
22310 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_features(this_ptr, val);
22311 // debug statements here
22313 // uint64_t ChannelCounterparty_get_unspendable_punishment_reserve(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
22315 export function ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr: bigint): bigint {
22316 if(!isWasmInitialized) {
22317 throw new Error("initializeWasm() must be awaited first!");
22319 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr);
22320 return nativeResponseValue;
22322 // void ChannelCounterparty_set_unspendable_punishment_reserve(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, uint64_t val);
22324 export function ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr: bigint, val: bigint): void {
22325 if(!isWasmInitialized) {
22326 throw new Error("initializeWasm() must be awaited first!");
22328 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr, val);
22329 // debug statements here
22331 // struct LDKCounterpartyForwardingInfo ChannelCounterparty_get_forwarding_info(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
22333 export function ChannelCounterparty_get_forwarding_info(this_ptr: bigint): bigint {
22334 if(!isWasmInitialized) {
22335 throw new Error("initializeWasm() must be awaited first!");
22337 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_forwarding_info(this_ptr);
22338 return nativeResponseValue;
22340 // void ChannelCounterparty_set_forwarding_info(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCounterpartyForwardingInfo val);
22342 export function ChannelCounterparty_set_forwarding_info(this_ptr: bigint, val: bigint): void {
22343 if(!isWasmInitialized) {
22344 throw new Error("initializeWasm() must be awaited first!");
22346 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_forwarding_info(this_ptr, val);
22347 // debug statements here
22349 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_minimum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
22351 export function ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr: bigint): bigint {
22352 if(!isWasmInitialized) {
22353 throw new Error("initializeWasm() must be awaited first!");
22355 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr);
22356 return nativeResponseValue;
22358 // void ChannelCounterparty_set_outbound_htlc_minimum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
22360 export function ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
22361 if(!isWasmInitialized) {
22362 throw new Error("initializeWasm() must be awaited first!");
22364 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr, val);
22365 // debug statements here
22367 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_maximum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
22369 export function ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr: bigint): bigint {
22370 if(!isWasmInitialized) {
22371 throw new Error("initializeWasm() must be awaited first!");
22373 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr);
22374 return nativeResponseValue;
22376 // void ChannelCounterparty_set_outbound_htlc_maximum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
22378 export function ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
22379 if(!isWasmInitialized) {
22380 throw new Error("initializeWasm() must be awaited first!");
22382 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr, val);
22383 // debug statements here
22385 // 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);
22387 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 {
22388 if(!isWasmInitialized) {
22389 throw new Error("initializeWasm() must be awaited first!");
22391 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);
22392 return nativeResponseValue;
22394 // uint64_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg);
22396 export function ChannelCounterparty_clone_ptr(arg: bigint): bigint {
22397 if(!isWasmInitialized) {
22398 throw new Error("initializeWasm() must be awaited first!");
22400 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone_ptr(arg);
22401 return nativeResponseValue;
22403 // struct LDKChannelCounterparty ChannelCounterparty_clone(const struct LDKChannelCounterparty *NONNULL_PTR orig);
22405 export function ChannelCounterparty_clone(orig: bigint): bigint {
22406 if(!isWasmInitialized) {
22407 throw new Error("initializeWasm() must be awaited first!");
22409 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone(orig);
22410 return nativeResponseValue;
22412 // void ChannelDetails_free(struct LDKChannelDetails this_obj);
22414 export function ChannelDetails_free(this_obj: bigint): void {
22415 if(!isWasmInitialized) {
22416 throw new Error("initializeWasm() must be awaited first!");
22418 const nativeResponseValue = wasm.TS_ChannelDetails_free(this_obj);
22419 // debug statements here
22421 // const uint8_t (*ChannelDetails_get_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr))[32];
22423 export function ChannelDetails_get_channel_id(this_ptr: bigint): number {
22424 if(!isWasmInitialized) {
22425 throw new Error("initializeWasm() must be awaited first!");
22427 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_id(this_ptr);
22428 return nativeResponseValue;
22430 // void ChannelDetails_set_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22432 export function ChannelDetails_set_channel_id(this_ptr: bigint, val: number): void {
22433 if(!isWasmInitialized) {
22434 throw new Error("initializeWasm() must be awaited first!");
22436 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_id(this_ptr, val);
22437 // debug statements here
22439 // struct LDKChannelCounterparty ChannelDetails_get_counterparty(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
22441 export function ChannelDetails_get_counterparty(this_ptr: bigint): bigint {
22442 if(!isWasmInitialized) {
22443 throw new Error("initializeWasm() must be awaited first!");
22445 const nativeResponseValue = wasm.TS_ChannelDetails_get_counterparty(this_ptr);
22446 return nativeResponseValue;
22448 // void ChannelDetails_set_counterparty(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelCounterparty val);
22450 export function ChannelDetails_set_counterparty(this_ptr: bigint, val: bigint): void {
22451 if(!isWasmInitialized) {
22452 throw new Error("initializeWasm() must be awaited first!");
22454 const nativeResponseValue = wasm.TS_ChannelDetails_set_counterparty(this_ptr, val);
22455 // debug statements here
22457 // struct LDKOutPoint ChannelDetails_get_funding_txo(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
22459 export function ChannelDetails_get_funding_txo(this_ptr: bigint): bigint {
22460 if(!isWasmInitialized) {
22461 throw new Error("initializeWasm() must be awaited first!");
22463 const nativeResponseValue = wasm.TS_ChannelDetails_get_funding_txo(this_ptr);
22464 return nativeResponseValue;
22466 // void ChannelDetails_set_funding_txo(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKOutPoint val);
22468 export function ChannelDetails_set_funding_txo(this_ptr: bigint, val: bigint): void {
22469 if(!isWasmInitialized) {
22470 throw new Error("initializeWasm() must be awaited first!");
22472 const nativeResponseValue = wasm.TS_ChannelDetails_set_funding_txo(this_ptr, val);
22473 // debug statements here
22475 // struct LDKChannelTypeFeatures ChannelDetails_get_channel_type(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
22477 export function ChannelDetails_get_channel_type(this_ptr: bigint): bigint {
22478 if(!isWasmInitialized) {
22479 throw new Error("initializeWasm() must be awaited first!");
22481 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_type(this_ptr);
22482 return nativeResponseValue;
22484 // void ChannelDetails_set_channel_type(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
22486 export function ChannelDetails_set_channel_type(this_ptr: bigint, val: bigint): void {
22487 if(!isWasmInitialized) {
22488 throw new Error("initializeWasm() must be awaited first!");
22490 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_type(this_ptr, val);
22491 // debug statements here
22493 // struct LDKCOption_u64Z ChannelDetails_get_short_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
22495 export function ChannelDetails_get_short_channel_id(this_ptr: bigint): bigint {
22496 if(!isWasmInitialized) {
22497 throw new Error("initializeWasm() must be awaited first!");
22499 const nativeResponseValue = wasm.TS_ChannelDetails_get_short_channel_id(this_ptr);
22500 return nativeResponseValue;
22502 // void ChannelDetails_set_short_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
22504 export function ChannelDetails_set_short_channel_id(this_ptr: bigint, val: bigint): void {
22505 if(!isWasmInitialized) {
22506 throw new Error("initializeWasm() must be awaited first!");
22508 const nativeResponseValue = wasm.TS_ChannelDetails_set_short_channel_id(this_ptr, val);
22509 // debug statements here
22511 // struct LDKCOption_u64Z ChannelDetails_get_outbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
22513 export function ChannelDetails_get_outbound_scid_alias(this_ptr: bigint): bigint {
22514 if(!isWasmInitialized) {
22515 throw new Error("initializeWasm() must be awaited first!");
22517 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_scid_alias(this_ptr);
22518 return nativeResponseValue;
22520 // void ChannelDetails_set_outbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
22522 export function ChannelDetails_set_outbound_scid_alias(this_ptr: bigint, val: bigint): void {
22523 if(!isWasmInitialized) {
22524 throw new Error("initializeWasm() must be awaited first!");
22526 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_scid_alias(this_ptr, val);
22527 // debug statements here
22529 // struct LDKCOption_u64Z ChannelDetails_get_inbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
22531 export function ChannelDetails_get_inbound_scid_alias(this_ptr: bigint): bigint {
22532 if(!isWasmInitialized) {
22533 throw new Error("initializeWasm() must be awaited first!");
22535 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_scid_alias(this_ptr);
22536 return nativeResponseValue;
22538 // void ChannelDetails_set_inbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
22540 export function ChannelDetails_set_inbound_scid_alias(this_ptr: bigint, val: bigint): void {
22541 if(!isWasmInitialized) {
22542 throw new Error("initializeWasm() must be awaited first!");
22544 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_scid_alias(this_ptr, val);
22545 // debug statements here
22547 // uint64_t ChannelDetails_get_channel_value_satoshis(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
22549 export function ChannelDetails_get_channel_value_satoshis(this_ptr: bigint): bigint {
22550 if(!isWasmInitialized) {
22551 throw new Error("initializeWasm() must be awaited first!");
22553 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_value_satoshis(this_ptr);
22554 return nativeResponseValue;
22556 // void ChannelDetails_set_channel_value_satoshis(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
22558 export function ChannelDetails_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
22559 if(!isWasmInitialized) {
22560 throw new Error("initializeWasm() must be awaited first!");
22562 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_value_satoshis(this_ptr, val);
22563 // debug statements here
22565 // struct LDKCOption_u64Z ChannelDetails_get_unspendable_punishment_reserve(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
22567 export function ChannelDetails_get_unspendable_punishment_reserve(this_ptr: bigint): bigint {
22568 if(!isWasmInitialized) {
22569 throw new Error("initializeWasm() must be awaited first!");
22571 const nativeResponseValue = wasm.TS_ChannelDetails_get_unspendable_punishment_reserve(this_ptr);
22572 return nativeResponseValue;
22574 // void ChannelDetails_set_unspendable_punishment_reserve(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
22576 export function ChannelDetails_set_unspendable_punishment_reserve(this_ptr: bigint, val: bigint): void {
22577 if(!isWasmInitialized) {
22578 throw new Error("initializeWasm() must be awaited first!");
22580 const nativeResponseValue = wasm.TS_ChannelDetails_set_unspendable_punishment_reserve(this_ptr, val);
22581 // debug statements here
22583 // struct LDKU128 ChannelDetails_get_user_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
22585 export function ChannelDetails_get_user_channel_id(this_ptr: bigint): number {
22586 if(!isWasmInitialized) {
22587 throw new Error("initializeWasm() must be awaited first!");
22589 const nativeResponseValue = wasm.TS_ChannelDetails_get_user_channel_id(this_ptr);
22590 return nativeResponseValue;
22592 // void ChannelDetails_set_user_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKU128 val);
22594 export function ChannelDetails_set_user_channel_id(this_ptr: bigint, val: number): void {
22595 if(!isWasmInitialized) {
22596 throw new Error("initializeWasm() must be awaited first!");
22598 const nativeResponseValue = wasm.TS_ChannelDetails_set_user_channel_id(this_ptr, val);
22599 // debug statements here
22601 // uint64_t ChannelDetails_get_balance_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
22603 export function ChannelDetails_get_balance_msat(this_ptr: bigint): bigint {
22604 if(!isWasmInitialized) {
22605 throw new Error("initializeWasm() must be awaited first!");
22607 const nativeResponseValue = wasm.TS_ChannelDetails_get_balance_msat(this_ptr);
22608 return nativeResponseValue;
22610 // void ChannelDetails_set_balance_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
22612 export function ChannelDetails_set_balance_msat(this_ptr: bigint, val: bigint): void {
22613 if(!isWasmInitialized) {
22614 throw new Error("initializeWasm() must be awaited first!");
22616 const nativeResponseValue = wasm.TS_ChannelDetails_set_balance_msat(this_ptr, val);
22617 // debug statements here
22619 // uint64_t ChannelDetails_get_outbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
22621 export function ChannelDetails_get_outbound_capacity_msat(this_ptr: bigint): bigint {
22622 if(!isWasmInitialized) {
22623 throw new Error("initializeWasm() must be awaited first!");
22625 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_capacity_msat(this_ptr);
22626 return nativeResponseValue;
22628 // void ChannelDetails_set_outbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
22630 export function ChannelDetails_set_outbound_capacity_msat(this_ptr: bigint, val: bigint): void {
22631 if(!isWasmInitialized) {
22632 throw new Error("initializeWasm() must be awaited first!");
22634 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_capacity_msat(this_ptr, val);
22635 // debug statements here
22637 // uint64_t ChannelDetails_get_next_outbound_htlc_limit_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
22639 export function ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr: bigint): bigint {
22640 if(!isWasmInitialized) {
22641 throw new Error("initializeWasm() must be awaited first!");
22643 const nativeResponseValue = wasm.TS_ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr);
22644 return nativeResponseValue;
22646 // void ChannelDetails_set_next_outbound_htlc_limit_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
22648 export function ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr: bigint, val: bigint): void {
22649 if(!isWasmInitialized) {
22650 throw new Error("initializeWasm() must be awaited first!");
22652 const nativeResponseValue = wasm.TS_ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr, val);
22653 // debug statements here
22655 // uint64_t ChannelDetails_get_inbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
22657 export function ChannelDetails_get_inbound_capacity_msat(this_ptr: bigint): bigint {
22658 if(!isWasmInitialized) {
22659 throw new Error("initializeWasm() must be awaited first!");
22661 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_capacity_msat(this_ptr);
22662 return nativeResponseValue;
22664 // void ChannelDetails_set_inbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
22666 export function ChannelDetails_set_inbound_capacity_msat(this_ptr: bigint, val: bigint): void {
22667 if(!isWasmInitialized) {
22668 throw new Error("initializeWasm() must be awaited first!");
22670 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_capacity_msat(this_ptr, val);
22671 // debug statements here
22673 // struct LDKCOption_u32Z ChannelDetails_get_confirmations_required(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
22675 export function ChannelDetails_get_confirmations_required(this_ptr: bigint): bigint {
22676 if(!isWasmInitialized) {
22677 throw new Error("initializeWasm() must be awaited first!");
22679 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations_required(this_ptr);
22680 return nativeResponseValue;
22682 // void ChannelDetails_set_confirmations_required(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
22684 export function ChannelDetails_set_confirmations_required(this_ptr: bigint, val: bigint): void {
22685 if(!isWasmInitialized) {
22686 throw new Error("initializeWasm() must be awaited first!");
22688 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations_required(this_ptr, val);
22689 // debug statements here
22691 // struct LDKCOption_u32Z ChannelDetails_get_confirmations(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
22693 export function ChannelDetails_get_confirmations(this_ptr: bigint): bigint {
22694 if(!isWasmInitialized) {
22695 throw new Error("initializeWasm() must be awaited first!");
22697 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations(this_ptr);
22698 return nativeResponseValue;
22700 // void ChannelDetails_set_confirmations(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
22702 export function ChannelDetails_set_confirmations(this_ptr: bigint, val: bigint): void {
22703 if(!isWasmInitialized) {
22704 throw new Error("initializeWasm() must be awaited first!");
22706 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations(this_ptr, val);
22707 // debug statements here
22709 // struct LDKCOption_u16Z ChannelDetails_get_force_close_spend_delay(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
22711 export function ChannelDetails_get_force_close_spend_delay(this_ptr: bigint): bigint {
22712 if(!isWasmInitialized) {
22713 throw new Error("initializeWasm() must be awaited first!");
22715 const nativeResponseValue = wasm.TS_ChannelDetails_get_force_close_spend_delay(this_ptr);
22716 return nativeResponseValue;
22718 // void ChannelDetails_set_force_close_spend_delay(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
22720 export function ChannelDetails_set_force_close_spend_delay(this_ptr: bigint, val: bigint): void {
22721 if(!isWasmInitialized) {
22722 throw new Error("initializeWasm() must be awaited first!");
22724 const nativeResponseValue = wasm.TS_ChannelDetails_set_force_close_spend_delay(this_ptr, val);
22725 // debug statements here
22727 // bool ChannelDetails_get_is_outbound(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
22729 export function ChannelDetails_get_is_outbound(this_ptr: bigint): boolean {
22730 if(!isWasmInitialized) {
22731 throw new Error("initializeWasm() must be awaited first!");
22733 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_outbound(this_ptr);
22734 return nativeResponseValue;
22736 // void ChannelDetails_set_is_outbound(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
22738 export function ChannelDetails_set_is_outbound(this_ptr: bigint, val: boolean): void {
22739 if(!isWasmInitialized) {
22740 throw new Error("initializeWasm() must be awaited first!");
22742 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_outbound(this_ptr, val);
22743 // debug statements here
22745 // bool ChannelDetails_get_is_channel_ready(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
22747 export function ChannelDetails_get_is_channel_ready(this_ptr: bigint): boolean {
22748 if(!isWasmInitialized) {
22749 throw new Error("initializeWasm() must be awaited first!");
22751 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_channel_ready(this_ptr);
22752 return nativeResponseValue;
22754 // void ChannelDetails_set_is_channel_ready(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
22756 export function ChannelDetails_set_is_channel_ready(this_ptr: bigint, val: boolean): void {
22757 if(!isWasmInitialized) {
22758 throw new Error("initializeWasm() must be awaited first!");
22760 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_channel_ready(this_ptr, val);
22761 // debug statements here
22763 // bool ChannelDetails_get_is_usable(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
22765 export function ChannelDetails_get_is_usable(this_ptr: bigint): boolean {
22766 if(!isWasmInitialized) {
22767 throw new Error("initializeWasm() must be awaited first!");
22769 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_usable(this_ptr);
22770 return nativeResponseValue;
22772 // void ChannelDetails_set_is_usable(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
22774 export function ChannelDetails_set_is_usable(this_ptr: bigint, val: boolean): void {
22775 if(!isWasmInitialized) {
22776 throw new Error("initializeWasm() must be awaited first!");
22778 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_usable(this_ptr, val);
22779 // debug statements here
22781 // bool ChannelDetails_get_is_public(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
22783 export function ChannelDetails_get_is_public(this_ptr: bigint): boolean {
22784 if(!isWasmInitialized) {
22785 throw new Error("initializeWasm() must be awaited first!");
22787 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_public(this_ptr);
22788 return nativeResponseValue;
22790 // void ChannelDetails_set_is_public(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
22792 export function ChannelDetails_set_is_public(this_ptr: bigint, val: boolean): void {
22793 if(!isWasmInitialized) {
22794 throw new Error("initializeWasm() must be awaited first!");
22796 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_public(this_ptr, val);
22797 // debug statements here
22799 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_minimum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
22801 export function ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr: bigint): bigint {
22802 if(!isWasmInitialized) {
22803 throw new Error("initializeWasm() must be awaited first!");
22805 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr);
22806 return nativeResponseValue;
22808 // void ChannelDetails_set_inbound_htlc_minimum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
22810 export function ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
22811 if(!isWasmInitialized) {
22812 throw new Error("initializeWasm() must be awaited first!");
22814 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr, val);
22815 // debug statements here
22817 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_maximum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
22819 export function ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr: bigint): bigint {
22820 if(!isWasmInitialized) {
22821 throw new Error("initializeWasm() must be awaited first!");
22823 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr);
22824 return nativeResponseValue;
22826 // void ChannelDetails_set_inbound_htlc_maximum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
22828 export function ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
22829 if(!isWasmInitialized) {
22830 throw new Error("initializeWasm() must be awaited first!");
22832 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr, val);
22833 // debug statements here
22835 // struct LDKChannelConfig ChannelDetails_get_config(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
22837 export function ChannelDetails_get_config(this_ptr: bigint): bigint {
22838 if(!isWasmInitialized) {
22839 throw new Error("initializeWasm() must be awaited first!");
22841 const nativeResponseValue = wasm.TS_ChannelDetails_get_config(this_ptr);
22842 return nativeResponseValue;
22844 // void ChannelDetails_set_config(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
22846 export function ChannelDetails_set_config(this_ptr: bigint, val: bigint): void {
22847 if(!isWasmInitialized) {
22848 throw new Error("initializeWasm() must be awaited first!");
22850 const nativeResponseValue = wasm.TS_ChannelDetails_set_config(this_ptr, val);
22851 // debug statements here
22853 // 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, struct LDKU128 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_u32Z confirmations_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);
22855 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: number, 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, confirmations_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 {
22856 if(!isWasmInitialized) {
22857 throw new Error("initializeWasm() must be awaited first!");
22859 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, confirmations_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);
22860 return nativeResponseValue;
22862 // uint64_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg);
22864 export function ChannelDetails_clone_ptr(arg: bigint): bigint {
22865 if(!isWasmInitialized) {
22866 throw new Error("initializeWasm() must be awaited first!");
22868 const nativeResponseValue = wasm.TS_ChannelDetails_clone_ptr(arg);
22869 return nativeResponseValue;
22871 // struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
22873 export function ChannelDetails_clone(orig: bigint): bigint {
22874 if(!isWasmInitialized) {
22875 throw new Error("initializeWasm() must be awaited first!");
22877 const nativeResponseValue = wasm.TS_ChannelDetails_clone(orig);
22878 return nativeResponseValue;
22880 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_inbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
22882 export function ChannelDetails_get_inbound_payment_scid(this_arg: bigint): bigint {
22883 if(!isWasmInitialized) {
22884 throw new Error("initializeWasm() must be awaited first!");
22886 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_payment_scid(this_arg);
22887 return nativeResponseValue;
22889 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_outbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
22891 export function ChannelDetails_get_outbound_payment_scid(this_arg: bigint): bigint {
22892 if(!isWasmInitialized) {
22893 throw new Error("initializeWasm() must be awaited first!");
22895 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_payment_scid(this_arg);
22896 return nativeResponseValue;
22898 // void RecentPaymentDetails_free(struct LDKRecentPaymentDetails this_ptr);
22900 export function RecentPaymentDetails_free(this_ptr: bigint): void {
22901 if(!isWasmInitialized) {
22902 throw new Error("initializeWasm() must be awaited first!");
22904 const nativeResponseValue = wasm.TS_RecentPaymentDetails_free(this_ptr);
22905 // debug statements here
22907 // uint64_t RecentPaymentDetails_clone_ptr(LDKRecentPaymentDetails *NONNULL_PTR arg);
22909 export function RecentPaymentDetails_clone_ptr(arg: bigint): bigint {
22910 if(!isWasmInitialized) {
22911 throw new Error("initializeWasm() must be awaited first!");
22913 const nativeResponseValue = wasm.TS_RecentPaymentDetails_clone_ptr(arg);
22914 return nativeResponseValue;
22916 // struct LDKRecentPaymentDetails RecentPaymentDetails_clone(const struct LDKRecentPaymentDetails *NONNULL_PTR orig);
22918 export function RecentPaymentDetails_clone(orig: bigint): bigint {
22919 if(!isWasmInitialized) {
22920 throw new Error("initializeWasm() must be awaited first!");
22922 const nativeResponseValue = wasm.TS_RecentPaymentDetails_clone(orig);
22923 return nativeResponseValue;
22925 // struct LDKRecentPaymentDetails RecentPaymentDetails_pending(struct LDKThirtyTwoBytes payment_hash, uint64_t total_msat);
22927 export function RecentPaymentDetails_pending(payment_hash: number, total_msat: bigint): bigint {
22928 if(!isWasmInitialized) {
22929 throw new Error("initializeWasm() must be awaited first!");
22931 const nativeResponseValue = wasm.TS_RecentPaymentDetails_pending(payment_hash, total_msat);
22932 return nativeResponseValue;
22934 // struct LDKRecentPaymentDetails RecentPaymentDetails_fulfilled(struct LDKThirtyTwoBytes payment_hash);
22936 export function RecentPaymentDetails_fulfilled(payment_hash: number): bigint {
22937 if(!isWasmInitialized) {
22938 throw new Error("initializeWasm() must be awaited first!");
22940 const nativeResponseValue = wasm.TS_RecentPaymentDetails_fulfilled(payment_hash);
22941 return nativeResponseValue;
22943 // struct LDKRecentPaymentDetails RecentPaymentDetails_abandoned(struct LDKThirtyTwoBytes payment_hash);
22945 export function RecentPaymentDetails_abandoned(payment_hash: number): bigint {
22946 if(!isWasmInitialized) {
22947 throw new Error("initializeWasm() must be awaited first!");
22949 const nativeResponseValue = wasm.TS_RecentPaymentDetails_abandoned(payment_hash);
22950 return nativeResponseValue;
22952 // void PhantomRouteHints_free(struct LDKPhantomRouteHints this_obj);
22954 export function PhantomRouteHints_free(this_obj: bigint): void {
22955 if(!isWasmInitialized) {
22956 throw new Error("initializeWasm() must be awaited first!");
22958 const nativeResponseValue = wasm.TS_PhantomRouteHints_free(this_obj);
22959 // debug statements here
22961 // struct LDKCVec_ChannelDetailsZ PhantomRouteHints_get_channels(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
22963 export function PhantomRouteHints_get_channels(this_ptr: bigint): number {
22964 if(!isWasmInitialized) {
22965 throw new Error("initializeWasm() must be awaited first!");
22967 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_channels(this_ptr);
22968 return nativeResponseValue;
22970 // void PhantomRouteHints_set_channels(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKCVec_ChannelDetailsZ val);
22972 export function PhantomRouteHints_set_channels(this_ptr: bigint, val: number): void {
22973 if(!isWasmInitialized) {
22974 throw new Error("initializeWasm() must be awaited first!");
22976 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_channels(this_ptr, val);
22977 // debug statements here
22979 // uint64_t PhantomRouteHints_get_phantom_scid(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
22981 export function PhantomRouteHints_get_phantom_scid(this_ptr: bigint): bigint {
22982 if(!isWasmInitialized) {
22983 throw new Error("initializeWasm() must be awaited first!");
22985 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_phantom_scid(this_ptr);
22986 return nativeResponseValue;
22988 // void PhantomRouteHints_set_phantom_scid(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, uint64_t val);
22990 export function PhantomRouteHints_set_phantom_scid(this_ptr: bigint, val: bigint): void {
22991 if(!isWasmInitialized) {
22992 throw new Error("initializeWasm() must be awaited first!");
22994 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_phantom_scid(this_ptr, val);
22995 // debug statements here
22997 // struct LDKPublicKey PhantomRouteHints_get_real_node_pubkey(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
22999 export function PhantomRouteHints_get_real_node_pubkey(this_ptr: bigint): number {
23000 if(!isWasmInitialized) {
23001 throw new Error("initializeWasm() must be awaited first!");
23003 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_real_node_pubkey(this_ptr);
23004 return nativeResponseValue;
23006 // void PhantomRouteHints_set_real_node_pubkey(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23008 export function PhantomRouteHints_set_real_node_pubkey(this_ptr: bigint, val: number): void {
23009 if(!isWasmInitialized) {
23010 throw new Error("initializeWasm() must be awaited first!");
23012 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_real_node_pubkey(this_ptr, val);
23013 // debug statements here
23015 // MUST_USE_RES struct LDKPhantomRouteHints PhantomRouteHints_new(struct LDKCVec_ChannelDetailsZ channels_arg, uint64_t phantom_scid_arg, struct LDKPublicKey real_node_pubkey_arg);
23017 export function PhantomRouteHints_new(channels_arg: number, phantom_scid_arg: bigint, real_node_pubkey_arg: number): bigint {
23018 if(!isWasmInitialized) {
23019 throw new Error("initializeWasm() must be awaited first!");
23021 const nativeResponseValue = wasm.TS_PhantomRouteHints_new(channels_arg, phantom_scid_arg, real_node_pubkey_arg);
23022 return nativeResponseValue;
23024 // uint64_t PhantomRouteHints_clone_ptr(LDKPhantomRouteHints *NONNULL_PTR arg);
23026 export function PhantomRouteHints_clone_ptr(arg: bigint): bigint {
23027 if(!isWasmInitialized) {
23028 throw new Error("initializeWasm() must be awaited first!");
23030 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone_ptr(arg);
23031 return nativeResponseValue;
23033 // struct LDKPhantomRouteHints PhantomRouteHints_clone(const struct LDKPhantomRouteHints *NONNULL_PTR orig);
23035 export function PhantomRouteHints_clone(orig: bigint): bigint {
23036 if(!isWasmInitialized) {
23037 throw new Error("initializeWasm() must be awaited first!");
23039 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone(orig);
23040 return nativeResponseValue;
23042 // MUST_USE_RES struct LDKChannelManager ChannelManager_new(struct LDKFeeEstimator fee_est, struct LDKWatch chain_monitor, struct LDKBroadcasterInterface tx_broadcaster, struct LDKRouter router, struct LDKLogger logger, struct LDKEntropySource entropy_source, struct LDKNodeSigner node_signer, struct LDKSignerProvider signer_provider, struct LDKUserConfig config, struct LDKChainParameters params);
23044 export function ChannelManager_new(fee_est: bigint, chain_monitor: bigint, tx_broadcaster: bigint, router: bigint, logger: bigint, entropy_source: bigint, node_signer: bigint, signer_provider: bigint, config: bigint, params: bigint): bigint {
23045 if(!isWasmInitialized) {
23046 throw new Error("initializeWasm() must be awaited first!");
23048 const nativeResponseValue = wasm.TS_ChannelManager_new(fee_est, chain_monitor, tx_broadcaster, router, logger, entropy_source, node_signer, signer_provider, config, params);
23049 return nativeResponseValue;
23051 // MUST_USE_RES struct LDKUserConfig ChannelManager_get_current_default_configuration(const struct LDKChannelManager *NONNULL_PTR this_arg);
23053 export function ChannelManager_get_current_default_configuration(this_arg: bigint): bigint {
23054 if(!isWasmInitialized) {
23055 throw new Error("initializeWasm() must be awaited first!");
23057 const nativeResponseValue = wasm.TS_ChannelManager_get_current_default_configuration(this_arg);
23058 return nativeResponseValue;
23060 // 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, struct LDKU128 user_channel_id, struct LDKUserConfig override_config);
23062 export function ChannelManager_create_channel(this_arg: bigint, their_network_key: number, channel_value_satoshis: bigint, push_msat: bigint, user_channel_id: number, override_config: bigint): bigint {
23063 if(!isWasmInitialized) {
23064 throw new Error("initializeWasm() must be awaited first!");
23066 const nativeResponseValue = wasm.TS_ChannelManager_create_channel(this_arg, their_network_key, channel_value_satoshis, push_msat, user_channel_id, override_config);
23067 return nativeResponseValue;
23069 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
23071 export function ChannelManager_list_channels(this_arg: bigint): number {
23072 if(!isWasmInitialized) {
23073 throw new Error("initializeWasm() must be awaited first!");
23075 const nativeResponseValue = wasm.TS_ChannelManager_list_channels(this_arg);
23076 return nativeResponseValue;
23078 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_usable_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
23080 export function ChannelManager_list_usable_channels(this_arg: bigint): number {
23081 if(!isWasmInitialized) {
23082 throw new Error("initializeWasm() must be awaited first!");
23084 const nativeResponseValue = wasm.TS_ChannelManager_list_usable_channels(this_arg);
23085 return nativeResponseValue;
23087 // MUST_USE_RES struct LDKCVec_RecentPaymentDetailsZ ChannelManager_list_recent_payments(const struct LDKChannelManager *NONNULL_PTR this_arg);
23089 export function ChannelManager_list_recent_payments(this_arg: bigint): number {
23090 if(!isWasmInitialized) {
23091 throw new Error("initializeWasm() must be awaited first!");
23093 const nativeResponseValue = wasm.TS_ChannelManager_list_recent_payments(this_arg);
23094 return nativeResponseValue;
23096 // 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);
23098 export function ChannelManager_close_channel(this_arg: bigint, channel_id: number, counterparty_node_id: number): bigint {
23099 if(!isWasmInitialized) {
23100 throw new Error("initializeWasm() must be awaited first!");
23102 const nativeResponseValue = wasm.TS_ChannelManager_close_channel(this_arg, channel_id, counterparty_node_id);
23103 return nativeResponseValue;
23105 // 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);
23107 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 {
23108 if(!isWasmInitialized) {
23109 throw new Error("initializeWasm() must be awaited first!");
23111 const nativeResponseValue = wasm.TS_ChannelManager_close_channel_with_target_feerate(this_arg, channel_id, counterparty_node_id, target_feerate_sats_per_1000_weight);
23112 return nativeResponseValue;
23114 // 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);
23116 export function ChannelManager_force_close_broadcasting_latest_txn(this_arg: bigint, channel_id: number, counterparty_node_id: number): bigint {
23117 if(!isWasmInitialized) {
23118 throw new Error("initializeWasm() must be awaited first!");
23120 const nativeResponseValue = wasm.TS_ChannelManager_force_close_broadcasting_latest_txn(this_arg, channel_id, counterparty_node_id);
23121 return nativeResponseValue;
23123 // 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);
23125 export function ChannelManager_force_close_without_broadcasting_txn(this_arg: bigint, channel_id: number, counterparty_node_id: number): bigint {
23126 if(!isWasmInitialized) {
23127 throw new Error("initializeWasm() must be awaited first!");
23129 const nativeResponseValue = wasm.TS_ChannelManager_force_close_without_broadcasting_txn(this_arg, channel_id, counterparty_node_id);
23130 return nativeResponseValue;
23132 // void ChannelManager_force_close_all_channels_broadcasting_latest_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
23134 export function ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg: bigint): void {
23135 if(!isWasmInitialized) {
23136 throw new Error("initializeWasm() must be awaited first!");
23138 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg);
23139 // debug statements here
23141 // void ChannelManager_force_close_all_channels_without_broadcasting_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
23143 export function ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg: bigint): void {
23144 if(!isWasmInitialized) {
23145 throw new Error("initializeWasm() must be awaited first!");
23147 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg);
23148 // debug statements here
23150 // MUST_USE_RES struct LDKCResult_NonePaymentSendFailureZ ChannelManager_send_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret, struct LDKThirtyTwoBytes payment_id);
23152 export function ChannelManager_send_payment(this_arg: bigint, route: bigint, payment_hash: number, payment_secret: number, payment_id: number): bigint {
23153 if(!isWasmInitialized) {
23154 throw new Error("initializeWasm() must be awaited first!");
23156 const nativeResponseValue = wasm.TS_ChannelManager_send_payment(this_arg, route, payment_hash, payment_secret, payment_id);
23157 return nativeResponseValue;
23159 // MUST_USE_RES struct LDKCResult_NoneRetryableSendFailureZ ChannelManager_send_payment_with_retry(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret, struct LDKThirtyTwoBytes payment_id, struct LDKRouteParameters route_params, struct LDKRetry retry_strategy);
23161 export function ChannelManager_send_payment_with_retry(this_arg: bigint, payment_hash: number, payment_secret: number, payment_id: number, route_params: bigint, retry_strategy: bigint): bigint {
23162 if(!isWasmInitialized) {
23163 throw new Error("initializeWasm() must be awaited first!");
23165 const nativeResponseValue = wasm.TS_ChannelManager_send_payment_with_retry(this_arg, payment_hash, payment_secret, payment_id, route_params, retry_strategy);
23166 return nativeResponseValue;
23168 // void ChannelManager_abandon_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id);
23170 export function ChannelManager_abandon_payment(this_arg: bigint, payment_id: number): void {
23171 if(!isWasmInitialized) {
23172 throw new Error("initializeWasm() must be awaited first!");
23174 const nativeResponseValue = wasm.TS_ChannelManager_abandon_payment(this_arg, payment_id);
23175 // debug statements here
23177 // MUST_USE_RES struct LDKCResult_PaymentHashPaymentSendFailureZ ChannelManager_send_spontaneous_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_id);
23179 export function ChannelManager_send_spontaneous_payment(this_arg: bigint, route: bigint, payment_preimage: number, payment_id: number): bigint {
23180 if(!isWasmInitialized) {
23181 throw new Error("initializeWasm() must be awaited first!");
23183 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment(this_arg, route, payment_preimage, payment_id);
23184 return nativeResponseValue;
23186 // MUST_USE_RES struct LDKCResult_PaymentHashRetryableSendFailureZ ChannelManager_send_spontaneous_payment_with_retry(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_id, struct LDKRouteParameters route_params, struct LDKRetry retry_strategy);
23188 export function ChannelManager_send_spontaneous_payment_with_retry(this_arg: bigint, payment_preimage: number, payment_id: number, route_params: bigint, retry_strategy: bigint): bigint {
23189 if(!isWasmInitialized) {
23190 throw new Error("initializeWasm() must be awaited first!");
23192 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment_with_retry(this_arg, payment_preimage, payment_id, route_params, retry_strategy);
23193 return nativeResponseValue;
23195 // MUST_USE_RES struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ ChannelManager_send_probe(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ hops);
23197 export function ChannelManager_send_probe(this_arg: bigint, hops: number): bigint {
23198 if(!isWasmInitialized) {
23199 throw new Error("initializeWasm() must be awaited first!");
23201 const nativeResponseValue = wasm.TS_ChannelManager_send_probe(this_arg, hops);
23202 return nativeResponseValue;
23204 // 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);
23206 export function ChannelManager_funding_transaction_generated(this_arg: bigint, temporary_channel_id: number, counterparty_node_id: number, funding_transaction: number): bigint {
23207 if(!isWasmInitialized) {
23208 throw new Error("initializeWasm() must be awaited first!");
23210 const nativeResponseValue = wasm.TS_ChannelManager_funding_transaction_generated(this_arg, temporary_channel_id, counterparty_node_id, funding_transaction);
23211 return nativeResponseValue;
23213 // 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);
23215 export function ChannelManager_update_channel_config(this_arg: bigint, counterparty_node_id: number, channel_ids: number, config: bigint): bigint {
23216 if(!isWasmInitialized) {
23217 throw new Error("initializeWasm() must be awaited first!");
23219 const nativeResponseValue = wasm.TS_ChannelManager_update_channel_config(this_arg, counterparty_node_id, channel_ids, config);
23220 return nativeResponseValue;
23222 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_forward_intercepted_htlc(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes intercept_id, const uint8_t (*next_hop_channel_id)[32], struct LDKPublicKey next_node_id, uint64_t amt_to_forward_msat);
23224 export function ChannelManager_forward_intercepted_htlc(this_arg: bigint, intercept_id: number, next_hop_channel_id: number, next_node_id: number, amt_to_forward_msat: bigint): bigint {
23225 if(!isWasmInitialized) {
23226 throw new Error("initializeWasm() must be awaited first!");
23228 const nativeResponseValue = wasm.TS_ChannelManager_forward_intercepted_htlc(this_arg, intercept_id, next_hop_channel_id, next_node_id, amt_to_forward_msat);
23229 return nativeResponseValue;
23231 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_fail_intercepted_htlc(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes intercept_id);
23233 export function ChannelManager_fail_intercepted_htlc(this_arg: bigint, intercept_id: number): bigint {
23234 if(!isWasmInitialized) {
23235 throw new Error("initializeWasm() must be awaited first!");
23237 const nativeResponseValue = wasm.TS_ChannelManager_fail_intercepted_htlc(this_arg, intercept_id);
23238 return nativeResponseValue;
23240 // void ChannelManager_process_pending_htlc_forwards(const struct LDKChannelManager *NONNULL_PTR this_arg);
23242 export function ChannelManager_process_pending_htlc_forwards(this_arg: bigint): void {
23243 if(!isWasmInitialized) {
23244 throw new Error("initializeWasm() must be awaited first!");
23246 const nativeResponseValue = wasm.TS_ChannelManager_process_pending_htlc_forwards(this_arg);
23247 // debug statements here
23249 // void ChannelManager_timer_tick_occurred(const struct LDKChannelManager *NONNULL_PTR this_arg);
23251 export function ChannelManager_timer_tick_occurred(this_arg: bigint): void {
23252 if(!isWasmInitialized) {
23253 throw new Error("initializeWasm() must be awaited first!");
23255 const nativeResponseValue = wasm.TS_ChannelManager_timer_tick_occurred(this_arg);
23256 // debug statements here
23258 // void ChannelManager_fail_htlc_backwards(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
23260 export function ChannelManager_fail_htlc_backwards(this_arg: bigint, payment_hash: number): void {
23261 if(!isWasmInitialized) {
23262 throw new Error("initializeWasm() must be awaited first!");
23264 const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards(this_arg, payment_hash);
23265 // debug statements here
23267 // void ChannelManager_fail_htlc_backwards_with_reason(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32], enum LDKFailureCode failure_code);
23269 export function ChannelManager_fail_htlc_backwards_with_reason(this_arg: bigint, payment_hash: number, failure_code: FailureCode): void {
23270 if(!isWasmInitialized) {
23271 throw new Error("initializeWasm() must be awaited first!");
23273 const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards_with_reason(this_arg, payment_hash, failure_code);
23274 // debug statements here
23276 // void ChannelManager_claim_funds(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
23278 export function ChannelManager_claim_funds(this_arg: bigint, payment_preimage: number): void {
23279 if(!isWasmInitialized) {
23280 throw new Error("initializeWasm() must be awaited first!");
23282 const nativeResponseValue = wasm.TS_ChannelManager_claim_funds(this_arg, payment_preimage);
23283 // debug statements here
23285 // MUST_USE_RES struct LDKPublicKey ChannelManager_get_our_node_id(const struct LDKChannelManager *NONNULL_PTR this_arg);
23287 export function ChannelManager_get_our_node_id(this_arg: bigint): number {
23288 if(!isWasmInitialized) {
23289 throw new Error("initializeWasm() must be awaited first!");
23291 const nativeResponseValue = wasm.TS_ChannelManager_get_our_node_id(this_arg);
23292 return nativeResponseValue;
23294 // 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, struct LDKU128 user_channel_id);
23296 export function ChannelManager_accept_inbound_channel(this_arg: bigint, temporary_channel_id: number, counterparty_node_id: number, user_channel_id: number): bigint {
23297 if(!isWasmInitialized) {
23298 throw new Error("initializeWasm() must be awaited first!");
23300 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
23301 return nativeResponseValue;
23303 // 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, struct LDKU128 user_channel_id);
23305 export function ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg: bigint, temporary_channel_id: number, counterparty_node_id: number, user_channel_id: number): bigint {
23306 if(!isWasmInitialized) {
23307 throw new Error("initializeWasm() must be awaited first!");
23309 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
23310 return nativeResponseValue;
23312 // 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, struct LDKCOption_u16Z min_final_cltv_expiry_delta);
23314 export function ChannelManager_create_inbound_payment(this_arg: bigint, min_value_msat: bigint, invoice_expiry_delta_secs: number, min_final_cltv_expiry_delta: bigint): bigint {
23315 if(!isWasmInitialized) {
23316 throw new Error("initializeWasm() must be awaited first!");
23318 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment(this_arg, min_value_msat, invoice_expiry_delta_secs, min_final_cltv_expiry_delta);
23319 return nativeResponseValue;
23321 // 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);
23323 export function ChannelManager_create_inbound_payment_legacy(this_arg: bigint, min_value_msat: bigint, invoice_expiry_delta_secs: number): bigint {
23324 if(!isWasmInitialized) {
23325 throw new Error("initializeWasm() must be awaited first!");
23327 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_legacy(this_arg, min_value_msat, invoice_expiry_delta_secs);
23328 return nativeResponseValue;
23330 // 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, struct LDKCOption_u16Z min_final_cltv_expiry);
23332 export function ChannelManager_create_inbound_payment_for_hash(this_arg: bigint, payment_hash: number, min_value_msat: bigint, invoice_expiry_delta_secs: number, min_final_cltv_expiry: bigint): bigint {
23333 if(!isWasmInitialized) {
23334 throw new Error("initializeWasm() must be awaited first!");
23336 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs, min_final_cltv_expiry);
23337 return nativeResponseValue;
23339 // 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);
23341 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 {
23342 if(!isWasmInitialized) {
23343 throw new Error("initializeWasm() must be awaited first!");
23345 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash_legacy(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
23346 return nativeResponseValue;
23348 // 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);
23350 export function ChannelManager_get_payment_preimage(this_arg: bigint, payment_hash: number, payment_secret: number): bigint {
23351 if(!isWasmInitialized) {
23352 throw new Error("initializeWasm() must be awaited first!");
23354 const nativeResponseValue = wasm.TS_ChannelManager_get_payment_preimage(this_arg, payment_hash, payment_secret);
23355 return nativeResponseValue;
23357 // MUST_USE_RES uint64_t ChannelManager_get_phantom_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
23359 export function ChannelManager_get_phantom_scid(this_arg: bigint): bigint {
23360 if(!isWasmInitialized) {
23361 throw new Error("initializeWasm() must be awaited first!");
23363 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_scid(this_arg);
23364 return nativeResponseValue;
23366 // MUST_USE_RES struct LDKPhantomRouteHints ChannelManager_get_phantom_route_hints(const struct LDKChannelManager *NONNULL_PTR this_arg);
23368 export function ChannelManager_get_phantom_route_hints(this_arg: bigint): bigint {
23369 if(!isWasmInitialized) {
23370 throw new Error("initializeWasm() must be awaited first!");
23372 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_route_hints(this_arg);
23373 return nativeResponseValue;
23375 // MUST_USE_RES uint64_t ChannelManager_get_intercept_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
23377 export function ChannelManager_get_intercept_scid(this_arg: bigint): bigint {
23378 if(!isWasmInitialized) {
23379 throw new Error("initializeWasm() must be awaited first!");
23381 const nativeResponseValue = wasm.TS_ChannelManager_get_intercept_scid(this_arg);
23382 return nativeResponseValue;
23384 // MUST_USE_RES struct LDKInFlightHtlcs ChannelManager_compute_inflight_htlcs(const struct LDKChannelManager *NONNULL_PTR this_arg);
23386 export function ChannelManager_compute_inflight_htlcs(this_arg: bigint): bigint {
23387 if(!isWasmInitialized) {
23388 throw new Error("initializeWasm() must be awaited first!");
23390 const nativeResponseValue = wasm.TS_ChannelManager_compute_inflight_htlcs(this_arg);
23391 return nativeResponseValue;
23393 // struct LDKMessageSendEventsProvider ChannelManager_as_MessageSendEventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
23395 export function ChannelManager_as_MessageSendEventsProvider(this_arg: bigint): bigint {
23396 if(!isWasmInitialized) {
23397 throw new Error("initializeWasm() must be awaited first!");
23399 const nativeResponseValue = wasm.TS_ChannelManager_as_MessageSendEventsProvider(this_arg);
23400 return nativeResponseValue;
23402 // struct LDKEventsProvider ChannelManager_as_EventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
23404 export function ChannelManager_as_EventsProvider(this_arg: bigint): bigint {
23405 if(!isWasmInitialized) {
23406 throw new Error("initializeWasm() must be awaited first!");
23408 const nativeResponseValue = wasm.TS_ChannelManager_as_EventsProvider(this_arg);
23409 return nativeResponseValue;
23411 // struct LDKListen ChannelManager_as_Listen(const struct LDKChannelManager *NONNULL_PTR this_arg);
23413 export function ChannelManager_as_Listen(this_arg: bigint): bigint {
23414 if(!isWasmInitialized) {
23415 throw new Error("initializeWasm() must be awaited first!");
23417 const nativeResponseValue = wasm.TS_ChannelManager_as_Listen(this_arg);
23418 return nativeResponseValue;
23420 // struct LDKConfirm ChannelManager_as_Confirm(const struct LDKChannelManager *NONNULL_PTR this_arg);
23422 export function ChannelManager_as_Confirm(this_arg: bigint): bigint {
23423 if(!isWasmInitialized) {
23424 throw new Error("initializeWasm() must be awaited first!");
23426 const nativeResponseValue = wasm.TS_ChannelManager_as_Confirm(this_arg);
23427 return nativeResponseValue;
23429 // void ChannelManager_await_persistable_update(const struct LDKChannelManager *NONNULL_PTR this_arg);
23431 export function ChannelManager_await_persistable_update(this_arg: bigint): void {
23432 if(!isWasmInitialized) {
23433 throw new Error("initializeWasm() must be awaited first!");
23435 const nativeResponseValue = wasm.TS_ChannelManager_await_persistable_update(this_arg);
23436 // debug statements here
23438 // MUST_USE_RES struct LDKFuture ChannelManager_get_persistable_update_future(const struct LDKChannelManager *NONNULL_PTR this_arg);
23440 export function ChannelManager_get_persistable_update_future(this_arg: bigint): bigint {
23441 if(!isWasmInitialized) {
23442 throw new Error("initializeWasm() must be awaited first!");
23444 const nativeResponseValue = wasm.TS_ChannelManager_get_persistable_update_future(this_arg);
23445 return nativeResponseValue;
23447 // MUST_USE_RES struct LDKBestBlock ChannelManager_current_best_block(const struct LDKChannelManager *NONNULL_PTR this_arg);
23449 export function ChannelManager_current_best_block(this_arg: bigint): bigint {
23450 if(!isWasmInitialized) {
23451 throw new Error("initializeWasm() must be awaited first!");
23453 const nativeResponseValue = wasm.TS_ChannelManager_current_best_block(this_arg);
23454 return nativeResponseValue;
23456 // MUST_USE_RES struct LDKNodeFeatures ChannelManager_node_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
23458 export function ChannelManager_node_features(this_arg: bigint): bigint {
23459 if(!isWasmInitialized) {
23460 throw new Error("initializeWasm() must be awaited first!");
23462 const nativeResponseValue = wasm.TS_ChannelManager_node_features(this_arg);
23463 return nativeResponseValue;
23465 // MUST_USE_RES struct LDKChannelFeatures ChannelManager_channel_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
23467 export function ChannelManager_channel_features(this_arg: bigint): bigint {
23468 if(!isWasmInitialized) {
23469 throw new Error("initializeWasm() must be awaited first!");
23471 const nativeResponseValue = wasm.TS_ChannelManager_channel_features(this_arg);
23472 return nativeResponseValue;
23474 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelManager_channel_type_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
23476 export function ChannelManager_channel_type_features(this_arg: bigint): bigint {
23477 if(!isWasmInitialized) {
23478 throw new Error("initializeWasm() must be awaited first!");
23480 const nativeResponseValue = wasm.TS_ChannelManager_channel_type_features(this_arg);
23481 return nativeResponseValue;
23483 // MUST_USE_RES struct LDKInitFeatures ChannelManager_init_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
23485 export function ChannelManager_init_features(this_arg: bigint): bigint {
23486 if(!isWasmInitialized) {
23487 throw new Error("initializeWasm() must be awaited first!");
23489 const nativeResponseValue = wasm.TS_ChannelManager_init_features(this_arg);
23490 return nativeResponseValue;
23492 // struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
23494 export function ChannelManager_as_ChannelMessageHandler(this_arg: bigint): bigint {
23495 if(!isWasmInitialized) {
23496 throw new Error("initializeWasm() must be awaited first!");
23498 const nativeResponseValue = wasm.TS_ChannelManager_as_ChannelMessageHandler(this_arg);
23499 return nativeResponseValue;
23501 // struct LDKInitFeatures provided_init_features(const struct LDKUserConfig *NONNULL_PTR _config);
23503 export function provided_init_features(_config: bigint): bigint {
23504 if(!isWasmInitialized) {
23505 throw new Error("initializeWasm() must be awaited first!");
23507 const nativeResponseValue = wasm.TS_provided_init_features(_config);
23508 return nativeResponseValue;
23510 // struct LDKCVec_u8Z CounterpartyForwardingInfo_write(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR obj);
23512 export function CounterpartyForwardingInfo_write(obj: bigint): number {
23513 if(!isWasmInitialized) {
23514 throw new Error("initializeWasm() must be awaited first!");
23516 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_write(obj);
23517 return nativeResponseValue;
23519 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CounterpartyForwardingInfo_read(struct LDKu8slice ser);
23521 export function CounterpartyForwardingInfo_read(ser: number): bigint {
23522 if(!isWasmInitialized) {
23523 throw new Error("initializeWasm() must be awaited first!");
23525 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_read(ser);
23526 return nativeResponseValue;
23528 // struct LDKCVec_u8Z ChannelCounterparty_write(const struct LDKChannelCounterparty *NONNULL_PTR obj);
23530 export function ChannelCounterparty_write(obj: bigint): number {
23531 if(!isWasmInitialized) {
23532 throw new Error("initializeWasm() must be awaited first!");
23534 const nativeResponseValue = wasm.TS_ChannelCounterparty_write(obj);
23535 return nativeResponseValue;
23537 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ ChannelCounterparty_read(struct LDKu8slice ser);
23539 export function ChannelCounterparty_read(ser: number): bigint {
23540 if(!isWasmInitialized) {
23541 throw new Error("initializeWasm() must be awaited first!");
23543 const nativeResponseValue = wasm.TS_ChannelCounterparty_read(ser);
23544 return nativeResponseValue;
23546 // struct LDKCVec_u8Z ChannelDetails_write(const struct LDKChannelDetails *NONNULL_PTR obj);
23548 export function ChannelDetails_write(obj: bigint): number {
23549 if(!isWasmInitialized) {
23550 throw new Error("initializeWasm() must be awaited first!");
23552 const nativeResponseValue = wasm.TS_ChannelDetails_write(obj);
23553 return nativeResponseValue;
23555 // struct LDKCResult_ChannelDetailsDecodeErrorZ ChannelDetails_read(struct LDKu8slice ser);
23557 export function ChannelDetails_read(ser: number): bigint {
23558 if(!isWasmInitialized) {
23559 throw new Error("initializeWasm() must be awaited first!");
23561 const nativeResponseValue = wasm.TS_ChannelDetails_read(ser);
23562 return nativeResponseValue;
23564 // struct LDKCVec_u8Z PhantomRouteHints_write(const struct LDKPhantomRouteHints *NONNULL_PTR obj);
23566 export function PhantomRouteHints_write(obj: bigint): number {
23567 if(!isWasmInitialized) {
23568 throw new Error("initializeWasm() must be awaited first!");
23570 const nativeResponseValue = wasm.TS_PhantomRouteHints_write(obj);
23571 return nativeResponseValue;
23573 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ PhantomRouteHints_read(struct LDKu8slice ser);
23575 export function PhantomRouteHints_read(ser: number): bigint {
23576 if(!isWasmInitialized) {
23577 throw new Error("initializeWasm() must be awaited first!");
23579 const nativeResponseValue = wasm.TS_PhantomRouteHints_read(ser);
23580 return nativeResponseValue;
23582 // struct LDKCVec_u8Z ChannelManager_write(const struct LDKChannelManager *NONNULL_PTR obj);
23584 export function ChannelManager_write(obj: bigint): number {
23585 if(!isWasmInitialized) {
23586 throw new Error("initializeWasm() must be awaited first!");
23588 const nativeResponseValue = wasm.TS_ChannelManager_write(obj);
23589 return nativeResponseValue;
23591 // void ChannelManagerReadArgs_free(struct LDKChannelManagerReadArgs this_obj);
23593 export function ChannelManagerReadArgs_free(this_obj: bigint): void {
23594 if(!isWasmInitialized) {
23595 throw new Error("initializeWasm() must be awaited first!");
23597 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_free(this_obj);
23598 // debug statements here
23600 // const struct LDKEntropySource *ChannelManagerReadArgs_get_entropy_source(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
23602 export function ChannelManagerReadArgs_get_entropy_source(this_ptr: bigint): bigint {
23603 if(!isWasmInitialized) {
23604 throw new Error("initializeWasm() must be awaited first!");
23606 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_entropy_source(this_ptr);
23607 return nativeResponseValue;
23609 // void ChannelManagerReadArgs_set_entropy_source(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKEntropySource val);
23611 export function ChannelManagerReadArgs_set_entropy_source(this_ptr: bigint, val: bigint): void {
23612 if(!isWasmInitialized) {
23613 throw new Error("initializeWasm() must be awaited first!");
23615 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_entropy_source(this_ptr, val);
23616 // debug statements here
23618 // const struct LDKNodeSigner *ChannelManagerReadArgs_get_node_signer(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
23620 export function ChannelManagerReadArgs_get_node_signer(this_ptr: bigint): bigint {
23621 if(!isWasmInitialized) {
23622 throw new Error("initializeWasm() must be awaited first!");
23624 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_node_signer(this_ptr);
23625 return nativeResponseValue;
23627 // void ChannelManagerReadArgs_set_node_signer(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKNodeSigner val);
23629 export function ChannelManagerReadArgs_set_node_signer(this_ptr: bigint, val: bigint): void {
23630 if(!isWasmInitialized) {
23631 throw new Error("initializeWasm() must be awaited first!");
23633 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_node_signer(this_ptr, val);
23634 // debug statements here
23636 // const struct LDKSignerProvider *ChannelManagerReadArgs_get_signer_provider(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
23638 export function ChannelManagerReadArgs_get_signer_provider(this_ptr: bigint): bigint {
23639 if(!isWasmInitialized) {
23640 throw new Error("initializeWasm() must be awaited first!");
23642 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_signer_provider(this_ptr);
23643 return nativeResponseValue;
23645 // void ChannelManagerReadArgs_set_signer_provider(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKSignerProvider val);
23647 export function ChannelManagerReadArgs_set_signer_provider(this_ptr: bigint, val: bigint): void {
23648 if(!isWasmInitialized) {
23649 throw new Error("initializeWasm() must be awaited first!");
23651 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_signer_provider(this_ptr, val);
23652 // debug statements here
23654 // const struct LDKFeeEstimator *ChannelManagerReadArgs_get_fee_estimator(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
23656 export function ChannelManagerReadArgs_get_fee_estimator(this_ptr: bigint): bigint {
23657 if(!isWasmInitialized) {
23658 throw new Error("initializeWasm() must be awaited first!");
23660 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_fee_estimator(this_ptr);
23661 return nativeResponseValue;
23663 // void ChannelManagerReadArgs_set_fee_estimator(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKFeeEstimator val);
23665 export function ChannelManagerReadArgs_set_fee_estimator(this_ptr: bigint, val: bigint): void {
23666 if(!isWasmInitialized) {
23667 throw new Error("initializeWasm() must be awaited first!");
23669 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_fee_estimator(this_ptr, val);
23670 // debug statements here
23672 // const struct LDKWatch *ChannelManagerReadArgs_get_chain_monitor(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
23674 export function ChannelManagerReadArgs_get_chain_monitor(this_ptr: bigint): bigint {
23675 if(!isWasmInitialized) {
23676 throw new Error("initializeWasm() must be awaited first!");
23678 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_chain_monitor(this_ptr);
23679 return nativeResponseValue;
23681 // void ChannelManagerReadArgs_set_chain_monitor(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKWatch val);
23683 export function ChannelManagerReadArgs_set_chain_monitor(this_ptr: bigint, val: bigint): void {
23684 if(!isWasmInitialized) {
23685 throw new Error("initializeWasm() must be awaited first!");
23687 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_chain_monitor(this_ptr, val);
23688 // debug statements here
23690 // const struct LDKBroadcasterInterface *ChannelManagerReadArgs_get_tx_broadcaster(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
23692 export function ChannelManagerReadArgs_get_tx_broadcaster(this_ptr: bigint): bigint {
23693 if(!isWasmInitialized) {
23694 throw new Error("initializeWasm() must be awaited first!");
23696 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_tx_broadcaster(this_ptr);
23697 return nativeResponseValue;
23699 // void ChannelManagerReadArgs_set_tx_broadcaster(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKBroadcasterInterface val);
23701 export function ChannelManagerReadArgs_set_tx_broadcaster(this_ptr: bigint, val: bigint): void {
23702 if(!isWasmInitialized) {
23703 throw new Error("initializeWasm() must be awaited first!");
23705 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_tx_broadcaster(this_ptr, val);
23706 // debug statements here
23708 // const struct LDKRouter *ChannelManagerReadArgs_get_router(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
23710 export function ChannelManagerReadArgs_get_router(this_ptr: bigint): bigint {
23711 if(!isWasmInitialized) {
23712 throw new Error("initializeWasm() must be awaited first!");
23714 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_router(this_ptr);
23715 return nativeResponseValue;
23717 // void ChannelManagerReadArgs_set_router(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKRouter val);
23719 export function ChannelManagerReadArgs_set_router(this_ptr: bigint, val: bigint): void {
23720 if(!isWasmInitialized) {
23721 throw new Error("initializeWasm() must be awaited first!");
23723 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_router(this_ptr, val);
23724 // debug statements here
23726 // const struct LDKLogger *ChannelManagerReadArgs_get_logger(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
23728 export function ChannelManagerReadArgs_get_logger(this_ptr: bigint): bigint {
23729 if(!isWasmInitialized) {
23730 throw new Error("initializeWasm() must be awaited first!");
23732 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_logger(this_ptr);
23733 return nativeResponseValue;
23735 // void ChannelManagerReadArgs_set_logger(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKLogger val);
23737 export function ChannelManagerReadArgs_set_logger(this_ptr: bigint, val: bigint): void {
23738 if(!isWasmInitialized) {
23739 throw new Error("initializeWasm() must be awaited first!");
23741 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_logger(this_ptr, val);
23742 // debug statements here
23744 // struct LDKUserConfig ChannelManagerReadArgs_get_default_config(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
23746 export function ChannelManagerReadArgs_get_default_config(this_ptr: bigint): bigint {
23747 if(!isWasmInitialized) {
23748 throw new Error("initializeWasm() must be awaited first!");
23750 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_default_config(this_ptr);
23751 return nativeResponseValue;
23753 // void ChannelManagerReadArgs_set_default_config(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKUserConfig val);
23755 export function ChannelManagerReadArgs_set_default_config(this_ptr: bigint, val: bigint): void {
23756 if(!isWasmInitialized) {
23757 throw new Error("initializeWasm() must be awaited first!");
23759 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_default_config(this_ptr, val);
23760 // debug statements here
23762 // MUST_USE_RES struct LDKChannelManagerReadArgs ChannelManagerReadArgs_new(struct LDKEntropySource entropy_source, struct LDKNodeSigner node_signer, struct LDKSignerProvider signer_provider, struct LDKFeeEstimator fee_estimator, struct LDKWatch chain_monitor, struct LDKBroadcasterInterface tx_broadcaster, struct LDKRouter router, struct LDKLogger logger, struct LDKUserConfig default_config, struct LDKCVec_ChannelMonitorZ channel_monitors);
23764 export function ChannelManagerReadArgs_new(entropy_source: bigint, node_signer: bigint, signer_provider: bigint, fee_estimator: bigint, chain_monitor: bigint, tx_broadcaster: bigint, router: bigint, logger: bigint, default_config: bigint, channel_monitors: number): bigint {
23765 if(!isWasmInitialized) {
23766 throw new Error("initializeWasm() must be awaited first!");
23768 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_new(entropy_source, node_signer, signer_provider, fee_estimator, chain_monitor, tx_broadcaster, router, logger, default_config, channel_monitors);
23769 return nativeResponseValue;
23771 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ C2Tuple_BlockHashChannelManagerZ_read(struct LDKu8slice ser, struct LDKChannelManagerReadArgs arg);
23773 export function C2Tuple_BlockHashChannelManagerZ_read(ser: number, arg: bigint): bigint {
23774 if(!isWasmInitialized) {
23775 throw new Error("initializeWasm() must be awaited first!");
23777 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_read(ser, arg);
23778 return nativeResponseValue;
23780 // void ExpandedKey_free(struct LDKExpandedKey this_obj);
23782 export function ExpandedKey_free(this_obj: bigint): void {
23783 if(!isWasmInitialized) {
23784 throw new Error("initializeWasm() must be awaited first!");
23786 const nativeResponseValue = wasm.TS_ExpandedKey_free(this_obj);
23787 // debug statements here
23789 // MUST_USE_RES struct LDKExpandedKey ExpandedKey_new(const uint8_t (*key_material)[32]);
23791 export function ExpandedKey_new(key_material: number): bigint {
23792 if(!isWasmInitialized) {
23793 throw new Error("initializeWasm() must be awaited first!");
23795 const nativeResponseValue = wasm.TS_ExpandedKey_new(key_material);
23796 return nativeResponseValue;
23798 // 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 LDKEntropySource *NONNULL_PTR entropy_source, uint64_t current_time, struct LDKCOption_u16Z min_final_cltv_expiry_delta);
23800 export function create(keys: bigint, min_value_msat: bigint, invoice_expiry_delta_secs: number, entropy_source: bigint, current_time: bigint, min_final_cltv_expiry_delta: bigint): bigint {
23801 if(!isWasmInitialized) {
23802 throw new Error("initializeWasm() must be awaited first!");
23804 const nativeResponseValue = wasm.TS_create(keys, min_value_msat, invoice_expiry_delta_secs, entropy_source, current_time, min_final_cltv_expiry_delta);
23805 return nativeResponseValue;
23807 // 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, struct LDKCOption_u16Z min_final_cltv_expiry_delta);
23809 export function create_from_hash(keys: bigint, min_value_msat: bigint, payment_hash: number, invoice_expiry_delta_secs: number, current_time: bigint, min_final_cltv_expiry_delta: bigint): bigint {
23810 if(!isWasmInitialized) {
23811 throw new Error("initializeWasm() must be awaited first!");
23813 const nativeResponseValue = wasm.TS_create_from_hash(keys, min_value_msat, payment_hash, invoice_expiry_delta_secs, current_time, min_final_cltv_expiry_delta);
23814 return nativeResponseValue;
23816 // void DecodeError_free(struct LDKDecodeError this_ptr);
23818 export function DecodeError_free(this_ptr: bigint): void {
23819 if(!isWasmInitialized) {
23820 throw new Error("initializeWasm() must be awaited first!");
23822 const nativeResponseValue = wasm.TS_DecodeError_free(this_ptr);
23823 // debug statements here
23825 // uint64_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg);
23827 export function DecodeError_clone_ptr(arg: bigint): bigint {
23828 if(!isWasmInitialized) {
23829 throw new Error("initializeWasm() must be awaited first!");
23831 const nativeResponseValue = wasm.TS_DecodeError_clone_ptr(arg);
23832 return nativeResponseValue;
23834 // struct LDKDecodeError DecodeError_clone(const struct LDKDecodeError *NONNULL_PTR orig);
23836 export function DecodeError_clone(orig: bigint): bigint {
23837 if(!isWasmInitialized) {
23838 throw new Error("initializeWasm() must be awaited first!");
23840 const nativeResponseValue = wasm.TS_DecodeError_clone(orig);
23841 return nativeResponseValue;
23843 // struct LDKDecodeError DecodeError_unknown_version(void);
23845 export function DecodeError_unknown_version(): bigint {
23846 if(!isWasmInitialized) {
23847 throw new Error("initializeWasm() must be awaited first!");
23849 const nativeResponseValue = wasm.TS_DecodeError_unknown_version();
23850 return nativeResponseValue;
23852 // struct LDKDecodeError DecodeError_unknown_required_feature(void);
23854 export function DecodeError_unknown_required_feature(): bigint {
23855 if(!isWasmInitialized) {
23856 throw new Error("initializeWasm() must be awaited first!");
23858 const nativeResponseValue = wasm.TS_DecodeError_unknown_required_feature();
23859 return nativeResponseValue;
23861 // struct LDKDecodeError DecodeError_invalid_value(void);
23863 export function DecodeError_invalid_value(): bigint {
23864 if(!isWasmInitialized) {
23865 throw new Error("initializeWasm() must be awaited first!");
23867 const nativeResponseValue = wasm.TS_DecodeError_invalid_value();
23868 return nativeResponseValue;
23870 // struct LDKDecodeError DecodeError_short_read(void);
23872 export function DecodeError_short_read(): bigint {
23873 if(!isWasmInitialized) {
23874 throw new Error("initializeWasm() must be awaited first!");
23876 const nativeResponseValue = wasm.TS_DecodeError_short_read();
23877 return nativeResponseValue;
23879 // struct LDKDecodeError DecodeError_bad_length_descriptor(void);
23881 export function DecodeError_bad_length_descriptor(): bigint {
23882 if(!isWasmInitialized) {
23883 throw new Error("initializeWasm() must be awaited first!");
23885 const nativeResponseValue = wasm.TS_DecodeError_bad_length_descriptor();
23886 return nativeResponseValue;
23888 // struct LDKDecodeError DecodeError_io(enum LDKIOError a);
23890 export function DecodeError_io(a: IOError): bigint {
23891 if(!isWasmInitialized) {
23892 throw new Error("initializeWasm() must be awaited first!");
23894 const nativeResponseValue = wasm.TS_DecodeError_io(a);
23895 return nativeResponseValue;
23897 // struct LDKDecodeError DecodeError_unsupported_compression(void);
23899 export function DecodeError_unsupported_compression(): bigint {
23900 if(!isWasmInitialized) {
23901 throw new Error("initializeWasm() must be awaited first!");
23903 const nativeResponseValue = wasm.TS_DecodeError_unsupported_compression();
23904 return nativeResponseValue;
23906 // bool DecodeError_eq(const struct LDKDecodeError *NONNULL_PTR a, const struct LDKDecodeError *NONNULL_PTR b);
23908 export function DecodeError_eq(a: bigint, b: bigint): boolean {
23909 if(!isWasmInitialized) {
23910 throw new Error("initializeWasm() must be awaited first!");
23912 const nativeResponseValue = wasm.TS_DecodeError_eq(a, b);
23913 return nativeResponseValue;
23915 // void Init_free(struct LDKInit this_obj);
23917 export function Init_free(this_obj: bigint): void {
23918 if(!isWasmInitialized) {
23919 throw new Error("initializeWasm() must be awaited first!");
23921 const nativeResponseValue = wasm.TS_Init_free(this_obj);
23922 // debug statements here
23924 // struct LDKInitFeatures Init_get_features(const struct LDKInit *NONNULL_PTR this_ptr);
23926 export function Init_get_features(this_ptr: bigint): bigint {
23927 if(!isWasmInitialized) {
23928 throw new Error("initializeWasm() must be awaited first!");
23930 const nativeResponseValue = wasm.TS_Init_get_features(this_ptr);
23931 return nativeResponseValue;
23933 // void Init_set_features(struct LDKInit *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
23935 export function Init_set_features(this_ptr: bigint, val: bigint): void {
23936 if(!isWasmInitialized) {
23937 throw new Error("initializeWasm() must be awaited first!");
23939 const nativeResponseValue = wasm.TS_Init_set_features(this_ptr, val);
23940 // debug statements here
23942 // struct LDKCOption_NetAddressZ Init_get_remote_network_address(const struct LDKInit *NONNULL_PTR this_ptr);
23944 export function Init_get_remote_network_address(this_ptr: bigint): bigint {
23945 if(!isWasmInitialized) {
23946 throw new Error("initializeWasm() must be awaited first!");
23948 const nativeResponseValue = wasm.TS_Init_get_remote_network_address(this_ptr);
23949 return nativeResponseValue;
23951 // void Init_set_remote_network_address(struct LDKInit *NONNULL_PTR this_ptr, struct LDKCOption_NetAddressZ val);
23953 export function Init_set_remote_network_address(this_ptr: bigint, val: bigint): void {
23954 if(!isWasmInitialized) {
23955 throw new Error("initializeWasm() must be awaited first!");
23957 const nativeResponseValue = wasm.TS_Init_set_remote_network_address(this_ptr, val);
23958 // debug statements here
23960 // MUST_USE_RES struct LDKInit Init_new(struct LDKInitFeatures features_arg, struct LDKCOption_NetAddressZ remote_network_address_arg);
23962 export function Init_new(features_arg: bigint, remote_network_address_arg: bigint): bigint {
23963 if(!isWasmInitialized) {
23964 throw new Error("initializeWasm() must be awaited first!");
23966 const nativeResponseValue = wasm.TS_Init_new(features_arg, remote_network_address_arg);
23967 return nativeResponseValue;
23969 // uint64_t Init_clone_ptr(LDKInit *NONNULL_PTR arg);
23971 export function Init_clone_ptr(arg: bigint): bigint {
23972 if(!isWasmInitialized) {
23973 throw new Error("initializeWasm() must be awaited first!");
23975 const nativeResponseValue = wasm.TS_Init_clone_ptr(arg);
23976 return nativeResponseValue;
23978 // struct LDKInit Init_clone(const struct LDKInit *NONNULL_PTR orig);
23980 export function Init_clone(orig: bigint): bigint {
23981 if(!isWasmInitialized) {
23982 throw new Error("initializeWasm() must be awaited first!");
23984 const nativeResponseValue = wasm.TS_Init_clone(orig);
23985 return nativeResponseValue;
23987 // bool Init_eq(const struct LDKInit *NONNULL_PTR a, const struct LDKInit *NONNULL_PTR b);
23989 export function Init_eq(a: bigint, b: bigint): boolean {
23990 if(!isWasmInitialized) {
23991 throw new Error("initializeWasm() must be awaited first!");
23993 const nativeResponseValue = wasm.TS_Init_eq(a, b);
23994 return nativeResponseValue;
23996 // void ErrorMessage_free(struct LDKErrorMessage this_obj);
23998 export function ErrorMessage_free(this_obj: bigint): void {
23999 if(!isWasmInitialized) {
24000 throw new Error("initializeWasm() must be awaited first!");
24002 const nativeResponseValue = wasm.TS_ErrorMessage_free(this_obj);
24003 // debug statements here
24005 // const uint8_t (*ErrorMessage_get_channel_id(const struct LDKErrorMessage *NONNULL_PTR this_ptr))[32];
24007 export function ErrorMessage_get_channel_id(this_ptr: bigint): number {
24008 if(!isWasmInitialized) {
24009 throw new Error("initializeWasm() must be awaited first!");
24011 const nativeResponseValue = wasm.TS_ErrorMessage_get_channel_id(this_ptr);
24012 return nativeResponseValue;
24014 // void ErrorMessage_set_channel_id(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24016 export function ErrorMessage_set_channel_id(this_ptr: bigint, val: number): void {
24017 if(!isWasmInitialized) {
24018 throw new Error("initializeWasm() must be awaited first!");
24020 const nativeResponseValue = wasm.TS_ErrorMessage_set_channel_id(this_ptr, val);
24021 // debug statements here
24023 // struct LDKStr ErrorMessage_get_data(const struct LDKErrorMessage *NONNULL_PTR this_ptr);
24025 export function ErrorMessage_get_data(this_ptr: bigint): number {
24026 if(!isWasmInitialized) {
24027 throw new Error("initializeWasm() must be awaited first!");
24029 const nativeResponseValue = wasm.TS_ErrorMessage_get_data(this_ptr);
24030 return nativeResponseValue;
24032 // void ErrorMessage_set_data(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKStr val);
24034 export function ErrorMessage_set_data(this_ptr: bigint, val: number): void {
24035 if(!isWasmInitialized) {
24036 throw new Error("initializeWasm() must be awaited first!");
24038 const nativeResponseValue = wasm.TS_ErrorMessage_set_data(this_ptr, val);
24039 // debug statements here
24041 // MUST_USE_RES struct LDKErrorMessage ErrorMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
24043 export function ErrorMessage_new(channel_id_arg: number, data_arg: number): bigint {
24044 if(!isWasmInitialized) {
24045 throw new Error("initializeWasm() must be awaited first!");
24047 const nativeResponseValue = wasm.TS_ErrorMessage_new(channel_id_arg, data_arg);
24048 return nativeResponseValue;
24050 // uint64_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg);
24052 export function ErrorMessage_clone_ptr(arg: bigint): bigint {
24053 if(!isWasmInitialized) {
24054 throw new Error("initializeWasm() must be awaited first!");
24056 const nativeResponseValue = wasm.TS_ErrorMessage_clone_ptr(arg);
24057 return nativeResponseValue;
24059 // struct LDKErrorMessage ErrorMessage_clone(const struct LDKErrorMessage *NONNULL_PTR orig);
24061 export function ErrorMessage_clone(orig: bigint): bigint {
24062 if(!isWasmInitialized) {
24063 throw new Error("initializeWasm() must be awaited first!");
24065 const nativeResponseValue = wasm.TS_ErrorMessage_clone(orig);
24066 return nativeResponseValue;
24068 // bool ErrorMessage_eq(const struct LDKErrorMessage *NONNULL_PTR a, const struct LDKErrorMessage *NONNULL_PTR b);
24070 export function ErrorMessage_eq(a: bigint, b: bigint): boolean {
24071 if(!isWasmInitialized) {
24072 throw new Error("initializeWasm() must be awaited first!");
24074 const nativeResponseValue = wasm.TS_ErrorMessage_eq(a, b);
24075 return nativeResponseValue;
24077 // void WarningMessage_free(struct LDKWarningMessage this_obj);
24079 export function WarningMessage_free(this_obj: bigint): void {
24080 if(!isWasmInitialized) {
24081 throw new Error("initializeWasm() must be awaited first!");
24083 const nativeResponseValue = wasm.TS_WarningMessage_free(this_obj);
24084 // debug statements here
24086 // const uint8_t (*WarningMessage_get_channel_id(const struct LDKWarningMessage *NONNULL_PTR this_ptr))[32];
24088 export function WarningMessage_get_channel_id(this_ptr: bigint): number {
24089 if(!isWasmInitialized) {
24090 throw new Error("initializeWasm() must be awaited first!");
24092 const nativeResponseValue = wasm.TS_WarningMessage_get_channel_id(this_ptr);
24093 return nativeResponseValue;
24095 // void WarningMessage_set_channel_id(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24097 export function WarningMessage_set_channel_id(this_ptr: bigint, val: number): void {
24098 if(!isWasmInitialized) {
24099 throw new Error("initializeWasm() must be awaited first!");
24101 const nativeResponseValue = wasm.TS_WarningMessage_set_channel_id(this_ptr, val);
24102 // debug statements here
24104 // struct LDKStr WarningMessage_get_data(const struct LDKWarningMessage *NONNULL_PTR this_ptr);
24106 export function WarningMessage_get_data(this_ptr: bigint): number {
24107 if(!isWasmInitialized) {
24108 throw new Error("initializeWasm() must be awaited first!");
24110 const nativeResponseValue = wasm.TS_WarningMessage_get_data(this_ptr);
24111 return nativeResponseValue;
24113 // void WarningMessage_set_data(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKStr val);
24115 export function WarningMessage_set_data(this_ptr: bigint, val: number): void {
24116 if(!isWasmInitialized) {
24117 throw new Error("initializeWasm() must be awaited first!");
24119 const nativeResponseValue = wasm.TS_WarningMessage_set_data(this_ptr, val);
24120 // debug statements here
24122 // MUST_USE_RES struct LDKWarningMessage WarningMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
24124 export function WarningMessage_new(channel_id_arg: number, data_arg: number): bigint {
24125 if(!isWasmInitialized) {
24126 throw new Error("initializeWasm() must be awaited first!");
24128 const nativeResponseValue = wasm.TS_WarningMessage_new(channel_id_arg, data_arg);
24129 return nativeResponseValue;
24131 // uint64_t WarningMessage_clone_ptr(LDKWarningMessage *NONNULL_PTR arg);
24133 export function WarningMessage_clone_ptr(arg: bigint): bigint {
24134 if(!isWasmInitialized) {
24135 throw new Error("initializeWasm() must be awaited first!");
24137 const nativeResponseValue = wasm.TS_WarningMessage_clone_ptr(arg);
24138 return nativeResponseValue;
24140 // struct LDKWarningMessage WarningMessage_clone(const struct LDKWarningMessage *NONNULL_PTR orig);
24142 export function WarningMessage_clone(orig: bigint): bigint {
24143 if(!isWasmInitialized) {
24144 throw new Error("initializeWasm() must be awaited first!");
24146 const nativeResponseValue = wasm.TS_WarningMessage_clone(orig);
24147 return nativeResponseValue;
24149 // bool WarningMessage_eq(const struct LDKWarningMessage *NONNULL_PTR a, const struct LDKWarningMessage *NONNULL_PTR b);
24151 export function WarningMessage_eq(a: bigint, b: bigint): boolean {
24152 if(!isWasmInitialized) {
24153 throw new Error("initializeWasm() must be awaited first!");
24155 const nativeResponseValue = wasm.TS_WarningMessage_eq(a, b);
24156 return nativeResponseValue;
24158 // void Ping_free(struct LDKPing this_obj);
24160 export function Ping_free(this_obj: bigint): void {
24161 if(!isWasmInitialized) {
24162 throw new Error("initializeWasm() must be awaited first!");
24164 const nativeResponseValue = wasm.TS_Ping_free(this_obj);
24165 // debug statements here
24167 // uint16_t Ping_get_ponglen(const struct LDKPing *NONNULL_PTR this_ptr);
24169 export function Ping_get_ponglen(this_ptr: bigint): number {
24170 if(!isWasmInitialized) {
24171 throw new Error("initializeWasm() must be awaited first!");
24173 const nativeResponseValue = wasm.TS_Ping_get_ponglen(this_ptr);
24174 return nativeResponseValue;
24176 // void Ping_set_ponglen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
24178 export function Ping_set_ponglen(this_ptr: bigint, val: number): void {
24179 if(!isWasmInitialized) {
24180 throw new Error("initializeWasm() must be awaited first!");
24182 const nativeResponseValue = wasm.TS_Ping_set_ponglen(this_ptr, val);
24183 // debug statements here
24185 // uint16_t Ping_get_byteslen(const struct LDKPing *NONNULL_PTR this_ptr);
24187 export function Ping_get_byteslen(this_ptr: bigint): number {
24188 if(!isWasmInitialized) {
24189 throw new Error("initializeWasm() must be awaited first!");
24191 const nativeResponseValue = wasm.TS_Ping_get_byteslen(this_ptr);
24192 return nativeResponseValue;
24194 // void Ping_set_byteslen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
24196 export function Ping_set_byteslen(this_ptr: bigint, val: number): void {
24197 if(!isWasmInitialized) {
24198 throw new Error("initializeWasm() must be awaited first!");
24200 const nativeResponseValue = wasm.TS_Ping_set_byteslen(this_ptr, val);
24201 // debug statements here
24203 // MUST_USE_RES struct LDKPing Ping_new(uint16_t ponglen_arg, uint16_t byteslen_arg);
24205 export function Ping_new(ponglen_arg: number, byteslen_arg: number): bigint {
24206 if(!isWasmInitialized) {
24207 throw new Error("initializeWasm() must be awaited first!");
24209 const nativeResponseValue = wasm.TS_Ping_new(ponglen_arg, byteslen_arg);
24210 return nativeResponseValue;
24212 // uint64_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg);
24214 export function Ping_clone_ptr(arg: bigint): bigint {
24215 if(!isWasmInitialized) {
24216 throw new Error("initializeWasm() must be awaited first!");
24218 const nativeResponseValue = wasm.TS_Ping_clone_ptr(arg);
24219 return nativeResponseValue;
24221 // struct LDKPing Ping_clone(const struct LDKPing *NONNULL_PTR orig);
24223 export function Ping_clone(orig: bigint): bigint {
24224 if(!isWasmInitialized) {
24225 throw new Error("initializeWasm() must be awaited first!");
24227 const nativeResponseValue = wasm.TS_Ping_clone(orig);
24228 return nativeResponseValue;
24230 // bool Ping_eq(const struct LDKPing *NONNULL_PTR a, const struct LDKPing *NONNULL_PTR b);
24232 export function Ping_eq(a: bigint, b: bigint): boolean {
24233 if(!isWasmInitialized) {
24234 throw new Error("initializeWasm() must be awaited first!");
24236 const nativeResponseValue = wasm.TS_Ping_eq(a, b);
24237 return nativeResponseValue;
24239 // void Pong_free(struct LDKPong this_obj);
24241 export function Pong_free(this_obj: bigint): void {
24242 if(!isWasmInitialized) {
24243 throw new Error("initializeWasm() must be awaited first!");
24245 const nativeResponseValue = wasm.TS_Pong_free(this_obj);
24246 // debug statements here
24248 // uint16_t Pong_get_byteslen(const struct LDKPong *NONNULL_PTR this_ptr);
24250 export function Pong_get_byteslen(this_ptr: bigint): number {
24251 if(!isWasmInitialized) {
24252 throw new Error("initializeWasm() must be awaited first!");
24254 const nativeResponseValue = wasm.TS_Pong_get_byteslen(this_ptr);
24255 return nativeResponseValue;
24257 // void Pong_set_byteslen(struct LDKPong *NONNULL_PTR this_ptr, uint16_t val);
24259 export function Pong_set_byteslen(this_ptr: bigint, val: number): void {
24260 if(!isWasmInitialized) {
24261 throw new Error("initializeWasm() must be awaited first!");
24263 const nativeResponseValue = wasm.TS_Pong_set_byteslen(this_ptr, val);
24264 // debug statements here
24266 // MUST_USE_RES struct LDKPong Pong_new(uint16_t byteslen_arg);
24268 export function Pong_new(byteslen_arg: number): bigint {
24269 if(!isWasmInitialized) {
24270 throw new Error("initializeWasm() must be awaited first!");
24272 const nativeResponseValue = wasm.TS_Pong_new(byteslen_arg);
24273 return nativeResponseValue;
24275 // uint64_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg);
24277 export function Pong_clone_ptr(arg: bigint): bigint {
24278 if(!isWasmInitialized) {
24279 throw new Error("initializeWasm() must be awaited first!");
24281 const nativeResponseValue = wasm.TS_Pong_clone_ptr(arg);
24282 return nativeResponseValue;
24284 // struct LDKPong Pong_clone(const struct LDKPong *NONNULL_PTR orig);
24286 export function Pong_clone(orig: bigint): bigint {
24287 if(!isWasmInitialized) {
24288 throw new Error("initializeWasm() must be awaited first!");
24290 const nativeResponseValue = wasm.TS_Pong_clone(orig);
24291 return nativeResponseValue;
24293 // bool Pong_eq(const struct LDKPong *NONNULL_PTR a, const struct LDKPong *NONNULL_PTR b);
24295 export function Pong_eq(a: bigint, b: bigint): boolean {
24296 if(!isWasmInitialized) {
24297 throw new Error("initializeWasm() must be awaited first!");
24299 const nativeResponseValue = wasm.TS_Pong_eq(a, b);
24300 return nativeResponseValue;
24302 // void OpenChannel_free(struct LDKOpenChannel this_obj);
24304 export function OpenChannel_free(this_obj: bigint): void {
24305 if(!isWasmInitialized) {
24306 throw new Error("initializeWasm() must be awaited first!");
24308 const nativeResponseValue = wasm.TS_OpenChannel_free(this_obj);
24309 // debug statements here
24311 // const uint8_t (*OpenChannel_get_chain_hash(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
24313 export function OpenChannel_get_chain_hash(this_ptr: bigint): number {
24314 if(!isWasmInitialized) {
24315 throw new Error("initializeWasm() must be awaited first!");
24317 const nativeResponseValue = wasm.TS_OpenChannel_get_chain_hash(this_ptr);
24318 return nativeResponseValue;
24320 // void OpenChannel_set_chain_hash(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24322 export function OpenChannel_set_chain_hash(this_ptr: bigint, val: number): void {
24323 if(!isWasmInitialized) {
24324 throw new Error("initializeWasm() must be awaited first!");
24326 const nativeResponseValue = wasm.TS_OpenChannel_set_chain_hash(this_ptr, val);
24327 // debug statements here
24329 // const uint8_t (*OpenChannel_get_temporary_channel_id(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
24331 export function OpenChannel_get_temporary_channel_id(this_ptr: bigint): number {
24332 if(!isWasmInitialized) {
24333 throw new Error("initializeWasm() must be awaited first!");
24335 const nativeResponseValue = wasm.TS_OpenChannel_get_temporary_channel_id(this_ptr);
24336 return nativeResponseValue;
24338 // void OpenChannel_set_temporary_channel_id(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24340 export function OpenChannel_set_temporary_channel_id(this_ptr: bigint, val: number): void {
24341 if(!isWasmInitialized) {
24342 throw new Error("initializeWasm() must be awaited first!");
24344 const nativeResponseValue = wasm.TS_OpenChannel_set_temporary_channel_id(this_ptr, val);
24345 // debug statements here
24347 // uint64_t OpenChannel_get_funding_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
24349 export function OpenChannel_get_funding_satoshis(this_ptr: bigint): bigint {
24350 if(!isWasmInitialized) {
24351 throw new Error("initializeWasm() must be awaited first!");
24353 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_satoshis(this_ptr);
24354 return nativeResponseValue;
24356 // void OpenChannel_set_funding_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
24358 export function OpenChannel_set_funding_satoshis(this_ptr: bigint, val: bigint): void {
24359 if(!isWasmInitialized) {
24360 throw new Error("initializeWasm() must be awaited first!");
24362 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_satoshis(this_ptr, val);
24363 // debug statements here
24365 // uint64_t OpenChannel_get_push_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
24367 export function OpenChannel_get_push_msat(this_ptr: bigint): bigint {
24368 if(!isWasmInitialized) {
24369 throw new Error("initializeWasm() must be awaited first!");
24371 const nativeResponseValue = wasm.TS_OpenChannel_get_push_msat(this_ptr);
24372 return nativeResponseValue;
24374 // void OpenChannel_set_push_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
24376 export function OpenChannel_set_push_msat(this_ptr: bigint, val: bigint): void {
24377 if(!isWasmInitialized) {
24378 throw new Error("initializeWasm() must be awaited first!");
24380 const nativeResponseValue = wasm.TS_OpenChannel_set_push_msat(this_ptr, val);
24381 // debug statements here
24383 // uint64_t OpenChannel_get_dust_limit_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
24385 export function OpenChannel_get_dust_limit_satoshis(this_ptr: bigint): bigint {
24386 if(!isWasmInitialized) {
24387 throw new Error("initializeWasm() must be awaited first!");
24389 const nativeResponseValue = wasm.TS_OpenChannel_get_dust_limit_satoshis(this_ptr);
24390 return nativeResponseValue;
24392 // void OpenChannel_set_dust_limit_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
24394 export function OpenChannel_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
24395 if(!isWasmInitialized) {
24396 throw new Error("initializeWasm() must be awaited first!");
24398 const nativeResponseValue = wasm.TS_OpenChannel_set_dust_limit_satoshis(this_ptr, val);
24399 // debug statements here
24401 // uint64_t OpenChannel_get_max_htlc_value_in_flight_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
24403 export function OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
24404 if(!isWasmInitialized) {
24405 throw new Error("initializeWasm() must be awaited first!");
24407 const nativeResponseValue = wasm.TS_OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr);
24408 return nativeResponseValue;
24410 // void OpenChannel_set_max_htlc_value_in_flight_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
24412 export function OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
24413 if(!isWasmInitialized) {
24414 throw new Error("initializeWasm() must be awaited first!");
24416 const nativeResponseValue = wasm.TS_OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
24417 // debug statements here
24419 // uint64_t OpenChannel_get_channel_reserve_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
24421 export function OpenChannel_get_channel_reserve_satoshis(this_ptr: bigint): bigint {
24422 if(!isWasmInitialized) {
24423 throw new Error("initializeWasm() must be awaited first!");
24425 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_reserve_satoshis(this_ptr);
24426 return nativeResponseValue;
24428 // void OpenChannel_set_channel_reserve_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
24430 export function OpenChannel_set_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
24431 if(!isWasmInitialized) {
24432 throw new Error("initializeWasm() must be awaited first!");
24434 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_reserve_satoshis(this_ptr, val);
24435 // debug statements here
24437 // uint64_t OpenChannel_get_htlc_minimum_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
24439 export function OpenChannel_get_htlc_minimum_msat(this_ptr: bigint): bigint {
24440 if(!isWasmInitialized) {
24441 throw new Error("initializeWasm() must be awaited first!");
24443 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_minimum_msat(this_ptr);
24444 return nativeResponseValue;
24446 // void OpenChannel_set_htlc_minimum_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
24448 export function OpenChannel_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
24449 if(!isWasmInitialized) {
24450 throw new Error("initializeWasm() must be awaited first!");
24452 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_minimum_msat(this_ptr, val);
24453 // debug statements here
24455 // uint32_t OpenChannel_get_feerate_per_kw(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
24457 export function OpenChannel_get_feerate_per_kw(this_ptr: bigint): number {
24458 if(!isWasmInitialized) {
24459 throw new Error("initializeWasm() must be awaited first!");
24461 const nativeResponseValue = wasm.TS_OpenChannel_get_feerate_per_kw(this_ptr);
24462 return nativeResponseValue;
24464 // void OpenChannel_set_feerate_per_kw(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint32_t val);
24466 export function OpenChannel_set_feerate_per_kw(this_ptr: bigint, val: number): void {
24467 if(!isWasmInitialized) {
24468 throw new Error("initializeWasm() must be awaited first!");
24470 const nativeResponseValue = wasm.TS_OpenChannel_set_feerate_per_kw(this_ptr, val);
24471 // debug statements here
24473 // uint16_t OpenChannel_get_to_self_delay(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
24475 export function OpenChannel_get_to_self_delay(this_ptr: bigint): number {
24476 if(!isWasmInitialized) {
24477 throw new Error("initializeWasm() must be awaited first!");
24479 const nativeResponseValue = wasm.TS_OpenChannel_get_to_self_delay(this_ptr);
24480 return nativeResponseValue;
24482 // void OpenChannel_set_to_self_delay(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
24484 export function OpenChannel_set_to_self_delay(this_ptr: bigint, val: number): void {
24485 if(!isWasmInitialized) {
24486 throw new Error("initializeWasm() must be awaited first!");
24488 const nativeResponseValue = wasm.TS_OpenChannel_set_to_self_delay(this_ptr, val);
24489 // debug statements here
24491 // uint16_t OpenChannel_get_max_accepted_htlcs(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
24493 export function OpenChannel_get_max_accepted_htlcs(this_ptr: bigint): number {
24494 if(!isWasmInitialized) {
24495 throw new Error("initializeWasm() must be awaited first!");
24497 const nativeResponseValue = wasm.TS_OpenChannel_get_max_accepted_htlcs(this_ptr);
24498 return nativeResponseValue;
24500 // void OpenChannel_set_max_accepted_htlcs(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
24502 export function OpenChannel_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
24503 if(!isWasmInitialized) {
24504 throw new Error("initializeWasm() must be awaited first!");
24506 const nativeResponseValue = wasm.TS_OpenChannel_set_max_accepted_htlcs(this_ptr, val);
24507 // debug statements here
24509 // struct LDKPublicKey OpenChannel_get_funding_pubkey(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
24511 export function OpenChannel_get_funding_pubkey(this_ptr: bigint): number {
24512 if(!isWasmInitialized) {
24513 throw new Error("initializeWasm() must be awaited first!");
24515 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_pubkey(this_ptr);
24516 return nativeResponseValue;
24518 // void OpenChannel_set_funding_pubkey(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24520 export function OpenChannel_set_funding_pubkey(this_ptr: bigint, val: number): void {
24521 if(!isWasmInitialized) {
24522 throw new Error("initializeWasm() must be awaited first!");
24524 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_pubkey(this_ptr, val);
24525 // debug statements here
24527 // struct LDKPublicKey OpenChannel_get_revocation_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
24529 export function OpenChannel_get_revocation_basepoint(this_ptr: bigint): number {
24530 if(!isWasmInitialized) {
24531 throw new Error("initializeWasm() must be awaited first!");
24533 const nativeResponseValue = wasm.TS_OpenChannel_get_revocation_basepoint(this_ptr);
24534 return nativeResponseValue;
24536 // void OpenChannel_set_revocation_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24538 export function OpenChannel_set_revocation_basepoint(this_ptr: bigint, val: number): void {
24539 if(!isWasmInitialized) {
24540 throw new Error("initializeWasm() must be awaited first!");
24542 const nativeResponseValue = wasm.TS_OpenChannel_set_revocation_basepoint(this_ptr, val);
24543 // debug statements here
24545 // struct LDKPublicKey OpenChannel_get_payment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
24547 export function OpenChannel_get_payment_point(this_ptr: bigint): number {
24548 if(!isWasmInitialized) {
24549 throw new Error("initializeWasm() must be awaited first!");
24551 const nativeResponseValue = wasm.TS_OpenChannel_get_payment_point(this_ptr);
24552 return nativeResponseValue;
24554 // void OpenChannel_set_payment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24556 export function OpenChannel_set_payment_point(this_ptr: bigint, val: number): void {
24557 if(!isWasmInitialized) {
24558 throw new Error("initializeWasm() must be awaited first!");
24560 const nativeResponseValue = wasm.TS_OpenChannel_set_payment_point(this_ptr, val);
24561 // debug statements here
24563 // struct LDKPublicKey OpenChannel_get_delayed_payment_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
24565 export function OpenChannel_get_delayed_payment_basepoint(this_ptr: bigint): number {
24566 if(!isWasmInitialized) {
24567 throw new Error("initializeWasm() must be awaited first!");
24569 const nativeResponseValue = wasm.TS_OpenChannel_get_delayed_payment_basepoint(this_ptr);
24570 return nativeResponseValue;
24572 // void OpenChannel_set_delayed_payment_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24574 export function OpenChannel_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
24575 if(!isWasmInitialized) {
24576 throw new Error("initializeWasm() must be awaited first!");
24578 const nativeResponseValue = wasm.TS_OpenChannel_set_delayed_payment_basepoint(this_ptr, val);
24579 // debug statements here
24581 // struct LDKPublicKey OpenChannel_get_htlc_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
24583 export function OpenChannel_get_htlc_basepoint(this_ptr: bigint): number {
24584 if(!isWasmInitialized) {
24585 throw new Error("initializeWasm() must be awaited first!");
24587 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_basepoint(this_ptr);
24588 return nativeResponseValue;
24590 // void OpenChannel_set_htlc_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24592 export function OpenChannel_set_htlc_basepoint(this_ptr: bigint, val: number): void {
24593 if(!isWasmInitialized) {
24594 throw new Error("initializeWasm() must be awaited first!");
24596 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_basepoint(this_ptr, val);
24597 // debug statements here
24599 // struct LDKPublicKey OpenChannel_get_first_per_commitment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
24601 export function OpenChannel_get_first_per_commitment_point(this_ptr: bigint): number {
24602 if(!isWasmInitialized) {
24603 throw new Error("initializeWasm() must be awaited first!");
24605 const nativeResponseValue = wasm.TS_OpenChannel_get_first_per_commitment_point(this_ptr);
24606 return nativeResponseValue;
24608 // void OpenChannel_set_first_per_commitment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24610 export function OpenChannel_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
24611 if(!isWasmInitialized) {
24612 throw new Error("initializeWasm() must be awaited first!");
24614 const nativeResponseValue = wasm.TS_OpenChannel_set_first_per_commitment_point(this_ptr, val);
24615 // debug statements here
24617 // uint8_t OpenChannel_get_channel_flags(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
24619 export function OpenChannel_get_channel_flags(this_ptr: bigint): number {
24620 if(!isWasmInitialized) {
24621 throw new Error("initializeWasm() must be awaited first!");
24623 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_flags(this_ptr);
24624 return nativeResponseValue;
24626 // void OpenChannel_set_channel_flags(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint8_t val);
24628 export function OpenChannel_set_channel_flags(this_ptr: bigint, val: number): void {
24629 if(!isWasmInitialized) {
24630 throw new Error("initializeWasm() must be awaited first!");
24632 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_flags(this_ptr, val);
24633 // debug statements here
24635 // struct LDKChannelTypeFeatures OpenChannel_get_channel_type(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
24637 export function OpenChannel_get_channel_type(this_ptr: bigint): bigint {
24638 if(!isWasmInitialized) {
24639 throw new Error("initializeWasm() must be awaited first!");
24641 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_type(this_ptr);
24642 return nativeResponseValue;
24644 // void OpenChannel_set_channel_type(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
24646 export function OpenChannel_set_channel_type(this_ptr: bigint, val: bigint): void {
24647 if(!isWasmInitialized) {
24648 throw new Error("initializeWasm() must be awaited first!");
24650 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_type(this_ptr, val);
24651 // debug statements here
24653 // uint64_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg);
24655 export function OpenChannel_clone_ptr(arg: bigint): bigint {
24656 if(!isWasmInitialized) {
24657 throw new Error("initializeWasm() must be awaited first!");
24659 const nativeResponseValue = wasm.TS_OpenChannel_clone_ptr(arg);
24660 return nativeResponseValue;
24662 // struct LDKOpenChannel OpenChannel_clone(const struct LDKOpenChannel *NONNULL_PTR orig);
24664 export function OpenChannel_clone(orig: bigint): bigint {
24665 if(!isWasmInitialized) {
24666 throw new Error("initializeWasm() must be awaited first!");
24668 const nativeResponseValue = wasm.TS_OpenChannel_clone(orig);
24669 return nativeResponseValue;
24671 // bool OpenChannel_eq(const struct LDKOpenChannel *NONNULL_PTR a, const struct LDKOpenChannel *NONNULL_PTR b);
24673 export function OpenChannel_eq(a: bigint, b: bigint): boolean {
24674 if(!isWasmInitialized) {
24675 throw new Error("initializeWasm() must be awaited first!");
24677 const nativeResponseValue = wasm.TS_OpenChannel_eq(a, b);
24678 return nativeResponseValue;
24680 // void AcceptChannel_free(struct LDKAcceptChannel this_obj);
24682 export function AcceptChannel_free(this_obj: bigint): void {
24683 if(!isWasmInitialized) {
24684 throw new Error("initializeWasm() must be awaited first!");
24686 const nativeResponseValue = wasm.TS_AcceptChannel_free(this_obj);
24687 // debug statements here
24689 // const uint8_t (*AcceptChannel_get_temporary_channel_id(const struct LDKAcceptChannel *NONNULL_PTR this_ptr))[32];
24691 export function AcceptChannel_get_temporary_channel_id(this_ptr: bigint): number {
24692 if(!isWasmInitialized) {
24693 throw new Error("initializeWasm() must be awaited first!");
24695 const nativeResponseValue = wasm.TS_AcceptChannel_get_temporary_channel_id(this_ptr);
24696 return nativeResponseValue;
24698 // void AcceptChannel_set_temporary_channel_id(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24700 export function AcceptChannel_set_temporary_channel_id(this_ptr: bigint, val: number): void {
24701 if(!isWasmInitialized) {
24702 throw new Error("initializeWasm() must be awaited first!");
24704 const nativeResponseValue = wasm.TS_AcceptChannel_set_temporary_channel_id(this_ptr, val);
24705 // debug statements here
24707 // uint64_t AcceptChannel_get_dust_limit_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
24709 export function AcceptChannel_get_dust_limit_satoshis(this_ptr: bigint): bigint {
24710 if(!isWasmInitialized) {
24711 throw new Error("initializeWasm() must be awaited first!");
24713 const nativeResponseValue = wasm.TS_AcceptChannel_get_dust_limit_satoshis(this_ptr);
24714 return nativeResponseValue;
24716 // void AcceptChannel_set_dust_limit_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
24718 export function AcceptChannel_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
24719 if(!isWasmInitialized) {
24720 throw new Error("initializeWasm() must be awaited first!");
24722 const nativeResponseValue = wasm.TS_AcceptChannel_set_dust_limit_satoshis(this_ptr, val);
24723 // debug statements here
24725 // uint64_t AcceptChannel_get_max_htlc_value_in_flight_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
24727 export function AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
24728 if(!isWasmInitialized) {
24729 throw new Error("initializeWasm() must be awaited first!");
24731 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr);
24732 return nativeResponseValue;
24734 // void AcceptChannel_set_max_htlc_value_in_flight_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
24736 export function AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
24737 if(!isWasmInitialized) {
24738 throw new Error("initializeWasm() must be awaited first!");
24740 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
24741 // debug statements here
24743 // uint64_t AcceptChannel_get_channel_reserve_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
24745 export function AcceptChannel_get_channel_reserve_satoshis(this_ptr: bigint): bigint {
24746 if(!isWasmInitialized) {
24747 throw new Error("initializeWasm() must be awaited first!");
24749 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_reserve_satoshis(this_ptr);
24750 return nativeResponseValue;
24752 // void AcceptChannel_set_channel_reserve_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
24754 export function AcceptChannel_set_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
24755 if(!isWasmInitialized) {
24756 throw new Error("initializeWasm() must be awaited first!");
24758 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_reserve_satoshis(this_ptr, val);
24759 // debug statements here
24761 // uint64_t AcceptChannel_get_htlc_minimum_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
24763 export function AcceptChannel_get_htlc_minimum_msat(this_ptr: bigint): bigint {
24764 if(!isWasmInitialized) {
24765 throw new Error("initializeWasm() must be awaited first!");
24767 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_minimum_msat(this_ptr);
24768 return nativeResponseValue;
24770 // void AcceptChannel_set_htlc_minimum_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
24772 export function AcceptChannel_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
24773 if(!isWasmInitialized) {
24774 throw new Error("initializeWasm() must be awaited first!");
24776 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_minimum_msat(this_ptr, val);
24777 // debug statements here
24779 // uint32_t AcceptChannel_get_minimum_depth(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
24781 export function AcceptChannel_get_minimum_depth(this_ptr: bigint): number {
24782 if(!isWasmInitialized) {
24783 throw new Error("initializeWasm() must be awaited first!");
24785 const nativeResponseValue = wasm.TS_AcceptChannel_get_minimum_depth(this_ptr);
24786 return nativeResponseValue;
24788 // void AcceptChannel_set_minimum_depth(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint32_t val);
24790 export function AcceptChannel_set_minimum_depth(this_ptr: bigint, val: number): void {
24791 if(!isWasmInitialized) {
24792 throw new Error("initializeWasm() must be awaited first!");
24794 const nativeResponseValue = wasm.TS_AcceptChannel_set_minimum_depth(this_ptr, val);
24795 // debug statements here
24797 // uint16_t AcceptChannel_get_to_self_delay(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
24799 export function AcceptChannel_get_to_self_delay(this_ptr: bigint): number {
24800 if(!isWasmInitialized) {
24801 throw new Error("initializeWasm() must be awaited first!");
24803 const nativeResponseValue = wasm.TS_AcceptChannel_get_to_self_delay(this_ptr);
24804 return nativeResponseValue;
24806 // void AcceptChannel_set_to_self_delay(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
24808 export function AcceptChannel_set_to_self_delay(this_ptr: bigint, val: number): void {
24809 if(!isWasmInitialized) {
24810 throw new Error("initializeWasm() must be awaited first!");
24812 const nativeResponseValue = wasm.TS_AcceptChannel_set_to_self_delay(this_ptr, val);
24813 // debug statements here
24815 // uint16_t AcceptChannel_get_max_accepted_htlcs(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
24817 export function AcceptChannel_get_max_accepted_htlcs(this_ptr: bigint): number {
24818 if(!isWasmInitialized) {
24819 throw new Error("initializeWasm() must be awaited first!");
24821 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_accepted_htlcs(this_ptr);
24822 return nativeResponseValue;
24824 // void AcceptChannel_set_max_accepted_htlcs(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
24826 export function AcceptChannel_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
24827 if(!isWasmInitialized) {
24828 throw new Error("initializeWasm() must be awaited first!");
24830 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_accepted_htlcs(this_ptr, val);
24831 // debug statements here
24833 // struct LDKPublicKey AcceptChannel_get_funding_pubkey(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
24835 export function AcceptChannel_get_funding_pubkey(this_ptr: bigint): number {
24836 if(!isWasmInitialized) {
24837 throw new Error("initializeWasm() must be awaited first!");
24839 const nativeResponseValue = wasm.TS_AcceptChannel_get_funding_pubkey(this_ptr);
24840 return nativeResponseValue;
24842 // void AcceptChannel_set_funding_pubkey(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24844 export function AcceptChannel_set_funding_pubkey(this_ptr: bigint, val: number): void {
24845 if(!isWasmInitialized) {
24846 throw new Error("initializeWasm() must be awaited first!");
24848 const nativeResponseValue = wasm.TS_AcceptChannel_set_funding_pubkey(this_ptr, val);
24849 // debug statements here
24851 // struct LDKPublicKey AcceptChannel_get_revocation_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
24853 export function AcceptChannel_get_revocation_basepoint(this_ptr: bigint): number {
24854 if(!isWasmInitialized) {
24855 throw new Error("initializeWasm() must be awaited first!");
24857 const nativeResponseValue = wasm.TS_AcceptChannel_get_revocation_basepoint(this_ptr);
24858 return nativeResponseValue;
24860 // void AcceptChannel_set_revocation_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24862 export function AcceptChannel_set_revocation_basepoint(this_ptr: bigint, val: number): void {
24863 if(!isWasmInitialized) {
24864 throw new Error("initializeWasm() must be awaited first!");
24866 const nativeResponseValue = wasm.TS_AcceptChannel_set_revocation_basepoint(this_ptr, val);
24867 // debug statements here
24869 // struct LDKPublicKey AcceptChannel_get_payment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
24871 export function AcceptChannel_get_payment_point(this_ptr: bigint): number {
24872 if(!isWasmInitialized) {
24873 throw new Error("initializeWasm() must be awaited first!");
24875 const nativeResponseValue = wasm.TS_AcceptChannel_get_payment_point(this_ptr);
24876 return nativeResponseValue;
24878 // void AcceptChannel_set_payment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24880 export function AcceptChannel_set_payment_point(this_ptr: bigint, val: number): void {
24881 if(!isWasmInitialized) {
24882 throw new Error("initializeWasm() must be awaited first!");
24884 const nativeResponseValue = wasm.TS_AcceptChannel_set_payment_point(this_ptr, val);
24885 // debug statements here
24887 // struct LDKPublicKey AcceptChannel_get_delayed_payment_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
24889 export function AcceptChannel_get_delayed_payment_basepoint(this_ptr: bigint): number {
24890 if(!isWasmInitialized) {
24891 throw new Error("initializeWasm() must be awaited first!");
24893 const nativeResponseValue = wasm.TS_AcceptChannel_get_delayed_payment_basepoint(this_ptr);
24894 return nativeResponseValue;
24896 // void AcceptChannel_set_delayed_payment_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24898 export function AcceptChannel_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
24899 if(!isWasmInitialized) {
24900 throw new Error("initializeWasm() must be awaited first!");
24902 const nativeResponseValue = wasm.TS_AcceptChannel_set_delayed_payment_basepoint(this_ptr, val);
24903 // debug statements here
24905 // struct LDKPublicKey AcceptChannel_get_htlc_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
24907 export function AcceptChannel_get_htlc_basepoint(this_ptr: bigint): number {
24908 if(!isWasmInitialized) {
24909 throw new Error("initializeWasm() must be awaited first!");
24911 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_basepoint(this_ptr);
24912 return nativeResponseValue;
24914 // void AcceptChannel_set_htlc_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24916 export function AcceptChannel_set_htlc_basepoint(this_ptr: bigint, val: number): void {
24917 if(!isWasmInitialized) {
24918 throw new Error("initializeWasm() must be awaited first!");
24920 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_basepoint(this_ptr, val);
24921 // debug statements here
24923 // struct LDKPublicKey AcceptChannel_get_first_per_commitment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
24925 export function AcceptChannel_get_first_per_commitment_point(this_ptr: bigint): number {
24926 if(!isWasmInitialized) {
24927 throw new Error("initializeWasm() must be awaited first!");
24929 const nativeResponseValue = wasm.TS_AcceptChannel_get_first_per_commitment_point(this_ptr);
24930 return nativeResponseValue;
24932 // void AcceptChannel_set_first_per_commitment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24934 export function AcceptChannel_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
24935 if(!isWasmInitialized) {
24936 throw new Error("initializeWasm() must be awaited first!");
24938 const nativeResponseValue = wasm.TS_AcceptChannel_set_first_per_commitment_point(this_ptr, val);
24939 // debug statements here
24941 // struct LDKChannelTypeFeatures AcceptChannel_get_channel_type(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
24943 export function AcceptChannel_get_channel_type(this_ptr: bigint): bigint {
24944 if(!isWasmInitialized) {
24945 throw new Error("initializeWasm() must be awaited first!");
24947 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_type(this_ptr);
24948 return nativeResponseValue;
24950 // void AcceptChannel_set_channel_type(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
24952 export function AcceptChannel_set_channel_type(this_ptr: bigint, val: bigint): void {
24953 if(!isWasmInitialized) {
24954 throw new Error("initializeWasm() must be awaited first!");
24956 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_type(this_ptr, val);
24957 // debug statements here
24959 // uint64_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg);
24961 export function AcceptChannel_clone_ptr(arg: bigint): bigint {
24962 if(!isWasmInitialized) {
24963 throw new Error("initializeWasm() must be awaited first!");
24965 const nativeResponseValue = wasm.TS_AcceptChannel_clone_ptr(arg);
24966 return nativeResponseValue;
24968 // struct LDKAcceptChannel AcceptChannel_clone(const struct LDKAcceptChannel *NONNULL_PTR orig);
24970 export function AcceptChannel_clone(orig: bigint): bigint {
24971 if(!isWasmInitialized) {
24972 throw new Error("initializeWasm() must be awaited first!");
24974 const nativeResponseValue = wasm.TS_AcceptChannel_clone(orig);
24975 return nativeResponseValue;
24977 // bool AcceptChannel_eq(const struct LDKAcceptChannel *NONNULL_PTR a, const struct LDKAcceptChannel *NONNULL_PTR b);
24979 export function AcceptChannel_eq(a: bigint, b: bigint): boolean {
24980 if(!isWasmInitialized) {
24981 throw new Error("initializeWasm() must be awaited first!");
24983 const nativeResponseValue = wasm.TS_AcceptChannel_eq(a, b);
24984 return nativeResponseValue;
24986 // void FundingCreated_free(struct LDKFundingCreated this_obj);
24988 export function FundingCreated_free(this_obj: bigint): void {
24989 if(!isWasmInitialized) {
24990 throw new Error("initializeWasm() must be awaited first!");
24992 const nativeResponseValue = wasm.TS_FundingCreated_free(this_obj);
24993 // debug statements here
24995 // const uint8_t (*FundingCreated_get_temporary_channel_id(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
24997 export function FundingCreated_get_temporary_channel_id(this_ptr: bigint): number {
24998 if(!isWasmInitialized) {
24999 throw new Error("initializeWasm() must be awaited first!");
25001 const nativeResponseValue = wasm.TS_FundingCreated_get_temporary_channel_id(this_ptr);
25002 return nativeResponseValue;
25004 // void FundingCreated_set_temporary_channel_id(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25006 export function FundingCreated_set_temporary_channel_id(this_ptr: bigint, val: number): void {
25007 if(!isWasmInitialized) {
25008 throw new Error("initializeWasm() must be awaited first!");
25010 const nativeResponseValue = wasm.TS_FundingCreated_set_temporary_channel_id(this_ptr, val);
25011 // debug statements here
25013 // const uint8_t (*FundingCreated_get_funding_txid(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
25015 export function FundingCreated_get_funding_txid(this_ptr: bigint): number {
25016 if(!isWasmInitialized) {
25017 throw new Error("initializeWasm() must be awaited first!");
25019 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_txid(this_ptr);
25020 return nativeResponseValue;
25022 // void FundingCreated_set_funding_txid(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25024 export function FundingCreated_set_funding_txid(this_ptr: bigint, val: number): void {
25025 if(!isWasmInitialized) {
25026 throw new Error("initializeWasm() must be awaited first!");
25028 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_txid(this_ptr, val);
25029 // debug statements here
25031 // uint16_t FundingCreated_get_funding_output_index(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
25033 export function FundingCreated_get_funding_output_index(this_ptr: bigint): number {
25034 if(!isWasmInitialized) {
25035 throw new Error("initializeWasm() must be awaited first!");
25037 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_output_index(this_ptr);
25038 return nativeResponseValue;
25040 // void FundingCreated_set_funding_output_index(struct LDKFundingCreated *NONNULL_PTR this_ptr, uint16_t val);
25042 export function FundingCreated_set_funding_output_index(this_ptr: bigint, val: number): void {
25043 if(!isWasmInitialized) {
25044 throw new Error("initializeWasm() must be awaited first!");
25046 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_output_index(this_ptr, val);
25047 // debug statements here
25049 // struct LDKSignature FundingCreated_get_signature(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
25051 export function FundingCreated_get_signature(this_ptr: bigint): number {
25052 if(!isWasmInitialized) {
25053 throw new Error("initializeWasm() must be awaited first!");
25055 const nativeResponseValue = wasm.TS_FundingCreated_get_signature(this_ptr);
25056 return nativeResponseValue;
25058 // void FundingCreated_set_signature(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKSignature val);
25060 export function FundingCreated_set_signature(this_ptr: bigint, val: number): void {
25061 if(!isWasmInitialized) {
25062 throw new Error("initializeWasm() must be awaited first!");
25064 const nativeResponseValue = wasm.TS_FundingCreated_set_signature(this_ptr, val);
25065 // debug statements here
25067 // 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);
25069 export function FundingCreated_new(temporary_channel_id_arg: number, funding_txid_arg: number, funding_output_index_arg: number, signature_arg: number): bigint {
25070 if(!isWasmInitialized) {
25071 throw new Error("initializeWasm() must be awaited first!");
25073 const nativeResponseValue = wasm.TS_FundingCreated_new(temporary_channel_id_arg, funding_txid_arg, funding_output_index_arg, signature_arg);
25074 return nativeResponseValue;
25076 // uint64_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg);
25078 export function FundingCreated_clone_ptr(arg: bigint): bigint {
25079 if(!isWasmInitialized) {
25080 throw new Error("initializeWasm() must be awaited first!");
25082 const nativeResponseValue = wasm.TS_FundingCreated_clone_ptr(arg);
25083 return nativeResponseValue;
25085 // struct LDKFundingCreated FundingCreated_clone(const struct LDKFundingCreated *NONNULL_PTR orig);
25087 export function FundingCreated_clone(orig: bigint): bigint {
25088 if(!isWasmInitialized) {
25089 throw new Error("initializeWasm() must be awaited first!");
25091 const nativeResponseValue = wasm.TS_FundingCreated_clone(orig);
25092 return nativeResponseValue;
25094 // bool FundingCreated_eq(const struct LDKFundingCreated *NONNULL_PTR a, const struct LDKFundingCreated *NONNULL_PTR b);
25096 export function FundingCreated_eq(a: bigint, b: bigint): boolean {
25097 if(!isWasmInitialized) {
25098 throw new Error("initializeWasm() must be awaited first!");
25100 const nativeResponseValue = wasm.TS_FundingCreated_eq(a, b);
25101 return nativeResponseValue;
25103 // void FundingSigned_free(struct LDKFundingSigned this_obj);
25105 export function FundingSigned_free(this_obj: bigint): void {
25106 if(!isWasmInitialized) {
25107 throw new Error("initializeWasm() must be awaited first!");
25109 const nativeResponseValue = wasm.TS_FundingSigned_free(this_obj);
25110 // debug statements here
25112 // const uint8_t (*FundingSigned_get_channel_id(const struct LDKFundingSigned *NONNULL_PTR this_ptr))[32];
25114 export function FundingSigned_get_channel_id(this_ptr: bigint): number {
25115 if(!isWasmInitialized) {
25116 throw new Error("initializeWasm() must be awaited first!");
25118 const nativeResponseValue = wasm.TS_FundingSigned_get_channel_id(this_ptr);
25119 return nativeResponseValue;
25121 // void FundingSigned_set_channel_id(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25123 export function FundingSigned_set_channel_id(this_ptr: bigint, val: number): void {
25124 if(!isWasmInitialized) {
25125 throw new Error("initializeWasm() must be awaited first!");
25127 const nativeResponseValue = wasm.TS_FundingSigned_set_channel_id(this_ptr, val);
25128 // debug statements here
25130 // struct LDKSignature FundingSigned_get_signature(const struct LDKFundingSigned *NONNULL_PTR this_ptr);
25132 export function FundingSigned_get_signature(this_ptr: bigint): number {
25133 if(!isWasmInitialized) {
25134 throw new Error("initializeWasm() must be awaited first!");
25136 const nativeResponseValue = wasm.TS_FundingSigned_get_signature(this_ptr);
25137 return nativeResponseValue;
25139 // void FundingSigned_set_signature(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
25141 export function FundingSigned_set_signature(this_ptr: bigint, val: number): void {
25142 if(!isWasmInitialized) {
25143 throw new Error("initializeWasm() must be awaited first!");
25145 const nativeResponseValue = wasm.TS_FundingSigned_set_signature(this_ptr, val);
25146 // debug statements here
25148 // MUST_USE_RES struct LDKFundingSigned FundingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg);
25150 export function FundingSigned_new(channel_id_arg: number, signature_arg: number): bigint {
25151 if(!isWasmInitialized) {
25152 throw new Error("initializeWasm() must be awaited first!");
25154 const nativeResponseValue = wasm.TS_FundingSigned_new(channel_id_arg, signature_arg);
25155 return nativeResponseValue;
25157 // uint64_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg);
25159 export function FundingSigned_clone_ptr(arg: bigint): bigint {
25160 if(!isWasmInitialized) {
25161 throw new Error("initializeWasm() must be awaited first!");
25163 const nativeResponseValue = wasm.TS_FundingSigned_clone_ptr(arg);
25164 return nativeResponseValue;
25166 // struct LDKFundingSigned FundingSigned_clone(const struct LDKFundingSigned *NONNULL_PTR orig);
25168 export function FundingSigned_clone(orig: bigint): bigint {
25169 if(!isWasmInitialized) {
25170 throw new Error("initializeWasm() must be awaited first!");
25172 const nativeResponseValue = wasm.TS_FundingSigned_clone(orig);
25173 return nativeResponseValue;
25175 // bool FundingSigned_eq(const struct LDKFundingSigned *NONNULL_PTR a, const struct LDKFundingSigned *NONNULL_PTR b);
25177 export function FundingSigned_eq(a: bigint, b: bigint): boolean {
25178 if(!isWasmInitialized) {
25179 throw new Error("initializeWasm() must be awaited first!");
25181 const nativeResponseValue = wasm.TS_FundingSigned_eq(a, b);
25182 return nativeResponseValue;
25184 // void ChannelReady_free(struct LDKChannelReady this_obj);
25186 export function ChannelReady_free(this_obj: bigint): void {
25187 if(!isWasmInitialized) {
25188 throw new Error("initializeWasm() must be awaited first!");
25190 const nativeResponseValue = wasm.TS_ChannelReady_free(this_obj);
25191 // debug statements here
25193 // const uint8_t (*ChannelReady_get_channel_id(const struct LDKChannelReady *NONNULL_PTR this_ptr))[32];
25195 export function ChannelReady_get_channel_id(this_ptr: bigint): number {
25196 if(!isWasmInitialized) {
25197 throw new Error("initializeWasm() must be awaited first!");
25199 const nativeResponseValue = wasm.TS_ChannelReady_get_channel_id(this_ptr);
25200 return nativeResponseValue;
25202 // void ChannelReady_set_channel_id(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25204 export function ChannelReady_set_channel_id(this_ptr: bigint, val: number): void {
25205 if(!isWasmInitialized) {
25206 throw new Error("initializeWasm() must be awaited first!");
25208 const nativeResponseValue = wasm.TS_ChannelReady_set_channel_id(this_ptr, val);
25209 // debug statements here
25211 // struct LDKPublicKey ChannelReady_get_next_per_commitment_point(const struct LDKChannelReady *NONNULL_PTR this_ptr);
25213 export function ChannelReady_get_next_per_commitment_point(this_ptr: bigint): number {
25214 if(!isWasmInitialized) {
25215 throw new Error("initializeWasm() must be awaited first!");
25217 const nativeResponseValue = wasm.TS_ChannelReady_get_next_per_commitment_point(this_ptr);
25218 return nativeResponseValue;
25220 // void ChannelReady_set_next_per_commitment_point(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25222 export function ChannelReady_set_next_per_commitment_point(this_ptr: bigint, val: number): void {
25223 if(!isWasmInitialized) {
25224 throw new Error("initializeWasm() must be awaited first!");
25226 const nativeResponseValue = wasm.TS_ChannelReady_set_next_per_commitment_point(this_ptr, val);
25227 // debug statements here
25229 // struct LDKCOption_u64Z ChannelReady_get_short_channel_id_alias(const struct LDKChannelReady *NONNULL_PTR this_ptr);
25231 export function ChannelReady_get_short_channel_id_alias(this_ptr: bigint): bigint {
25232 if(!isWasmInitialized) {
25233 throw new Error("initializeWasm() must be awaited first!");
25235 const nativeResponseValue = wasm.TS_ChannelReady_get_short_channel_id_alias(this_ptr);
25236 return nativeResponseValue;
25238 // void ChannelReady_set_short_channel_id_alias(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
25240 export function ChannelReady_set_short_channel_id_alias(this_ptr: bigint, val: bigint): void {
25241 if(!isWasmInitialized) {
25242 throw new Error("initializeWasm() must be awaited first!");
25244 const nativeResponseValue = wasm.TS_ChannelReady_set_short_channel_id_alias(this_ptr, val);
25245 // debug statements here
25247 // 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);
25249 export function ChannelReady_new(channel_id_arg: number, next_per_commitment_point_arg: number, short_channel_id_alias_arg: bigint): bigint {
25250 if(!isWasmInitialized) {
25251 throw new Error("initializeWasm() must be awaited first!");
25253 const nativeResponseValue = wasm.TS_ChannelReady_new(channel_id_arg, next_per_commitment_point_arg, short_channel_id_alias_arg);
25254 return nativeResponseValue;
25256 // uint64_t ChannelReady_clone_ptr(LDKChannelReady *NONNULL_PTR arg);
25258 export function ChannelReady_clone_ptr(arg: bigint): bigint {
25259 if(!isWasmInitialized) {
25260 throw new Error("initializeWasm() must be awaited first!");
25262 const nativeResponseValue = wasm.TS_ChannelReady_clone_ptr(arg);
25263 return nativeResponseValue;
25265 // struct LDKChannelReady ChannelReady_clone(const struct LDKChannelReady *NONNULL_PTR orig);
25267 export function ChannelReady_clone(orig: bigint): bigint {
25268 if(!isWasmInitialized) {
25269 throw new Error("initializeWasm() must be awaited first!");
25271 const nativeResponseValue = wasm.TS_ChannelReady_clone(orig);
25272 return nativeResponseValue;
25274 // bool ChannelReady_eq(const struct LDKChannelReady *NONNULL_PTR a, const struct LDKChannelReady *NONNULL_PTR b);
25276 export function ChannelReady_eq(a: bigint, b: bigint): boolean {
25277 if(!isWasmInitialized) {
25278 throw new Error("initializeWasm() must be awaited first!");
25280 const nativeResponseValue = wasm.TS_ChannelReady_eq(a, b);
25281 return nativeResponseValue;
25283 // void Shutdown_free(struct LDKShutdown this_obj);
25285 export function Shutdown_free(this_obj: bigint): void {
25286 if(!isWasmInitialized) {
25287 throw new Error("initializeWasm() must be awaited first!");
25289 const nativeResponseValue = wasm.TS_Shutdown_free(this_obj);
25290 // debug statements here
25292 // const uint8_t (*Shutdown_get_channel_id(const struct LDKShutdown *NONNULL_PTR this_ptr))[32];
25294 export function Shutdown_get_channel_id(this_ptr: bigint): number {
25295 if(!isWasmInitialized) {
25296 throw new Error("initializeWasm() must be awaited first!");
25298 const nativeResponseValue = wasm.TS_Shutdown_get_channel_id(this_ptr);
25299 return nativeResponseValue;
25301 // void Shutdown_set_channel_id(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25303 export function Shutdown_set_channel_id(this_ptr: bigint, val: number): void {
25304 if(!isWasmInitialized) {
25305 throw new Error("initializeWasm() must be awaited first!");
25307 const nativeResponseValue = wasm.TS_Shutdown_set_channel_id(this_ptr, val);
25308 // debug statements here
25310 // struct LDKu8slice Shutdown_get_scriptpubkey(const struct LDKShutdown *NONNULL_PTR this_ptr);
25312 export function Shutdown_get_scriptpubkey(this_ptr: bigint): number {
25313 if(!isWasmInitialized) {
25314 throw new Error("initializeWasm() must be awaited first!");
25316 const nativeResponseValue = wasm.TS_Shutdown_get_scriptpubkey(this_ptr);
25317 return nativeResponseValue;
25319 // void Shutdown_set_scriptpubkey(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
25321 export function Shutdown_set_scriptpubkey(this_ptr: bigint, val: number): void {
25322 if(!isWasmInitialized) {
25323 throw new Error("initializeWasm() must be awaited first!");
25325 const nativeResponseValue = wasm.TS_Shutdown_set_scriptpubkey(this_ptr, val);
25326 // debug statements here
25328 // MUST_USE_RES struct LDKShutdown Shutdown_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z scriptpubkey_arg);
25330 export function Shutdown_new(channel_id_arg: number, scriptpubkey_arg: number): bigint {
25331 if(!isWasmInitialized) {
25332 throw new Error("initializeWasm() must be awaited first!");
25334 const nativeResponseValue = wasm.TS_Shutdown_new(channel_id_arg, scriptpubkey_arg);
25335 return nativeResponseValue;
25337 // uint64_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg);
25339 export function Shutdown_clone_ptr(arg: bigint): bigint {
25340 if(!isWasmInitialized) {
25341 throw new Error("initializeWasm() must be awaited first!");
25343 const nativeResponseValue = wasm.TS_Shutdown_clone_ptr(arg);
25344 return nativeResponseValue;
25346 // struct LDKShutdown Shutdown_clone(const struct LDKShutdown *NONNULL_PTR orig);
25348 export function Shutdown_clone(orig: bigint): bigint {
25349 if(!isWasmInitialized) {
25350 throw new Error("initializeWasm() must be awaited first!");
25352 const nativeResponseValue = wasm.TS_Shutdown_clone(orig);
25353 return nativeResponseValue;
25355 // bool Shutdown_eq(const struct LDKShutdown *NONNULL_PTR a, const struct LDKShutdown *NONNULL_PTR b);
25357 export function Shutdown_eq(a: bigint, b: bigint): boolean {
25358 if(!isWasmInitialized) {
25359 throw new Error("initializeWasm() must be awaited first!");
25361 const nativeResponseValue = wasm.TS_Shutdown_eq(a, b);
25362 return nativeResponseValue;
25364 // void ClosingSignedFeeRange_free(struct LDKClosingSignedFeeRange this_obj);
25366 export function ClosingSignedFeeRange_free(this_obj: bigint): void {
25367 if(!isWasmInitialized) {
25368 throw new Error("initializeWasm() must be awaited first!");
25370 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_free(this_obj);
25371 // debug statements here
25373 // uint64_t ClosingSignedFeeRange_get_min_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
25375 export function ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr: bigint): bigint {
25376 if(!isWasmInitialized) {
25377 throw new Error("initializeWasm() must be awaited first!");
25379 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr);
25380 return nativeResponseValue;
25382 // void ClosingSignedFeeRange_set_min_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
25384 export function ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr: bigint, val: bigint): void {
25385 if(!isWasmInitialized) {
25386 throw new Error("initializeWasm() must be awaited first!");
25388 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr, val);
25389 // debug statements here
25391 // uint64_t ClosingSignedFeeRange_get_max_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
25393 export function ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr: bigint): bigint {
25394 if(!isWasmInitialized) {
25395 throw new Error("initializeWasm() must be awaited first!");
25397 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr);
25398 return nativeResponseValue;
25400 // void ClosingSignedFeeRange_set_max_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
25402 export function ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr: bigint, val: bigint): void {
25403 if(!isWasmInitialized) {
25404 throw new Error("initializeWasm() must be awaited first!");
25406 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr, val);
25407 // debug statements here
25409 // MUST_USE_RES struct LDKClosingSignedFeeRange ClosingSignedFeeRange_new(uint64_t min_fee_satoshis_arg, uint64_t max_fee_satoshis_arg);
25411 export function ClosingSignedFeeRange_new(min_fee_satoshis_arg: bigint, max_fee_satoshis_arg: bigint): bigint {
25412 if(!isWasmInitialized) {
25413 throw new Error("initializeWasm() must be awaited first!");
25415 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
25416 return nativeResponseValue;
25418 // uint64_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg);
25420 export function ClosingSignedFeeRange_clone_ptr(arg: bigint): bigint {
25421 if(!isWasmInitialized) {
25422 throw new Error("initializeWasm() must be awaited first!");
25424 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone_ptr(arg);
25425 return nativeResponseValue;
25427 // struct LDKClosingSignedFeeRange ClosingSignedFeeRange_clone(const struct LDKClosingSignedFeeRange *NONNULL_PTR orig);
25429 export function ClosingSignedFeeRange_clone(orig: bigint): bigint {
25430 if(!isWasmInitialized) {
25431 throw new Error("initializeWasm() must be awaited first!");
25433 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone(orig);
25434 return nativeResponseValue;
25436 // bool ClosingSignedFeeRange_eq(const struct LDKClosingSignedFeeRange *NONNULL_PTR a, const struct LDKClosingSignedFeeRange *NONNULL_PTR b);
25438 export function ClosingSignedFeeRange_eq(a: bigint, b: bigint): boolean {
25439 if(!isWasmInitialized) {
25440 throw new Error("initializeWasm() must be awaited first!");
25442 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_eq(a, b);
25443 return nativeResponseValue;
25445 // void ClosingSigned_free(struct LDKClosingSigned this_obj);
25447 export function ClosingSigned_free(this_obj: bigint): void {
25448 if(!isWasmInitialized) {
25449 throw new Error("initializeWasm() must be awaited first!");
25451 const nativeResponseValue = wasm.TS_ClosingSigned_free(this_obj);
25452 // debug statements here
25454 // const uint8_t (*ClosingSigned_get_channel_id(const struct LDKClosingSigned *NONNULL_PTR this_ptr))[32];
25456 export function ClosingSigned_get_channel_id(this_ptr: bigint): number {
25457 if(!isWasmInitialized) {
25458 throw new Error("initializeWasm() must be awaited first!");
25460 const nativeResponseValue = wasm.TS_ClosingSigned_get_channel_id(this_ptr);
25461 return nativeResponseValue;
25463 // void ClosingSigned_set_channel_id(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25465 export function ClosingSigned_set_channel_id(this_ptr: bigint, val: number): void {
25466 if(!isWasmInitialized) {
25467 throw new Error("initializeWasm() must be awaited first!");
25469 const nativeResponseValue = wasm.TS_ClosingSigned_set_channel_id(this_ptr, val);
25470 // debug statements here
25472 // uint64_t ClosingSigned_get_fee_satoshis(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
25474 export function ClosingSigned_get_fee_satoshis(this_ptr: bigint): bigint {
25475 if(!isWasmInitialized) {
25476 throw new Error("initializeWasm() must be awaited first!");
25478 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_satoshis(this_ptr);
25479 return nativeResponseValue;
25481 // void ClosingSigned_set_fee_satoshis(struct LDKClosingSigned *NONNULL_PTR this_ptr, uint64_t val);
25483 export function ClosingSigned_set_fee_satoshis(this_ptr: bigint, val: bigint): void {
25484 if(!isWasmInitialized) {
25485 throw new Error("initializeWasm() must be awaited first!");
25487 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_satoshis(this_ptr, val);
25488 // debug statements here
25490 // struct LDKSignature ClosingSigned_get_signature(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
25492 export function ClosingSigned_get_signature(this_ptr: bigint): number {
25493 if(!isWasmInitialized) {
25494 throw new Error("initializeWasm() must be awaited first!");
25496 const nativeResponseValue = wasm.TS_ClosingSigned_get_signature(this_ptr);
25497 return nativeResponseValue;
25499 // void ClosingSigned_set_signature(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
25501 export function ClosingSigned_set_signature(this_ptr: bigint, val: number): void {
25502 if(!isWasmInitialized) {
25503 throw new Error("initializeWasm() must be awaited first!");
25505 const nativeResponseValue = wasm.TS_ClosingSigned_set_signature(this_ptr, val);
25506 // debug statements here
25508 // struct LDKClosingSignedFeeRange ClosingSigned_get_fee_range(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
25510 export function ClosingSigned_get_fee_range(this_ptr: bigint): bigint {
25511 if(!isWasmInitialized) {
25512 throw new Error("initializeWasm() must be awaited first!");
25514 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_range(this_ptr);
25515 return nativeResponseValue;
25517 // void ClosingSigned_set_fee_range(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKClosingSignedFeeRange val);
25519 export function ClosingSigned_set_fee_range(this_ptr: bigint, val: bigint): void {
25520 if(!isWasmInitialized) {
25521 throw new Error("initializeWasm() must be awaited first!");
25523 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_range(this_ptr, val);
25524 // debug statements here
25526 // 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);
25528 export function ClosingSigned_new(channel_id_arg: number, fee_satoshis_arg: bigint, signature_arg: number, fee_range_arg: bigint): bigint {
25529 if(!isWasmInitialized) {
25530 throw new Error("initializeWasm() must be awaited first!");
25532 const nativeResponseValue = wasm.TS_ClosingSigned_new(channel_id_arg, fee_satoshis_arg, signature_arg, fee_range_arg);
25533 return nativeResponseValue;
25535 // uint64_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg);
25537 export function ClosingSigned_clone_ptr(arg: bigint): bigint {
25538 if(!isWasmInitialized) {
25539 throw new Error("initializeWasm() must be awaited first!");
25541 const nativeResponseValue = wasm.TS_ClosingSigned_clone_ptr(arg);
25542 return nativeResponseValue;
25544 // struct LDKClosingSigned ClosingSigned_clone(const struct LDKClosingSigned *NONNULL_PTR orig);
25546 export function ClosingSigned_clone(orig: bigint): bigint {
25547 if(!isWasmInitialized) {
25548 throw new Error("initializeWasm() must be awaited first!");
25550 const nativeResponseValue = wasm.TS_ClosingSigned_clone(orig);
25551 return nativeResponseValue;
25553 // bool ClosingSigned_eq(const struct LDKClosingSigned *NONNULL_PTR a, const struct LDKClosingSigned *NONNULL_PTR b);
25555 export function ClosingSigned_eq(a: bigint, b: bigint): boolean {
25556 if(!isWasmInitialized) {
25557 throw new Error("initializeWasm() must be awaited first!");
25559 const nativeResponseValue = wasm.TS_ClosingSigned_eq(a, b);
25560 return nativeResponseValue;
25562 // void UpdateAddHTLC_free(struct LDKUpdateAddHTLC this_obj);
25564 export function UpdateAddHTLC_free(this_obj: bigint): void {
25565 if(!isWasmInitialized) {
25566 throw new Error("initializeWasm() must be awaited first!");
25568 const nativeResponseValue = wasm.TS_UpdateAddHTLC_free(this_obj);
25569 // debug statements here
25571 // const uint8_t (*UpdateAddHTLC_get_channel_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
25573 export function UpdateAddHTLC_get_channel_id(this_ptr: bigint): number {
25574 if(!isWasmInitialized) {
25575 throw new Error("initializeWasm() must be awaited first!");
25577 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_channel_id(this_ptr);
25578 return nativeResponseValue;
25580 // void UpdateAddHTLC_set_channel_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25582 export function UpdateAddHTLC_set_channel_id(this_ptr: bigint, val: number): void {
25583 if(!isWasmInitialized) {
25584 throw new Error("initializeWasm() must be awaited first!");
25586 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_channel_id(this_ptr, val);
25587 // debug statements here
25589 // uint64_t UpdateAddHTLC_get_htlc_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
25591 export function UpdateAddHTLC_get_htlc_id(this_ptr: bigint): bigint {
25592 if(!isWasmInitialized) {
25593 throw new Error("initializeWasm() must be awaited first!");
25595 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_htlc_id(this_ptr);
25596 return nativeResponseValue;
25598 // void UpdateAddHTLC_set_htlc_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
25600 export function UpdateAddHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
25601 if(!isWasmInitialized) {
25602 throw new Error("initializeWasm() must be awaited first!");
25604 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_htlc_id(this_ptr, val);
25605 // debug statements here
25607 // uint64_t UpdateAddHTLC_get_amount_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
25609 export function UpdateAddHTLC_get_amount_msat(this_ptr: bigint): bigint {
25610 if(!isWasmInitialized) {
25611 throw new Error("initializeWasm() must be awaited first!");
25613 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_amount_msat(this_ptr);
25614 return nativeResponseValue;
25616 // void UpdateAddHTLC_set_amount_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
25618 export function UpdateAddHTLC_set_amount_msat(this_ptr: bigint, val: bigint): void {
25619 if(!isWasmInitialized) {
25620 throw new Error("initializeWasm() must be awaited first!");
25622 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_amount_msat(this_ptr, val);
25623 // debug statements here
25625 // const uint8_t (*UpdateAddHTLC_get_payment_hash(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
25627 export function UpdateAddHTLC_get_payment_hash(this_ptr: bigint): number {
25628 if(!isWasmInitialized) {
25629 throw new Error("initializeWasm() must be awaited first!");
25631 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_payment_hash(this_ptr);
25632 return nativeResponseValue;
25634 // void UpdateAddHTLC_set_payment_hash(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25636 export function UpdateAddHTLC_set_payment_hash(this_ptr: bigint, val: number): void {
25637 if(!isWasmInitialized) {
25638 throw new Error("initializeWasm() must be awaited first!");
25640 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_payment_hash(this_ptr, val);
25641 // debug statements here
25643 // uint32_t UpdateAddHTLC_get_cltv_expiry(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
25645 export function UpdateAddHTLC_get_cltv_expiry(this_ptr: bigint): number {
25646 if(!isWasmInitialized) {
25647 throw new Error("initializeWasm() must be awaited first!");
25649 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_cltv_expiry(this_ptr);
25650 return nativeResponseValue;
25652 // void UpdateAddHTLC_set_cltv_expiry(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint32_t val);
25654 export function UpdateAddHTLC_set_cltv_expiry(this_ptr: bigint, val: number): void {
25655 if(!isWasmInitialized) {
25656 throw new Error("initializeWasm() must be awaited first!");
25658 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_cltv_expiry(this_ptr, val);
25659 // debug statements here
25661 // uint64_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg);
25663 export function UpdateAddHTLC_clone_ptr(arg: bigint): bigint {
25664 if(!isWasmInitialized) {
25665 throw new Error("initializeWasm() must be awaited first!");
25667 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone_ptr(arg);
25668 return nativeResponseValue;
25670 // struct LDKUpdateAddHTLC UpdateAddHTLC_clone(const struct LDKUpdateAddHTLC *NONNULL_PTR orig);
25672 export function UpdateAddHTLC_clone(orig: bigint): bigint {
25673 if(!isWasmInitialized) {
25674 throw new Error("initializeWasm() must be awaited first!");
25676 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone(orig);
25677 return nativeResponseValue;
25679 // bool UpdateAddHTLC_eq(const struct LDKUpdateAddHTLC *NONNULL_PTR a, const struct LDKUpdateAddHTLC *NONNULL_PTR b);
25681 export function UpdateAddHTLC_eq(a: bigint, b: bigint): boolean {
25682 if(!isWasmInitialized) {
25683 throw new Error("initializeWasm() must be awaited first!");
25685 const nativeResponseValue = wasm.TS_UpdateAddHTLC_eq(a, b);
25686 return nativeResponseValue;
25688 // void OnionMessage_free(struct LDKOnionMessage this_obj);
25690 export function OnionMessage_free(this_obj: bigint): void {
25691 if(!isWasmInitialized) {
25692 throw new Error("initializeWasm() must be awaited first!");
25694 const nativeResponseValue = wasm.TS_OnionMessage_free(this_obj);
25695 // debug statements here
25697 // struct LDKPublicKey OnionMessage_get_blinding_point(const struct LDKOnionMessage *NONNULL_PTR this_ptr);
25699 export function OnionMessage_get_blinding_point(this_ptr: bigint): number {
25700 if(!isWasmInitialized) {
25701 throw new Error("initializeWasm() must be awaited first!");
25703 const nativeResponseValue = wasm.TS_OnionMessage_get_blinding_point(this_ptr);
25704 return nativeResponseValue;
25706 // void OnionMessage_set_blinding_point(struct LDKOnionMessage *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25708 export function OnionMessage_set_blinding_point(this_ptr: bigint, val: number): void {
25709 if(!isWasmInitialized) {
25710 throw new Error("initializeWasm() must be awaited first!");
25712 const nativeResponseValue = wasm.TS_OnionMessage_set_blinding_point(this_ptr, val);
25713 // debug statements here
25715 // uint64_t OnionMessage_clone_ptr(LDKOnionMessage *NONNULL_PTR arg);
25717 export function OnionMessage_clone_ptr(arg: bigint): bigint {
25718 if(!isWasmInitialized) {
25719 throw new Error("initializeWasm() must be awaited first!");
25721 const nativeResponseValue = wasm.TS_OnionMessage_clone_ptr(arg);
25722 return nativeResponseValue;
25724 // struct LDKOnionMessage OnionMessage_clone(const struct LDKOnionMessage *NONNULL_PTR orig);
25726 export function OnionMessage_clone(orig: bigint): bigint {
25727 if(!isWasmInitialized) {
25728 throw new Error("initializeWasm() must be awaited first!");
25730 const nativeResponseValue = wasm.TS_OnionMessage_clone(orig);
25731 return nativeResponseValue;
25733 // bool OnionMessage_eq(const struct LDKOnionMessage *NONNULL_PTR a, const struct LDKOnionMessage *NONNULL_PTR b);
25735 export function OnionMessage_eq(a: bigint, b: bigint): boolean {
25736 if(!isWasmInitialized) {
25737 throw new Error("initializeWasm() must be awaited first!");
25739 const nativeResponseValue = wasm.TS_OnionMessage_eq(a, b);
25740 return nativeResponseValue;
25742 // void UpdateFulfillHTLC_free(struct LDKUpdateFulfillHTLC this_obj);
25744 export function UpdateFulfillHTLC_free(this_obj: bigint): void {
25745 if(!isWasmInitialized) {
25746 throw new Error("initializeWasm() must be awaited first!");
25748 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_free(this_obj);
25749 // debug statements here
25751 // const uint8_t (*UpdateFulfillHTLC_get_channel_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
25753 export function UpdateFulfillHTLC_get_channel_id(this_ptr: bigint): number {
25754 if(!isWasmInitialized) {
25755 throw new Error("initializeWasm() must be awaited first!");
25757 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_channel_id(this_ptr);
25758 return nativeResponseValue;
25760 // void UpdateFulfillHTLC_set_channel_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25762 export function UpdateFulfillHTLC_set_channel_id(this_ptr: bigint, val: number): void {
25763 if(!isWasmInitialized) {
25764 throw new Error("initializeWasm() must be awaited first!");
25766 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_channel_id(this_ptr, val);
25767 // debug statements here
25769 // uint64_t UpdateFulfillHTLC_get_htlc_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr);
25771 export function UpdateFulfillHTLC_get_htlc_id(this_ptr: bigint): bigint {
25772 if(!isWasmInitialized) {
25773 throw new Error("initializeWasm() must be awaited first!");
25775 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_htlc_id(this_ptr);
25776 return nativeResponseValue;
25778 // void UpdateFulfillHTLC_set_htlc_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, uint64_t val);
25780 export function UpdateFulfillHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
25781 if(!isWasmInitialized) {
25782 throw new Error("initializeWasm() must be awaited first!");
25784 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_htlc_id(this_ptr, val);
25785 // debug statements here
25787 // const uint8_t (*UpdateFulfillHTLC_get_payment_preimage(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
25789 export function UpdateFulfillHTLC_get_payment_preimage(this_ptr: bigint): number {
25790 if(!isWasmInitialized) {
25791 throw new Error("initializeWasm() must be awaited first!");
25793 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_payment_preimage(this_ptr);
25794 return nativeResponseValue;
25796 // void UpdateFulfillHTLC_set_payment_preimage(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25798 export function UpdateFulfillHTLC_set_payment_preimage(this_ptr: bigint, val: number): void {
25799 if(!isWasmInitialized) {
25800 throw new Error("initializeWasm() must be awaited first!");
25802 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_payment_preimage(this_ptr, val);
25803 // debug statements here
25805 // MUST_USE_RES struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t htlc_id_arg, struct LDKThirtyTwoBytes payment_preimage_arg);
25807 export function UpdateFulfillHTLC_new(channel_id_arg: number, htlc_id_arg: bigint, payment_preimage_arg: number): bigint {
25808 if(!isWasmInitialized) {
25809 throw new Error("initializeWasm() must be awaited first!");
25811 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_new(channel_id_arg, htlc_id_arg, payment_preimage_arg);
25812 return nativeResponseValue;
25814 // uint64_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg);
25816 export function UpdateFulfillHTLC_clone_ptr(arg: bigint): bigint {
25817 if(!isWasmInitialized) {
25818 throw new Error("initializeWasm() must be awaited first!");
25820 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone_ptr(arg);
25821 return nativeResponseValue;
25823 // struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_clone(const struct LDKUpdateFulfillHTLC *NONNULL_PTR orig);
25825 export function UpdateFulfillHTLC_clone(orig: bigint): bigint {
25826 if(!isWasmInitialized) {
25827 throw new Error("initializeWasm() must be awaited first!");
25829 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone(orig);
25830 return nativeResponseValue;
25832 // bool UpdateFulfillHTLC_eq(const struct LDKUpdateFulfillHTLC *NONNULL_PTR a, const struct LDKUpdateFulfillHTLC *NONNULL_PTR b);
25834 export function UpdateFulfillHTLC_eq(a: bigint, b: bigint): boolean {
25835 if(!isWasmInitialized) {
25836 throw new Error("initializeWasm() must be awaited first!");
25838 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_eq(a, b);
25839 return nativeResponseValue;
25841 // void UpdateFailHTLC_free(struct LDKUpdateFailHTLC this_obj);
25843 export function UpdateFailHTLC_free(this_obj: bigint): void {
25844 if(!isWasmInitialized) {
25845 throw new Error("initializeWasm() must be awaited first!");
25847 const nativeResponseValue = wasm.TS_UpdateFailHTLC_free(this_obj);
25848 // debug statements here
25850 // const uint8_t (*UpdateFailHTLC_get_channel_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr))[32];
25852 export function UpdateFailHTLC_get_channel_id(this_ptr: bigint): number {
25853 if(!isWasmInitialized) {
25854 throw new Error("initializeWasm() must be awaited first!");
25856 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_channel_id(this_ptr);
25857 return nativeResponseValue;
25859 // void UpdateFailHTLC_set_channel_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25861 export function UpdateFailHTLC_set_channel_id(this_ptr: bigint, val: number): void {
25862 if(!isWasmInitialized) {
25863 throw new Error("initializeWasm() must be awaited first!");
25865 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_channel_id(this_ptr, val);
25866 // debug statements here
25868 // uint64_t UpdateFailHTLC_get_htlc_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr);
25870 export function UpdateFailHTLC_get_htlc_id(this_ptr: bigint): bigint {
25871 if(!isWasmInitialized) {
25872 throw new Error("initializeWasm() must be awaited first!");
25874 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_htlc_id(this_ptr);
25875 return nativeResponseValue;
25877 // void UpdateFailHTLC_set_htlc_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, uint64_t val);
25879 export function UpdateFailHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
25880 if(!isWasmInitialized) {
25881 throw new Error("initializeWasm() must be awaited first!");
25883 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_htlc_id(this_ptr, val);
25884 // debug statements here
25886 // uint64_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg);
25888 export function UpdateFailHTLC_clone_ptr(arg: bigint): bigint {
25889 if(!isWasmInitialized) {
25890 throw new Error("initializeWasm() must be awaited first!");
25892 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone_ptr(arg);
25893 return nativeResponseValue;
25895 // struct LDKUpdateFailHTLC UpdateFailHTLC_clone(const struct LDKUpdateFailHTLC *NONNULL_PTR orig);
25897 export function UpdateFailHTLC_clone(orig: bigint): bigint {
25898 if(!isWasmInitialized) {
25899 throw new Error("initializeWasm() must be awaited first!");
25901 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone(orig);
25902 return nativeResponseValue;
25904 // bool UpdateFailHTLC_eq(const struct LDKUpdateFailHTLC *NONNULL_PTR a, const struct LDKUpdateFailHTLC *NONNULL_PTR b);
25906 export function UpdateFailHTLC_eq(a: bigint, b: bigint): boolean {
25907 if(!isWasmInitialized) {
25908 throw new Error("initializeWasm() must be awaited first!");
25910 const nativeResponseValue = wasm.TS_UpdateFailHTLC_eq(a, b);
25911 return nativeResponseValue;
25913 // void UpdateFailMalformedHTLC_free(struct LDKUpdateFailMalformedHTLC this_obj);
25915 export function UpdateFailMalformedHTLC_free(this_obj: bigint): void {
25916 if(!isWasmInitialized) {
25917 throw new Error("initializeWasm() must be awaited first!");
25919 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_free(this_obj);
25920 // debug statements here
25922 // const uint8_t (*UpdateFailMalformedHTLC_get_channel_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr))[32];
25924 export function UpdateFailMalformedHTLC_get_channel_id(this_ptr: bigint): number {
25925 if(!isWasmInitialized) {
25926 throw new Error("initializeWasm() must be awaited first!");
25928 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_channel_id(this_ptr);
25929 return nativeResponseValue;
25931 // void UpdateFailMalformedHTLC_set_channel_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25933 export function UpdateFailMalformedHTLC_set_channel_id(this_ptr: bigint, val: number): void {
25934 if(!isWasmInitialized) {
25935 throw new Error("initializeWasm() must be awaited first!");
25937 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_channel_id(this_ptr, val);
25938 // debug statements here
25940 // uint64_t UpdateFailMalformedHTLC_get_htlc_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
25942 export function UpdateFailMalformedHTLC_get_htlc_id(this_ptr: bigint): bigint {
25943 if(!isWasmInitialized) {
25944 throw new Error("initializeWasm() must be awaited first!");
25946 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_htlc_id(this_ptr);
25947 return nativeResponseValue;
25949 // void UpdateFailMalformedHTLC_set_htlc_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint64_t val);
25951 export function UpdateFailMalformedHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
25952 if(!isWasmInitialized) {
25953 throw new Error("initializeWasm() must be awaited first!");
25955 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_htlc_id(this_ptr, val);
25956 // debug statements here
25958 // uint16_t UpdateFailMalformedHTLC_get_failure_code(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
25960 export function UpdateFailMalformedHTLC_get_failure_code(this_ptr: bigint): number {
25961 if(!isWasmInitialized) {
25962 throw new Error("initializeWasm() must be awaited first!");
25964 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_failure_code(this_ptr);
25965 return nativeResponseValue;
25967 // void UpdateFailMalformedHTLC_set_failure_code(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint16_t val);
25969 export function UpdateFailMalformedHTLC_set_failure_code(this_ptr: bigint, val: number): void {
25970 if(!isWasmInitialized) {
25971 throw new Error("initializeWasm() must be awaited first!");
25973 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_failure_code(this_ptr, val);
25974 // debug statements here
25976 // uint64_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg);
25978 export function UpdateFailMalformedHTLC_clone_ptr(arg: bigint): bigint {
25979 if(!isWasmInitialized) {
25980 throw new Error("initializeWasm() must be awaited first!");
25982 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone_ptr(arg);
25983 return nativeResponseValue;
25985 // struct LDKUpdateFailMalformedHTLC UpdateFailMalformedHTLC_clone(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR orig);
25987 export function UpdateFailMalformedHTLC_clone(orig: bigint): bigint {
25988 if(!isWasmInitialized) {
25989 throw new Error("initializeWasm() must be awaited first!");
25991 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone(orig);
25992 return nativeResponseValue;
25994 // bool UpdateFailMalformedHTLC_eq(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR a, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR b);
25996 export function UpdateFailMalformedHTLC_eq(a: bigint, b: bigint): boolean {
25997 if(!isWasmInitialized) {
25998 throw new Error("initializeWasm() must be awaited first!");
26000 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_eq(a, b);
26001 return nativeResponseValue;
26003 // void CommitmentSigned_free(struct LDKCommitmentSigned this_obj);
26005 export function CommitmentSigned_free(this_obj: bigint): void {
26006 if(!isWasmInitialized) {
26007 throw new Error("initializeWasm() must be awaited first!");
26009 const nativeResponseValue = wasm.TS_CommitmentSigned_free(this_obj);
26010 // debug statements here
26012 // const uint8_t (*CommitmentSigned_get_channel_id(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr))[32];
26014 export function CommitmentSigned_get_channel_id(this_ptr: bigint): number {
26015 if(!isWasmInitialized) {
26016 throw new Error("initializeWasm() must be awaited first!");
26018 const nativeResponseValue = wasm.TS_CommitmentSigned_get_channel_id(this_ptr);
26019 return nativeResponseValue;
26021 // void CommitmentSigned_set_channel_id(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26023 export function CommitmentSigned_set_channel_id(this_ptr: bigint, val: number): void {
26024 if(!isWasmInitialized) {
26025 throw new Error("initializeWasm() must be awaited first!");
26027 const nativeResponseValue = wasm.TS_CommitmentSigned_set_channel_id(this_ptr, val);
26028 // debug statements here
26030 // struct LDKSignature CommitmentSigned_get_signature(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
26032 export function CommitmentSigned_get_signature(this_ptr: bigint): number {
26033 if(!isWasmInitialized) {
26034 throw new Error("initializeWasm() must be awaited first!");
26036 const nativeResponseValue = wasm.TS_CommitmentSigned_get_signature(this_ptr);
26037 return nativeResponseValue;
26039 // void CommitmentSigned_set_signature(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
26041 export function CommitmentSigned_set_signature(this_ptr: bigint, val: number): void {
26042 if(!isWasmInitialized) {
26043 throw new Error("initializeWasm() must be awaited first!");
26045 const nativeResponseValue = wasm.TS_CommitmentSigned_set_signature(this_ptr, val);
26046 // debug statements here
26048 // struct LDKCVec_SignatureZ CommitmentSigned_get_htlc_signatures(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
26050 export function CommitmentSigned_get_htlc_signatures(this_ptr: bigint): number {
26051 if(!isWasmInitialized) {
26052 throw new Error("initializeWasm() must be awaited first!");
26054 const nativeResponseValue = wasm.TS_CommitmentSigned_get_htlc_signatures(this_ptr);
26055 return nativeResponseValue;
26057 // void CommitmentSigned_set_htlc_signatures(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
26059 export function CommitmentSigned_set_htlc_signatures(this_ptr: bigint, val: number): void {
26060 if(!isWasmInitialized) {
26061 throw new Error("initializeWasm() must be awaited first!");
26063 const nativeResponseValue = wasm.TS_CommitmentSigned_set_htlc_signatures(this_ptr, val);
26064 // debug statements here
26066 // MUST_USE_RES struct LDKCommitmentSigned CommitmentSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg, struct LDKCVec_SignatureZ htlc_signatures_arg);
26068 export function CommitmentSigned_new(channel_id_arg: number, signature_arg: number, htlc_signatures_arg: number): bigint {
26069 if(!isWasmInitialized) {
26070 throw new Error("initializeWasm() must be awaited first!");
26072 const nativeResponseValue = wasm.TS_CommitmentSigned_new(channel_id_arg, signature_arg, htlc_signatures_arg);
26073 return nativeResponseValue;
26075 // uint64_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg);
26077 export function CommitmentSigned_clone_ptr(arg: bigint): bigint {
26078 if(!isWasmInitialized) {
26079 throw new Error("initializeWasm() must be awaited first!");
26081 const nativeResponseValue = wasm.TS_CommitmentSigned_clone_ptr(arg);
26082 return nativeResponseValue;
26084 // struct LDKCommitmentSigned CommitmentSigned_clone(const struct LDKCommitmentSigned *NONNULL_PTR orig);
26086 export function CommitmentSigned_clone(orig: bigint): bigint {
26087 if(!isWasmInitialized) {
26088 throw new Error("initializeWasm() must be awaited first!");
26090 const nativeResponseValue = wasm.TS_CommitmentSigned_clone(orig);
26091 return nativeResponseValue;
26093 // bool CommitmentSigned_eq(const struct LDKCommitmentSigned *NONNULL_PTR a, const struct LDKCommitmentSigned *NONNULL_PTR b);
26095 export function CommitmentSigned_eq(a: bigint, b: bigint): boolean {
26096 if(!isWasmInitialized) {
26097 throw new Error("initializeWasm() must be awaited first!");
26099 const nativeResponseValue = wasm.TS_CommitmentSigned_eq(a, b);
26100 return nativeResponseValue;
26102 // void RevokeAndACK_free(struct LDKRevokeAndACK this_obj);
26104 export function RevokeAndACK_free(this_obj: bigint): void {
26105 if(!isWasmInitialized) {
26106 throw new Error("initializeWasm() must be awaited first!");
26108 const nativeResponseValue = wasm.TS_RevokeAndACK_free(this_obj);
26109 // debug statements here
26111 // const uint8_t (*RevokeAndACK_get_channel_id(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
26113 export function RevokeAndACK_get_channel_id(this_ptr: bigint): number {
26114 if(!isWasmInitialized) {
26115 throw new Error("initializeWasm() must be awaited first!");
26117 const nativeResponseValue = wasm.TS_RevokeAndACK_get_channel_id(this_ptr);
26118 return nativeResponseValue;
26120 // void RevokeAndACK_set_channel_id(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26122 export function RevokeAndACK_set_channel_id(this_ptr: bigint, val: number): void {
26123 if(!isWasmInitialized) {
26124 throw new Error("initializeWasm() must be awaited first!");
26126 const nativeResponseValue = wasm.TS_RevokeAndACK_set_channel_id(this_ptr, val);
26127 // debug statements here
26129 // const uint8_t (*RevokeAndACK_get_per_commitment_secret(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
26131 export function RevokeAndACK_get_per_commitment_secret(this_ptr: bigint): number {
26132 if(!isWasmInitialized) {
26133 throw new Error("initializeWasm() must be awaited first!");
26135 const nativeResponseValue = wasm.TS_RevokeAndACK_get_per_commitment_secret(this_ptr);
26136 return nativeResponseValue;
26138 // void RevokeAndACK_set_per_commitment_secret(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26140 export function RevokeAndACK_set_per_commitment_secret(this_ptr: bigint, val: number): void {
26141 if(!isWasmInitialized) {
26142 throw new Error("initializeWasm() must be awaited first!");
26144 const nativeResponseValue = wasm.TS_RevokeAndACK_set_per_commitment_secret(this_ptr, val);
26145 // debug statements here
26147 // struct LDKPublicKey RevokeAndACK_get_next_per_commitment_point(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr);
26149 export function RevokeAndACK_get_next_per_commitment_point(this_ptr: bigint): number {
26150 if(!isWasmInitialized) {
26151 throw new Error("initializeWasm() must be awaited first!");
26153 const nativeResponseValue = wasm.TS_RevokeAndACK_get_next_per_commitment_point(this_ptr);
26154 return nativeResponseValue;
26156 // void RevokeAndACK_set_next_per_commitment_point(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKPublicKey val);
26158 export function RevokeAndACK_set_next_per_commitment_point(this_ptr: bigint, val: number): void {
26159 if(!isWasmInitialized) {
26160 throw new Error("initializeWasm() must be awaited first!");
26162 const nativeResponseValue = wasm.TS_RevokeAndACK_set_next_per_commitment_point(this_ptr, val);
26163 // debug statements here
26165 // 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);
26167 export function RevokeAndACK_new(channel_id_arg: number, per_commitment_secret_arg: number, next_per_commitment_point_arg: number): bigint {
26168 if(!isWasmInitialized) {
26169 throw new Error("initializeWasm() must be awaited first!");
26171 const nativeResponseValue = wasm.TS_RevokeAndACK_new(channel_id_arg, per_commitment_secret_arg, next_per_commitment_point_arg);
26172 return nativeResponseValue;
26174 // uint64_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg);
26176 export function RevokeAndACK_clone_ptr(arg: bigint): bigint {
26177 if(!isWasmInitialized) {
26178 throw new Error("initializeWasm() must be awaited first!");
26180 const nativeResponseValue = wasm.TS_RevokeAndACK_clone_ptr(arg);
26181 return nativeResponseValue;
26183 // struct LDKRevokeAndACK RevokeAndACK_clone(const struct LDKRevokeAndACK *NONNULL_PTR orig);
26185 export function RevokeAndACK_clone(orig: bigint): bigint {
26186 if(!isWasmInitialized) {
26187 throw new Error("initializeWasm() must be awaited first!");
26189 const nativeResponseValue = wasm.TS_RevokeAndACK_clone(orig);
26190 return nativeResponseValue;
26192 // bool RevokeAndACK_eq(const struct LDKRevokeAndACK *NONNULL_PTR a, const struct LDKRevokeAndACK *NONNULL_PTR b);
26194 export function RevokeAndACK_eq(a: bigint, b: bigint): boolean {
26195 if(!isWasmInitialized) {
26196 throw new Error("initializeWasm() must be awaited first!");
26198 const nativeResponseValue = wasm.TS_RevokeAndACK_eq(a, b);
26199 return nativeResponseValue;
26201 // void UpdateFee_free(struct LDKUpdateFee this_obj);
26203 export function UpdateFee_free(this_obj: bigint): void {
26204 if(!isWasmInitialized) {
26205 throw new Error("initializeWasm() must be awaited first!");
26207 const nativeResponseValue = wasm.TS_UpdateFee_free(this_obj);
26208 // debug statements here
26210 // const uint8_t (*UpdateFee_get_channel_id(const struct LDKUpdateFee *NONNULL_PTR this_ptr))[32];
26212 export function UpdateFee_get_channel_id(this_ptr: bigint): number {
26213 if(!isWasmInitialized) {
26214 throw new Error("initializeWasm() must be awaited first!");
26216 const nativeResponseValue = wasm.TS_UpdateFee_get_channel_id(this_ptr);
26217 return nativeResponseValue;
26219 // void UpdateFee_set_channel_id(struct LDKUpdateFee *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26221 export function UpdateFee_set_channel_id(this_ptr: bigint, val: number): void {
26222 if(!isWasmInitialized) {
26223 throw new Error("initializeWasm() must be awaited first!");
26225 const nativeResponseValue = wasm.TS_UpdateFee_set_channel_id(this_ptr, val);
26226 // debug statements here
26228 // uint32_t UpdateFee_get_feerate_per_kw(const struct LDKUpdateFee *NONNULL_PTR this_ptr);
26230 export function UpdateFee_get_feerate_per_kw(this_ptr: bigint): number {
26231 if(!isWasmInitialized) {
26232 throw new Error("initializeWasm() must be awaited first!");
26234 const nativeResponseValue = wasm.TS_UpdateFee_get_feerate_per_kw(this_ptr);
26235 return nativeResponseValue;
26237 // void UpdateFee_set_feerate_per_kw(struct LDKUpdateFee *NONNULL_PTR this_ptr, uint32_t val);
26239 export function UpdateFee_set_feerate_per_kw(this_ptr: bigint, val: number): void {
26240 if(!isWasmInitialized) {
26241 throw new Error("initializeWasm() must be awaited first!");
26243 const nativeResponseValue = wasm.TS_UpdateFee_set_feerate_per_kw(this_ptr, val);
26244 // debug statements here
26246 // MUST_USE_RES struct LDKUpdateFee UpdateFee_new(struct LDKThirtyTwoBytes channel_id_arg, uint32_t feerate_per_kw_arg);
26248 export function UpdateFee_new(channel_id_arg: number, feerate_per_kw_arg: number): bigint {
26249 if(!isWasmInitialized) {
26250 throw new Error("initializeWasm() must be awaited first!");
26252 const nativeResponseValue = wasm.TS_UpdateFee_new(channel_id_arg, feerate_per_kw_arg);
26253 return nativeResponseValue;
26255 // uint64_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg);
26257 export function UpdateFee_clone_ptr(arg: bigint): bigint {
26258 if(!isWasmInitialized) {
26259 throw new Error("initializeWasm() must be awaited first!");
26261 const nativeResponseValue = wasm.TS_UpdateFee_clone_ptr(arg);
26262 return nativeResponseValue;
26264 // struct LDKUpdateFee UpdateFee_clone(const struct LDKUpdateFee *NONNULL_PTR orig);
26266 export function UpdateFee_clone(orig: bigint): bigint {
26267 if(!isWasmInitialized) {
26268 throw new Error("initializeWasm() must be awaited first!");
26270 const nativeResponseValue = wasm.TS_UpdateFee_clone(orig);
26271 return nativeResponseValue;
26273 // bool UpdateFee_eq(const struct LDKUpdateFee *NONNULL_PTR a, const struct LDKUpdateFee *NONNULL_PTR b);
26275 export function UpdateFee_eq(a: bigint, b: bigint): boolean {
26276 if(!isWasmInitialized) {
26277 throw new Error("initializeWasm() must be awaited first!");
26279 const nativeResponseValue = wasm.TS_UpdateFee_eq(a, b);
26280 return nativeResponseValue;
26282 // void DataLossProtect_free(struct LDKDataLossProtect this_obj);
26284 export function DataLossProtect_free(this_obj: bigint): void {
26285 if(!isWasmInitialized) {
26286 throw new Error("initializeWasm() must be awaited first!");
26288 const nativeResponseValue = wasm.TS_DataLossProtect_free(this_obj);
26289 // debug statements here
26291 // const uint8_t (*DataLossProtect_get_your_last_per_commitment_secret(const struct LDKDataLossProtect *NONNULL_PTR this_ptr))[32];
26293 export function DataLossProtect_get_your_last_per_commitment_secret(this_ptr: bigint): number {
26294 if(!isWasmInitialized) {
26295 throw new Error("initializeWasm() must be awaited first!");
26297 const nativeResponseValue = wasm.TS_DataLossProtect_get_your_last_per_commitment_secret(this_ptr);
26298 return nativeResponseValue;
26300 // void DataLossProtect_set_your_last_per_commitment_secret(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26302 export function DataLossProtect_set_your_last_per_commitment_secret(this_ptr: bigint, val: number): void {
26303 if(!isWasmInitialized) {
26304 throw new Error("initializeWasm() must be awaited first!");
26306 const nativeResponseValue = wasm.TS_DataLossProtect_set_your_last_per_commitment_secret(this_ptr, val);
26307 // debug statements here
26309 // struct LDKPublicKey DataLossProtect_get_my_current_per_commitment_point(const struct LDKDataLossProtect *NONNULL_PTR this_ptr);
26311 export function DataLossProtect_get_my_current_per_commitment_point(this_ptr: bigint): number {
26312 if(!isWasmInitialized) {
26313 throw new Error("initializeWasm() must be awaited first!");
26315 const nativeResponseValue = wasm.TS_DataLossProtect_get_my_current_per_commitment_point(this_ptr);
26316 return nativeResponseValue;
26318 // void DataLossProtect_set_my_current_per_commitment_point(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKPublicKey val);
26320 export function DataLossProtect_set_my_current_per_commitment_point(this_ptr: bigint, val: number): void {
26321 if(!isWasmInitialized) {
26322 throw new Error("initializeWasm() must be awaited first!");
26324 const nativeResponseValue = wasm.TS_DataLossProtect_set_my_current_per_commitment_point(this_ptr, val);
26325 // debug statements here
26327 // MUST_USE_RES struct LDKDataLossProtect DataLossProtect_new(struct LDKThirtyTwoBytes your_last_per_commitment_secret_arg, struct LDKPublicKey my_current_per_commitment_point_arg);
26329 export function DataLossProtect_new(your_last_per_commitment_secret_arg: number, my_current_per_commitment_point_arg: number): bigint {
26330 if(!isWasmInitialized) {
26331 throw new Error("initializeWasm() must be awaited first!");
26333 const nativeResponseValue = wasm.TS_DataLossProtect_new(your_last_per_commitment_secret_arg, my_current_per_commitment_point_arg);
26334 return nativeResponseValue;
26336 // uint64_t DataLossProtect_clone_ptr(LDKDataLossProtect *NONNULL_PTR arg);
26338 export function DataLossProtect_clone_ptr(arg: bigint): bigint {
26339 if(!isWasmInitialized) {
26340 throw new Error("initializeWasm() must be awaited first!");
26342 const nativeResponseValue = wasm.TS_DataLossProtect_clone_ptr(arg);
26343 return nativeResponseValue;
26345 // struct LDKDataLossProtect DataLossProtect_clone(const struct LDKDataLossProtect *NONNULL_PTR orig);
26347 export function DataLossProtect_clone(orig: bigint): bigint {
26348 if(!isWasmInitialized) {
26349 throw new Error("initializeWasm() must be awaited first!");
26351 const nativeResponseValue = wasm.TS_DataLossProtect_clone(orig);
26352 return nativeResponseValue;
26354 // bool DataLossProtect_eq(const struct LDKDataLossProtect *NONNULL_PTR a, const struct LDKDataLossProtect *NONNULL_PTR b);
26356 export function DataLossProtect_eq(a: bigint, b: bigint): boolean {
26357 if(!isWasmInitialized) {
26358 throw new Error("initializeWasm() must be awaited first!");
26360 const nativeResponseValue = wasm.TS_DataLossProtect_eq(a, b);
26361 return nativeResponseValue;
26363 // void ChannelReestablish_free(struct LDKChannelReestablish this_obj);
26365 export function ChannelReestablish_free(this_obj: bigint): void {
26366 if(!isWasmInitialized) {
26367 throw new Error("initializeWasm() must be awaited first!");
26369 const nativeResponseValue = wasm.TS_ChannelReestablish_free(this_obj);
26370 // debug statements here
26372 // const uint8_t (*ChannelReestablish_get_channel_id(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
26374 export function ChannelReestablish_get_channel_id(this_ptr: bigint): number {
26375 if(!isWasmInitialized) {
26376 throw new Error("initializeWasm() must be awaited first!");
26378 const nativeResponseValue = wasm.TS_ChannelReestablish_get_channel_id(this_ptr);
26379 return nativeResponseValue;
26381 // void ChannelReestablish_set_channel_id(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26383 export function ChannelReestablish_set_channel_id(this_ptr: bigint, val: number): void {
26384 if(!isWasmInitialized) {
26385 throw new Error("initializeWasm() must be awaited first!");
26387 const nativeResponseValue = wasm.TS_ChannelReestablish_set_channel_id(this_ptr, val);
26388 // debug statements here
26390 // uint64_t ChannelReestablish_get_next_local_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
26392 export function ChannelReestablish_get_next_local_commitment_number(this_ptr: bigint): bigint {
26393 if(!isWasmInitialized) {
26394 throw new Error("initializeWasm() must be awaited first!");
26396 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_local_commitment_number(this_ptr);
26397 return nativeResponseValue;
26399 // void ChannelReestablish_set_next_local_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
26401 export function ChannelReestablish_set_next_local_commitment_number(this_ptr: bigint, val: bigint): void {
26402 if(!isWasmInitialized) {
26403 throw new Error("initializeWasm() must be awaited first!");
26405 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_local_commitment_number(this_ptr, val);
26406 // debug statements here
26408 // uint64_t ChannelReestablish_get_next_remote_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
26410 export function ChannelReestablish_get_next_remote_commitment_number(this_ptr: bigint): bigint {
26411 if(!isWasmInitialized) {
26412 throw new Error("initializeWasm() must be awaited first!");
26414 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_remote_commitment_number(this_ptr);
26415 return nativeResponseValue;
26417 // void ChannelReestablish_set_next_remote_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
26419 export function ChannelReestablish_set_next_remote_commitment_number(this_ptr: bigint, val: bigint): void {
26420 if(!isWasmInitialized) {
26421 throw new Error("initializeWasm() must be awaited first!");
26423 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_remote_commitment_number(this_ptr, val);
26424 // debug statements here
26426 // uint64_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg);
26428 export function ChannelReestablish_clone_ptr(arg: bigint): bigint {
26429 if(!isWasmInitialized) {
26430 throw new Error("initializeWasm() must be awaited first!");
26432 const nativeResponseValue = wasm.TS_ChannelReestablish_clone_ptr(arg);
26433 return nativeResponseValue;
26435 // struct LDKChannelReestablish ChannelReestablish_clone(const struct LDKChannelReestablish *NONNULL_PTR orig);
26437 export function ChannelReestablish_clone(orig: bigint): bigint {
26438 if(!isWasmInitialized) {
26439 throw new Error("initializeWasm() must be awaited first!");
26441 const nativeResponseValue = wasm.TS_ChannelReestablish_clone(orig);
26442 return nativeResponseValue;
26444 // bool ChannelReestablish_eq(const struct LDKChannelReestablish *NONNULL_PTR a, const struct LDKChannelReestablish *NONNULL_PTR b);
26446 export function ChannelReestablish_eq(a: bigint, b: bigint): boolean {
26447 if(!isWasmInitialized) {
26448 throw new Error("initializeWasm() must be awaited first!");
26450 const nativeResponseValue = wasm.TS_ChannelReestablish_eq(a, b);
26451 return nativeResponseValue;
26453 // void AnnouncementSignatures_free(struct LDKAnnouncementSignatures this_obj);
26455 export function AnnouncementSignatures_free(this_obj: bigint): void {
26456 if(!isWasmInitialized) {
26457 throw new Error("initializeWasm() must be awaited first!");
26459 const nativeResponseValue = wasm.TS_AnnouncementSignatures_free(this_obj);
26460 // debug statements here
26462 // const uint8_t (*AnnouncementSignatures_get_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr))[32];
26464 export function AnnouncementSignatures_get_channel_id(this_ptr: bigint): number {
26465 if(!isWasmInitialized) {
26466 throw new Error("initializeWasm() must be awaited first!");
26468 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_channel_id(this_ptr);
26469 return nativeResponseValue;
26471 // void AnnouncementSignatures_set_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26473 export function AnnouncementSignatures_set_channel_id(this_ptr: bigint, val: number): void {
26474 if(!isWasmInitialized) {
26475 throw new Error("initializeWasm() must be awaited first!");
26477 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_channel_id(this_ptr, val);
26478 // debug statements here
26480 // uint64_t AnnouncementSignatures_get_short_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
26482 export function AnnouncementSignatures_get_short_channel_id(this_ptr: bigint): bigint {
26483 if(!isWasmInitialized) {
26484 throw new Error("initializeWasm() must be awaited first!");
26486 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_short_channel_id(this_ptr);
26487 return nativeResponseValue;
26489 // void AnnouncementSignatures_set_short_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, uint64_t val);
26491 export function AnnouncementSignatures_set_short_channel_id(this_ptr: bigint, val: bigint): void {
26492 if(!isWasmInitialized) {
26493 throw new Error("initializeWasm() must be awaited first!");
26495 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_short_channel_id(this_ptr, val);
26496 // debug statements here
26498 // struct LDKSignature AnnouncementSignatures_get_node_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
26500 export function AnnouncementSignatures_get_node_signature(this_ptr: bigint): number {
26501 if(!isWasmInitialized) {
26502 throw new Error("initializeWasm() must be awaited first!");
26504 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_node_signature(this_ptr);
26505 return nativeResponseValue;
26507 // void AnnouncementSignatures_set_node_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
26509 export function AnnouncementSignatures_set_node_signature(this_ptr: bigint, val: number): void {
26510 if(!isWasmInitialized) {
26511 throw new Error("initializeWasm() must be awaited first!");
26513 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_node_signature(this_ptr, val);
26514 // debug statements here
26516 // struct LDKSignature AnnouncementSignatures_get_bitcoin_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
26518 export function AnnouncementSignatures_get_bitcoin_signature(this_ptr: bigint): number {
26519 if(!isWasmInitialized) {
26520 throw new Error("initializeWasm() must be awaited first!");
26522 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_bitcoin_signature(this_ptr);
26523 return nativeResponseValue;
26525 // void AnnouncementSignatures_set_bitcoin_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
26527 export function AnnouncementSignatures_set_bitcoin_signature(this_ptr: bigint, val: number): void {
26528 if(!isWasmInitialized) {
26529 throw new Error("initializeWasm() must be awaited first!");
26531 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_bitcoin_signature(this_ptr, val);
26532 // debug statements here
26534 // 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);
26536 export function AnnouncementSignatures_new(channel_id_arg: number, short_channel_id_arg: bigint, node_signature_arg: number, bitcoin_signature_arg: number): bigint {
26537 if(!isWasmInitialized) {
26538 throw new Error("initializeWasm() must be awaited first!");
26540 const nativeResponseValue = wasm.TS_AnnouncementSignatures_new(channel_id_arg, short_channel_id_arg, node_signature_arg, bitcoin_signature_arg);
26541 return nativeResponseValue;
26543 // uint64_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg);
26545 export function AnnouncementSignatures_clone_ptr(arg: bigint): bigint {
26546 if(!isWasmInitialized) {
26547 throw new Error("initializeWasm() must be awaited first!");
26549 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone_ptr(arg);
26550 return nativeResponseValue;
26552 // struct LDKAnnouncementSignatures AnnouncementSignatures_clone(const struct LDKAnnouncementSignatures *NONNULL_PTR orig);
26554 export function AnnouncementSignatures_clone(orig: bigint): bigint {
26555 if(!isWasmInitialized) {
26556 throw new Error("initializeWasm() must be awaited first!");
26558 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone(orig);
26559 return nativeResponseValue;
26561 // bool AnnouncementSignatures_eq(const struct LDKAnnouncementSignatures *NONNULL_PTR a, const struct LDKAnnouncementSignatures *NONNULL_PTR b);
26563 export function AnnouncementSignatures_eq(a: bigint, b: bigint): boolean {
26564 if(!isWasmInitialized) {
26565 throw new Error("initializeWasm() must be awaited first!");
26567 const nativeResponseValue = wasm.TS_AnnouncementSignatures_eq(a, b);
26568 return nativeResponseValue;
26570 // void NetAddress_free(struct LDKNetAddress this_ptr);
26572 export function NetAddress_free(this_ptr: bigint): void {
26573 if(!isWasmInitialized) {
26574 throw new Error("initializeWasm() must be awaited first!");
26576 const nativeResponseValue = wasm.TS_NetAddress_free(this_ptr);
26577 // debug statements here
26579 // uint64_t NetAddress_clone_ptr(LDKNetAddress *NONNULL_PTR arg);
26581 export function NetAddress_clone_ptr(arg: bigint): bigint {
26582 if(!isWasmInitialized) {
26583 throw new Error("initializeWasm() must be awaited first!");
26585 const nativeResponseValue = wasm.TS_NetAddress_clone_ptr(arg);
26586 return nativeResponseValue;
26588 // struct LDKNetAddress NetAddress_clone(const struct LDKNetAddress *NONNULL_PTR orig);
26590 export function NetAddress_clone(orig: bigint): bigint {
26591 if(!isWasmInitialized) {
26592 throw new Error("initializeWasm() must be awaited first!");
26594 const nativeResponseValue = wasm.TS_NetAddress_clone(orig);
26595 return nativeResponseValue;
26597 // struct LDKNetAddress NetAddress_ipv4(struct LDKFourBytes addr, uint16_t port);
26599 export function NetAddress_ipv4(addr: number, port: number): bigint {
26600 if(!isWasmInitialized) {
26601 throw new Error("initializeWasm() must be awaited first!");
26603 const nativeResponseValue = wasm.TS_NetAddress_ipv4(addr, port);
26604 return nativeResponseValue;
26606 // struct LDKNetAddress NetAddress_ipv6(struct LDKSixteenBytes addr, uint16_t port);
26608 export function NetAddress_ipv6(addr: number, port: number): bigint {
26609 if(!isWasmInitialized) {
26610 throw new Error("initializeWasm() must be awaited first!");
26612 const nativeResponseValue = wasm.TS_NetAddress_ipv6(addr, port);
26613 return nativeResponseValue;
26615 // struct LDKNetAddress NetAddress_onion_v2(struct LDKTwelveBytes a);
26617 export function NetAddress_onion_v2(a: number): bigint {
26618 if(!isWasmInitialized) {
26619 throw new Error("initializeWasm() must be awaited first!");
26621 const nativeResponseValue = wasm.TS_NetAddress_onion_v2(a);
26622 return nativeResponseValue;
26624 // struct LDKNetAddress NetAddress_onion_v3(struct LDKThirtyTwoBytes ed25519_pubkey, uint16_t checksum, uint8_t version, uint16_t port);
26626 export function NetAddress_onion_v3(ed25519_pubkey: number, checksum: number, version: number, port: number): bigint {
26627 if(!isWasmInitialized) {
26628 throw new Error("initializeWasm() must be awaited first!");
26630 const nativeResponseValue = wasm.TS_NetAddress_onion_v3(ed25519_pubkey, checksum, version, port);
26631 return nativeResponseValue;
26633 // struct LDKNetAddress NetAddress_hostname(struct LDKHostname hostname, uint16_t port);
26635 export function NetAddress_hostname(hostname: bigint, port: number): bigint {
26636 if(!isWasmInitialized) {
26637 throw new Error("initializeWasm() must be awaited first!");
26639 const nativeResponseValue = wasm.TS_NetAddress_hostname(hostname, port);
26640 return nativeResponseValue;
26642 // bool NetAddress_eq(const struct LDKNetAddress *NONNULL_PTR a, const struct LDKNetAddress *NONNULL_PTR b);
26644 export function NetAddress_eq(a: bigint, b: bigint): boolean {
26645 if(!isWasmInitialized) {
26646 throw new Error("initializeWasm() must be awaited first!");
26648 const nativeResponseValue = wasm.TS_NetAddress_eq(a, b);
26649 return nativeResponseValue;
26651 // struct LDKCVec_u8Z NetAddress_write(const struct LDKNetAddress *NONNULL_PTR obj);
26653 export function NetAddress_write(obj: bigint): number {
26654 if(!isWasmInitialized) {
26655 throw new Error("initializeWasm() must be awaited first!");
26657 const nativeResponseValue = wasm.TS_NetAddress_write(obj);
26658 return nativeResponseValue;
26660 // struct LDKCResult_NetAddressDecodeErrorZ NetAddress_read(struct LDKu8slice ser);
26662 export function NetAddress_read(ser: number): bigint {
26663 if(!isWasmInitialized) {
26664 throw new Error("initializeWasm() must be awaited first!");
26666 const nativeResponseValue = wasm.TS_NetAddress_read(ser);
26667 return nativeResponseValue;
26669 // void UnsignedGossipMessage_free(struct LDKUnsignedGossipMessage this_ptr);
26671 export function UnsignedGossipMessage_free(this_ptr: bigint): void {
26672 if(!isWasmInitialized) {
26673 throw new Error("initializeWasm() must be awaited first!");
26675 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_free(this_ptr);
26676 // debug statements here
26678 // uint64_t UnsignedGossipMessage_clone_ptr(LDKUnsignedGossipMessage *NONNULL_PTR arg);
26680 export function UnsignedGossipMessage_clone_ptr(arg: bigint): bigint {
26681 if(!isWasmInitialized) {
26682 throw new Error("initializeWasm() must be awaited first!");
26684 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_clone_ptr(arg);
26685 return nativeResponseValue;
26687 // struct LDKUnsignedGossipMessage UnsignedGossipMessage_clone(const struct LDKUnsignedGossipMessage *NONNULL_PTR orig);
26689 export function UnsignedGossipMessage_clone(orig: bigint): bigint {
26690 if(!isWasmInitialized) {
26691 throw new Error("initializeWasm() must be awaited first!");
26693 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_clone(orig);
26694 return nativeResponseValue;
26696 // struct LDKUnsignedGossipMessage UnsignedGossipMessage_channel_announcement(struct LDKUnsignedChannelAnnouncement a);
26698 export function UnsignedGossipMessage_channel_announcement(a: bigint): bigint {
26699 if(!isWasmInitialized) {
26700 throw new Error("initializeWasm() must be awaited first!");
26702 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_channel_announcement(a);
26703 return nativeResponseValue;
26705 // struct LDKUnsignedGossipMessage UnsignedGossipMessage_channel_update(struct LDKUnsignedChannelUpdate a);
26707 export function UnsignedGossipMessage_channel_update(a: bigint): bigint {
26708 if(!isWasmInitialized) {
26709 throw new Error("initializeWasm() must be awaited first!");
26711 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_channel_update(a);
26712 return nativeResponseValue;
26714 // struct LDKUnsignedGossipMessage UnsignedGossipMessage_node_announcement(struct LDKUnsignedNodeAnnouncement a);
26716 export function UnsignedGossipMessage_node_announcement(a: bigint): bigint {
26717 if(!isWasmInitialized) {
26718 throw new Error("initializeWasm() must be awaited first!");
26720 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_node_announcement(a);
26721 return nativeResponseValue;
26723 // struct LDKCVec_u8Z UnsignedGossipMessage_write(const struct LDKUnsignedGossipMessage *NONNULL_PTR obj);
26725 export function UnsignedGossipMessage_write(obj: bigint): number {
26726 if(!isWasmInitialized) {
26727 throw new Error("initializeWasm() must be awaited first!");
26729 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_write(obj);
26730 return nativeResponseValue;
26732 // void UnsignedNodeAnnouncement_free(struct LDKUnsignedNodeAnnouncement this_obj);
26734 export function UnsignedNodeAnnouncement_free(this_obj: bigint): void {
26735 if(!isWasmInitialized) {
26736 throw new Error("initializeWasm() must be awaited first!");
26738 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_free(this_obj);
26739 // debug statements here
26741 // struct LDKNodeFeatures UnsignedNodeAnnouncement_get_features(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
26743 export function UnsignedNodeAnnouncement_get_features(this_ptr: bigint): bigint {
26744 if(!isWasmInitialized) {
26745 throw new Error("initializeWasm() must be awaited first!");
26747 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_features(this_ptr);
26748 return nativeResponseValue;
26750 // void UnsignedNodeAnnouncement_set_features(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
26752 export function UnsignedNodeAnnouncement_set_features(this_ptr: bigint, val: bigint): void {
26753 if(!isWasmInitialized) {
26754 throw new Error("initializeWasm() must be awaited first!");
26756 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_features(this_ptr, val);
26757 // debug statements here
26759 // uint32_t UnsignedNodeAnnouncement_get_timestamp(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
26761 export function UnsignedNodeAnnouncement_get_timestamp(this_ptr: bigint): number {
26762 if(!isWasmInitialized) {
26763 throw new Error("initializeWasm() must be awaited first!");
26765 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_timestamp(this_ptr);
26766 return nativeResponseValue;
26768 // void UnsignedNodeAnnouncement_set_timestamp(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, uint32_t val);
26770 export function UnsignedNodeAnnouncement_set_timestamp(this_ptr: bigint, val: number): void {
26771 if(!isWasmInitialized) {
26772 throw new Error("initializeWasm() must be awaited first!");
26774 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_timestamp(this_ptr, val);
26775 // debug statements here
26777 // struct LDKNodeId UnsignedNodeAnnouncement_get_node_id(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
26779 export function UnsignedNodeAnnouncement_get_node_id(this_ptr: bigint): bigint {
26780 if(!isWasmInitialized) {
26781 throw new Error("initializeWasm() must be awaited first!");
26783 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_node_id(this_ptr);
26784 return nativeResponseValue;
26786 // void UnsignedNodeAnnouncement_set_node_id(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
26788 export function UnsignedNodeAnnouncement_set_node_id(this_ptr: bigint, val: bigint): void {
26789 if(!isWasmInitialized) {
26790 throw new Error("initializeWasm() must be awaited first!");
26792 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_node_id(this_ptr, val);
26793 // debug statements here
26795 // const uint8_t (*UnsignedNodeAnnouncement_get_rgb(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[3];
26797 export function UnsignedNodeAnnouncement_get_rgb(this_ptr: bigint): number {
26798 if(!isWasmInitialized) {
26799 throw new Error("initializeWasm() must be awaited first!");
26801 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_rgb(this_ptr);
26802 return nativeResponseValue;
26804 // void UnsignedNodeAnnouncement_set_rgb(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
26806 export function UnsignedNodeAnnouncement_set_rgb(this_ptr: bigint, val: number): void {
26807 if(!isWasmInitialized) {
26808 throw new Error("initializeWasm() must be awaited first!");
26810 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_rgb(this_ptr, val);
26811 // debug statements here
26813 // const uint8_t (*UnsignedNodeAnnouncement_get_alias(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[32];
26815 export function UnsignedNodeAnnouncement_get_alias(this_ptr: bigint): number {
26816 if(!isWasmInitialized) {
26817 throw new Error("initializeWasm() must be awaited first!");
26819 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_alias(this_ptr);
26820 return nativeResponseValue;
26822 // void UnsignedNodeAnnouncement_set_alias(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26824 export function UnsignedNodeAnnouncement_set_alias(this_ptr: bigint, val: number): void {
26825 if(!isWasmInitialized) {
26826 throw new Error("initializeWasm() must be awaited first!");
26828 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_alias(this_ptr, val);
26829 // debug statements here
26831 // struct LDKCVec_NetAddressZ UnsignedNodeAnnouncement_get_addresses(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
26833 export function UnsignedNodeAnnouncement_get_addresses(this_ptr: bigint): number {
26834 if(!isWasmInitialized) {
26835 throw new Error("initializeWasm() must be awaited first!");
26837 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_addresses(this_ptr);
26838 return nativeResponseValue;
26840 // void UnsignedNodeAnnouncement_set_addresses(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
26842 export function UnsignedNodeAnnouncement_set_addresses(this_ptr: bigint, val: number): void {
26843 if(!isWasmInitialized) {
26844 throw new Error("initializeWasm() must be awaited first!");
26846 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_addresses(this_ptr, val);
26847 // debug statements here
26849 // uint64_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg);
26851 export function UnsignedNodeAnnouncement_clone_ptr(arg: bigint): bigint {
26852 if(!isWasmInitialized) {
26853 throw new Error("initializeWasm() must be awaited first!");
26855 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone_ptr(arg);
26856 return nativeResponseValue;
26858 // struct LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_clone(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR orig);
26860 export function UnsignedNodeAnnouncement_clone(orig: bigint): bigint {
26861 if(!isWasmInitialized) {
26862 throw new Error("initializeWasm() must be awaited first!");
26864 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone(orig);
26865 return nativeResponseValue;
26867 // bool UnsignedNodeAnnouncement_eq(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR a, const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR b);
26869 export function UnsignedNodeAnnouncement_eq(a: bigint, b: bigint): boolean {
26870 if(!isWasmInitialized) {
26871 throw new Error("initializeWasm() must be awaited first!");
26873 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_eq(a, b);
26874 return nativeResponseValue;
26876 // void NodeAnnouncement_free(struct LDKNodeAnnouncement this_obj);
26878 export function NodeAnnouncement_free(this_obj: bigint): void {
26879 if(!isWasmInitialized) {
26880 throw new Error("initializeWasm() must be awaited first!");
26882 const nativeResponseValue = wasm.TS_NodeAnnouncement_free(this_obj);
26883 // debug statements here
26885 // struct LDKSignature NodeAnnouncement_get_signature(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
26887 export function NodeAnnouncement_get_signature(this_ptr: bigint): number {
26888 if(!isWasmInitialized) {
26889 throw new Error("initializeWasm() must be awaited first!");
26891 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_signature(this_ptr);
26892 return nativeResponseValue;
26894 // void NodeAnnouncement_set_signature(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
26896 export function NodeAnnouncement_set_signature(this_ptr: bigint, val: number): void {
26897 if(!isWasmInitialized) {
26898 throw new Error("initializeWasm() must be awaited first!");
26900 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_signature(this_ptr, val);
26901 // debug statements here
26903 // struct LDKUnsignedNodeAnnouncement NodeAnnouncement_get_contents(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
26905 export function NodeAnnouncement_get_contents(this_ptr: bigint): bigint {
26906 if(!isWasmInitialized) {
26907 throw new Error("initializeWasm() must be awaited first!");
26909 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_contents(this_ptr);
26910 return nativeResponseValue;
26912 // void NodeAnnouncement_set_contents(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedNodeAnnouncement val);
26914 export function NodeAnnouncement_set_contents(this_ptr: bigint, val: bigint): void {
26915 if(!isWasmInitialized) {
26916 throw new Error("initializeWasm() must be awaited first!");
26918 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_contents(this_ptr, val);
26919 // debug statements here
26921 // MUST_USE_RES struct LDKNodeAnnouncement NodeAnnouncement_new(struct LDKSignature signature_arg, struct LDKUnsignedNodeAnnouncement contents_arg);
26923 export function NodeAnnouncement_new(signature_arg: number, contents_arg: bigint): bigint {
26924 if(!isWasmInitialized) {
26925 throw new Error("initializeWasm() must be awaited first!");
26927 const nativeResponseValue = wasm.TS_NodeAnnouncement_new(signature_arg, contents_arg);
26928 return nativeResponseValue;
26930 // uint64_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg);
26932 export function NodeAnnouncement_clone_ptr(arg: bigint): bigint {
26933 if(!isWasmInitialized) {
26934 throw new Error("initializeWasm() must be awaited first!");
26936 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone_ptr(arg);
26937 return nativeResponseValue;
26939 // struct LDKNodeAnnouncement NodeAnnouncement_clone(const struct LDKNodeAnnouncement *NONNULL_PTR orig);
26941 export function NodeAnnouncement_clone(orig: bigint): bigint {
26942 if(!isWasmInitialized) {
26943 throw new Error("initializeWasm() must be awaited first!");
26945 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone(orig);
26946 return nativeResponseValue;
26948 // bool NodeAnnouncement_eq(const struct LDKNodeAnnouncement *NONNULL_PTR a, const struct LDKNodeAnnouncement *NONNULL_PTR b);
26950 export function NodeAnnouncement_eq(a: bigint, b: bigint): boolean {
26951 if(!isWasmInitialized) {
26952 throw new Error("initializeWasm() must be awaited first!");
26954 const nativeResponseValue = wasm.TS_NodeAnnouncement_eq(a, b);
26955 return nativeResponseValue;
26957 // void UnsignedChannelAnnouncement_free(struct LDKUnsignedChannelAnnouncement this_obj);
26959 export function UnsignedChannelAnnouncement_free(this_obj: bigint): void {
26960 if(!isWasmInitialized) {
26961 throw new Error("initializeWasm() must be awaited first!");
26963 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_free(this_obj);
26964 // debug statements here
26966 // struct LDKChannelFeatures UnsignedChannelAnnouncement_get_features(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
26968 export function UnsignedChannelAnnouncement_get_features(this_ptr: bigint): bigint {
26969 if(!isWasmInitialized) {
26970 throw new Error("initializeWasm() must be awaited first!");
26972 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_features(this_ptr);
26973 return nativeResponseValue;
26975 // void UnsignedChannelAnnouncement_set_features(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
26977 export function UnsignedChannelAnnouncement_set_features(this_ptr: bigint, val: bigint): void {
26978 if(!isWasmInitialized) {
26979 throw new Error("initializeWasm() must be awaited first!");
26981 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_features(this_ptr, val);
26982 // debug statements here
26984 // const uint8_t (*UnsignedChannelAnnouncement_get_chain_hash(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr))[32];
26986 export function UnsignedChannelAnnouncement_get_chain_hash(this_ptr: bigint): number {
26987 if(!isWasmInitialized) {
26988 throw new Error("initializeWasm() must be awaited first!");
26990 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_chain_hash(this_ptr);
26991 return nativeResponseValue;
26993 // void UnsignedChannelAnnouncement_set_chain_hash(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26995 export function UnsignedChannelAnnouncement_set_chain_hash(this_ptr: bigint, val: number): void {
26996 if(!isWasmInitialized) {
26997 throw new Error("initializeWasm() must be awaited first!");
26999 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_chain_hash(this_ptr, val);
27000 // debug statements here
27002 // uint64_t UnsignedChannelAnnouncement_get_short_channel_id(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
27004 export function UnsignedChannelAnnouncement_get_short_channel_id(this_ptr: bigint): bigint {
27005 if(!isWasmInitialized) {
27006 throw new Error("initializeWasm() must be awaited first!");
27008 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_short_channel_id(this_ptr);
27009 return nativeResponseValue;
27011 // void UnsignedChannelAnnouncement_set_short_channel_id(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, uint64_t val);
27013 export function UnsignedChannelAnnouncement_set_short_channel_id(this_ptr: bigint, val: bigint): void {
27014 if(!isWasmInitialized) {
27015 throw new Error("initializeWasm() must be awaited first!");
27017 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_short_channel_id(this_ptr, val);
27018 // debug statements here
27020 // struct LDKNodeId UnsignedChannelAnnouncement_get_node_id_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
27022 export function UnsignedChannelAnnouncement_get_node_id_1(this_ptr: bigint): bigint {
27023 if(!isWasmInitialized) {
27024 throw new Error("initializeWasm() must be awaited first!");
27026 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_1(this_ptr);
27027 return nativeResponseValue;
27029 // void UnsignedChannelAnnouncement_set_node_id_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
27031 export function UnsignedChannelAnnouncement_set_node_id_1(this_ptr: bigint, val: bigint): void {
27032 if(!isWasmInitialized) {
27033 throw new Error("initializeWasm() must be awaited first!");
27035 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_1(this_ptr, val);
27036 // debug statements here
27038 // struct LDKNodeId UnsignedChannelAnnouncement_get_node_id_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
27040 export function UnsignedChannelAnnouncement_get_node_id_2(this_ptr: bigint): bigint {
27041 if(!isWasmInitialized) {
27042 throw new Error("initializeWasm() must be awaited first!");
27044 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_2(this_ptr);
27045 return nativeResponseValue;
27047 // void UnsignedChannelAnnouncement_set_node_id_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
27049 export function UnsignedChannelAnnouncement_set_node_id_2(this_ptr: bigint, val: bigint): void {
27050 if(!isWasmInitialized) {
27051 throw new Error("initializeWasm() must be awaited first!");
27053 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_2(this_ptr, val);
27054 // debug statements here
27056 // struct LDKNodeId UnsignedChannelAnnouncement_get_bitcoin_key_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
27058 export function UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr: bigint): bigint {
27059 if(!isWasmInitialized) {
27060 throw new Error("initializeWasm() must be awaited first!");
27062 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr);
27063 return nativeResponseValue;
27065 // void UnsignedChannelAnnouncement_set_bitcoin_key_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
27067 export function UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr: bigint, val: bigint): void {
27068 if(!isWasmInitialized) {
27069 throw new Error("initializeWasm() must be awaited first!");
27071 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr, val);
27072 // debug statements here
27074 // struct LDKNodeId UnsignedChannelAnnouncement_get_bitcoin_key_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
27076 export function UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr: bigint): bigint {
27077 if(!isWasmInitialized) {
27078 throw new Error("initializeWasm() must be awaited first!");
27080 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr);
27081 return nativeResponseValue;
27083 // void UnsignedChannelAnnouncement_set_bitcoin_key_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
27085 export function UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr: bigint, val: bigint): void {
27086 if(!isWasmInitialized) {
27087 throw new Error("initializeWasm() must be awaited first!");
27089 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr, val);
27090 // debug statements here
27092 // uint64_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg);
27094 export function UnsignedChannelAnnouncement_clone_ptr(arg: bigint): bigint {
27095 if(!isWasmInitialized) {
27096 throw new Error("initializeWasm() must be awaited first!");
27098 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone_ptr(arg);
27099 return nativeResponseValue;
27101 // struct LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_clone(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR orig);
27103 export function UnsignedChannelAnnouncement_clone(orig: bigint): bigint {
27104 if(!isWasmInitialized) {
27105 throw new Error("initializeWasm() must be awaited first!");
27107 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone(orig);
27108 return nativeResponseValue;
27110 // bool UnsignedChannelAnnouncement_eq(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR a, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR b);
27112 export function UnsignedChannelAnnouncement_eq(a: bigint, b: bigint): boolean {
27113 if(!isWasmInitialized) {
27114 throw new Error("initializeWasm() must be awaited first!");
27116 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_eq(a, b);
27117 return nativeResponseValue;
27119 // void ChannelAnnouncement_free(struct LDKChannelAnnouncement this_obj);
27121 export function ChannelAnnouncement_free(this_obj: bigint): void {
27122 if(!isWasmInitialized) {
27123 throw new Error("initializeWasm() must be awaited first!");
27125 const nativeResponseValue = wasm.TS_ChannelAnnouncement_free(this_obj);
27126 // debug statements here
27128 // struct LDKSignature ChannelAnnouncement_get_node_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
27130 export function ChannelAnnouncement_get_node_signature_1(this_ptr: bigint): number {
27131 if(!isWasmInitialized) {
27132 throw new Error("initializeWasm() must be awaited first!");
27134 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_1(this_ptr);
27135 return nativeResponseValue;
27137 // void ChannelAnnouncement_set_node_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
27139 export function ChannelAnnouncement_set_node_signature_1(this_ptr: bigint, val: number): void {
27140 if(!isWasmInitialized) {
27141 throw new Error("initializeWasm() must be awaited first!");
27143 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_1(this_ptr, val);
27144 // debug statements here
27146 // struct LDKSignature ChannelAnnouncement_get_node_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
27148 export function ChannelAnnouncement_get_node_signature_2(this_ptr: bigint): number {
27149 if(!isWasmInitialized) {
27150 throw new Error("initializeWasm() must be awaited first!");
27152 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_2(this_ptr);
27153 return nativeResponseValue;
27155 // void ChannelAnnouncement_set_node_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
27157 export function ChannelAnnouncement_set_node_signature_2(this_ptr: bigint, val: number): void {
27158 if(!isWasmInitialized) {
27159 throw new Error("initializeWasm() must be awaited first!");
27161 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_2(this_ptr, val);
27162 // debug statements here
27164 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
27166 export function ChannelAnnouncement_get_bitcoin_signature_1(this_ptr: bigint): number {
27167 if(!isWasmInitialized) {
27168 throw new Error("initializeWasm() must be awaited first!");
27170 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_1(this_ptr);
27171 return nativeResponseValue;
27173 // void ChannelAnnouncement_set_bitcoin_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
27175 export function ChannelAnnouncement_set_bitcoin_signature_1(this_ptr: bigint, val: number): void {
27176 if(!isWasmInitialized) {
27177 throw new Error("initializeWasm() must be awaited first!");
27179 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_1(this_ptr, val);
27180 // debug statements here
27182 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
27184 export function ChannelAnnouncement_get_bitcoin_signature_2(this_ptr: bigint): number {
27185 if(!isWasmInitialized) {
27186 throw new Error("initializeWasm() must be awaited first!");
27188 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_2(this_ptr);
27189 return nativeResponseValue;
27191 // void ChannelAnnouncement_set_bitcoin_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
27193 export function ChannelAnnouncement_set_bitcoin_signature_2(this_ptr: bigint, val: number): void {
27194 if(!isWasmInitialized) {
27195 throw new Error("initializeWasm() must be awaited first!");
27197 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_2(this_ptr, val);
27198 // debug statements here
27200 // struct LDKUnsignedChannelAnnouncement ChannelAnnouncement_get_contents(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
27202 export function ChannelAnnouncement_get_contents(this_ptr: bigint): bigint {
27203 if(!isWasmInitialized) {
27204 throw new Error("initializeWasm() must be awaited first!");
27206 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_contents(this_ptr);
27207 return nativeResponseValue;
27209 // void ChannelAnnouncement_set_contents(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedChannelAnnouncement val);
27211 export function ChannelAnnouncement_set_contents(this_ptr: bigint, val: bigint): void {
27212 if(!isWasmInitialized) {
27213 throw new Error("initializeWasm() must be awaited first!");
27215 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_contents(this_ptr, val);
27216 // debug statements here
27218 // 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);
27220 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 {
27221 if(!isWasmInitialized) {
27222 throw new Error("initializeWasm() must be awaited first!");
27224 const nativeResponseValue = wasm.TS_ChannelAnnouncement_new(node_signature_1_arg, node_signature_2_arg, bitcoin_signature_1_arg, bitcoin_signature_2_arg, contents_arg);
27225 return nativeResponseValue;
27227 // uint64_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg);
27229 export function ChannelAnnouncement_clone_ptr(arg: bigint): bigint {
27230 if(!isWasmInitialized) {
27231 throw new Error("initializeWasm() must be awaited first!");
27233 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone_ptr(arg);
27234 return nativeResponseValue;
27236 // struct LDKChannelAnnouncement ChannelAnnouncement_clone(const struct LDKChannelAnnouncement *NONNULL_PTR orig);
27238 export function ChannelAnnouncement_clone(orig: bigint): bigint {
27239 if(!isWasmInitialized) {
27240 throw new Error("initializeWasm() must be awaited first!");
27242 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone(orig);
27243 return nativeResponseValue;
27245 // bool ChannelAnnouncement_eq(const struct LDKChannelAnnouncement *NONNULL_PTR a, const struct LDKChannelAnnouncement *NONNULL_PTR b);
27247 export function ChannelAnnouncement_eq(a: bigint, b: bigint): boolean {
27248 if(!isWasmInitialized) {
27249 throw new Error("initializeWasm() must be awaited first!");
27251 const nativeResponseValue = wasm.TS_ChannelAnnouncement_eq(a, b);
27252 return nativeResponseValue;
27254 // void UnsignedChannelUpdate_free(struct LDKUnsignedChannelUpdate this_obj);
27256 export function UnsignedChannelUpdate_free(this_obj: bigint): void {
27257 if(!isWasmInitialized) {
27258 throw new Error("initializeWasm() must be awaited first!");
27260 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_free(this_obj);
27261 // debug statements here
27263 // const uint8_t (*UnsignedChannelUpdate_get_chain_hash(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr))[32];
27265 export function UnsignedChannelUpdate_get_chain_hash(this_ptr: bigint): number {
27266 if(!isWasmInitialized) {
27267 throw new Error("initializeWasm() must be awaited first!");
27269 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_chain_hash(this_ptr);
27270 return nativeResponseValue;
27272 // void UnsignedChannelUpdate_set_chain_hash(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
27274 export function UnsignedChannelUpdate_set_chain_hash(this_ptr: bigint, val: number): void {
27275 if(!isWasmInitialized) {
27276 throw new Error("initializeWasm() must be awaited first!");
27278 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_chain_hash(this_ptr, val);
27279 // debug statements here
27281 // uint64_t UnsignedChannelUpdate_get_short_channel_id(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
27283 export function UnsignedChannelUpdate_get_short_channel_id(this_ptr: bigint): bigint {
27284 if(!isWasmInitialized) {
27285 throw new Error("initializeWasm() must be awaited first!");
27287 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_short_channel_id(this_ptr);
27288 return nativeResponseValue;
27290 // void UnsignedChannelUpdate_set_short_channel_id(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
27292 export function UnsignedChannelUpdate_set_short_channel_id(this_ptr: bigint, val: bigint): void {
27293 if(!isWasmInitialized) {
27294 throw new Error("initializeWasm() must be awaited first!");
27296 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_short_channel_id(this_ptr, val);
27297 // debug statements here
27299 // uint32_t UnsignedChannelUpdate_get_timestamp(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
27301 export function UnsignedChannelUpdate_get_timestamp(this_ptr: bigint): number {
27302 if(!isWasmInitialized) {
27303 throw new Error("initializeWasm() must be awaited first!");
27305 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_timestamp(this_ptr);
27306 return nativeResponseValue;
27308 // void UnsignedChannelUpdate_set_timestamp(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
27310 export function UnsignedChannelUpdate_set_timestamp(this_ptr: bigint, val: number): void {
27311 if(!isWasmInitialized) {
27312 throw new Error("initializeWasm() must be awaited first!");
27314 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_timestamp(this_ptr, val);
27315 // debug statements here
27317 // uint8_t UnsignedChannelUpdate_get_flags(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
27319 export function UnsignedChannelUpdate_get_flags(this_ptr: bigint): number {
27320 if(!isWasmInitialized) {
27321 throw new Error("initializeWasm() must be awaited first!");
27323 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_flags(this_ptr);
27324 return nativeResponseValue;
27326 // void UnsignedChannelUpdate_set_flags(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint8_t val);
27328 export function UnsignedChannelUpdate_set_flags(this_ptr: bigint, val: number): void {
27329 if(!isWasmInitialized) {
27330 throw new Error("initializeWasm() must be awaited first!");
27332 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_flags(this_ptr, val);
27333 // debug statements here
27335 // uint16_t UnsignedChannelUpdate_get_cltv_expiry_delta(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
27337 export function UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr: bigint): number {
27338 if(!isWasmInitialized) {
27339 throw new Error("initializeWasm() must be awaited first!");
27341 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr);
27342 return nativeResponseValue;
27344 // void UnsignedChannelUpdate_set_cltv_expiry_delta(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint16_t val);
27346 export function UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
27347 if(!isWasmInitialized) {
27348 throw new Error("initializeWasm() must be awaited first!");
27350 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr, val);
27351 // debug statements here
27353 // uint64_t UnsignedChannelUpdate_get_htlc_minimum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
27355 export function UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr: bigint): bigint {
27356 if(!isWasmInitialized) {
27357 throw new Error("initializeWasm() must be awaited first!");
27359 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr);
27360 return nativeResponseValue;
27362 // void UnsignedChannelUpdate_set_htlc_minimum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
27364 export function UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
27365 if(!isWasmInitialized) {
27366 throw new Error("initializeWasm() must be awaited first!");
27368 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr, val);
27369 // debug statements here
27371 // uint64_t UnsignedChannelUpdate_get_htlc_maximum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
27373 export function UnsignedChannelUpdate_get_htlc_maximum_msat(this_ptr: bigint): bigint {
27374 if(!isWasmInitialized) {
27375 throw new Error("initializeWasm() must be awaited first!");
27377 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_maximum_msat(this_ptr);
27378 return nativeResponseValue;
27380 // void UnsignedChannelUpdate_set_htlc_maximum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
27382 export function UnsignedChannelUpdate_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
27383 if(!isWasmInitialized) {
27384 throw new Error("initializeWasm() must be awaited first!");
27386 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_maximum_msat(this_ptr, val);
27387 // debug statements here
27389 // uint32_t UnsignedChannelUpdate_get_fee_base_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
27391 export function UnsignedChannelUpdate_get_fee_base_msat(this_ptr: bigint): number {
27392 if(!isWasmInitialized) {
27393 throw new Error("initializeWasm() must be awaited first!");
27395 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_base_msat(this_ptr);
27396 return nativeResponseValue;
27398 // void UnsignedChannelUpdate_set_fee_base_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
27400 export function UnsignedChannelUpdate_set_fee_base_msat(this_ptr: bigint, val: number): void {
27401 if(!isWasmInitialized) {
27402 throw new Error("initializeWasm() must be awaited first!");
27404 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_base_msat(this_ptr, val);
27405 // debug statements here
27407 // uint32_t UnsignedChannelUpdate_get_fee_proportional_millionths(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
27409 export function UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr: bigint): number {
27410 if(!isWasmInitialized) {
27411 throw new Error("initializeWasm() must be awaited first!");
27413 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr);
27414 return nativeResponseValue;
27416 // void UnsignedChannelUpdate_set_fee_proportional_millionths(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
27418 export function UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
27419 if(!isWasmInitialized) {
27420 throw new Error("initializeWasm() must be awaited first!");
27422 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr, val);
27423 // debug statements here
27425 // struct LDKCVec_u8Z UnsignedChannelUpdate_get_excess_data(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
27427 export function UnsignedChannelUpdate_get_excess_data(this_ptr: bigint): number {
27428 if(!isWasmInitialized) {
27429 throw new Error("initializeWasm() must be awaited first!");
27431 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_excess_data(this_ptr);
27432 return nativeResponseValue;
27434 // void UnsignedChannelUpdate_set_excess_data(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
27436 export function UnsignedChannelUpdate_set_excess_data(this_ptr: bigint, val: number): void {
27437 if(!isWasmInitialized) {
27438 throw new Error("initializeWasm() must be awaited first!");
27440 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_excess_data(this_ptr, val);
27441 // debug statements here
27443 // 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);
27445 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 {
27446 if(!isWasmInitialized) {
27447 throw new Error("initializeWasm() must be awaited first!");
27449 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);
27450 return nativeResponseValue;
27452 // uint64_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg);
27454 export function UnsignedChannelUpdate_clone_ptr(arg: bigint): bigint {
27455 if(!isWasmInitialized) {
27456 throw new Error("initializeWasm() must be awaited first!");
27458 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone_ptr(arg);
27459 return nativeResponseValue;
27461 // struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_clone(const struct LDKUnsignedChannelUpdate *NONNULL_PTR orig);
27463 export function UnsignedChannelUpdate_clone(orig: bigint): bigint {
27464 if(!isWasmInitialized) {
27465 throw new Error("initializeWasm() must be awaited first!");
27467 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone(orig);
27468 return nativeResponseValue;
27470 // bool UnsignedChannelUpdate_eq(const struct LDKUnsignedChannelUpdate *NONNULL_PTR a, const struct LDKUnsignedChannelUpdate *NONNULL_PTR b);
27472 export function UnsignedChannelUpdate_eq(a: bigint, b: bigint): boolean {
27473 if(!isWasmInitialized) {
27474 throw new Error("initializeWasm() must be awaited first!");
27476 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_eq(a, b);
27477 return nativeResponseValue;
27479 // void ChannelUpdate_free(struct LDKChannelUpdate this_obj);
27481 export function ChannelUpdate_free(this_obj: bigint): void {
27482 if(!isWasmInitialized) {
27483 throw new Error("initializeWasm() must be awaited first!");
27485 const nativeResponseValue = wasm.TS_ChannelUpdate_free(this_obj);
27486 // debug statements here
27488 // struct LDKSignature ChannelUpdate_get_signature(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
27490 export function ChannelUpdate_get_signature(this_ptr: bigint): number {
27491 if(!isWasmInitialized) {
27492 throw new Error("initializeWasm() must be awaited first!");
27494 const nativeResponseValue = wasm.TS_ChannelUpdate_get_signature(this_ptr);
27495 return nativeResponseValue;
27497 // void ChannelUpdate_set_signature(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKSignature val);
27499 export function ChannelUpdate_set_signature(this_ptr: bigint, val: number): void {
27500 if(!isWasmInitialized) {
27501 throw new Error("initializeWasm() must be awaited first!");
27503 const nativeResponseValue = wasm.TS_ChannelUpdate_set_signature(this_ptr, val);
27504 // debug statements here
27506 // struct LDKUnsignedChannelUpdate ChannelUpdate_get_contents(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
27508 export function ChannelUpdate_get_contents(this_ptr: bigint): bigint {
27509 if(!isWasmInitialized) {
27510 throw new Error("initializeWasm() must be awaited first!");
27512 const nativeResponseValue = wasm.TS_ChannelUpdate_get_contents(this_ptr);
27513 return nativeResponseValue;
27515 // void ChannelUpdate_set_contents(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKUnsignedChannelUpdate val);
27517 export function ChannelUpdate_set_contents(this_ptr: bigint, val: bigint): void {
27518 if(!isWasmInitialized) {
27519 throw new Error("initializeWasm() must be awaited first!");
27521 const nativeResponseValue = wasm.TS_ChannelUpdate_set_contents(this_ptr, val);
27522 // debug statements here
27524 // MUST_USE_RES struct LDKChannelUpdate ChannelUpdate_new(struct LDKSignature signature_arg, struct LDKUnsignedChannelUpdate contents_arg);
27526 export function ChannelUpdate_new(signature_arg: number, contents_arg: bigint): bigint {
27527 if(!isWasmInitialized) {
27528 throw new Error("initializeWasm() must be awaited first!");
27530 const nativeResponseValue = wasm.TS_ChannelUpdate_new(signature_arg, contents_arg);
27531 return nativeResponseValue;
27533 // uint64_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg);
27535 export function ChannelUpdate_clone_ptr(arg: bigint): bigint {
27536 if(!isWasmInitialized) {
27537 throw new Error("initializeWasm() must be awaited first!");
27539 const nativeResponseValue = wasm.TS_ChannelUpdate_clone_ptr(arg);
27540 return nativeResponseValue;
27542 // struct LDKChannelUpdate ChannelUpdate_clone(const struct LDKChannelUpdate *NONNULL_PTR orig);
27544 export function ChannelUpdate_clone(orig: bigint): bigint {
27545 if(!isWasmInitialized) {
27546 throw new Error("initializeWasm() must be awaited first!");
27548 const nativeResponseValue = wasm.TS_ChannelUpdate_clone(orig);
27549 return nativeResponseValue;
27551 // bool ChannelUpdate_eq(const struct LDKChannelUpdate *NONNULL_PTR a, const struct LDKChannelUpdate *NONNULL_PTR b);
27553 export function ChannelUpdate_eq(a: bigint, b: bigint): boolean {
27554 if(!isWasmInitialized) {
27555 throw new Error("initializeWasm() must be awaited first!");
27557 const nativeResponseValue = wasm.TS_ChannelUpdate_eq(a, b);
27558 return nativeResponseValue;
27560 // void QueryChannelRange_free(struct LDKQueryChannelRange this_obj);
27562 export function QueryChannelRange_free(this_obj: bigint): void {
27563 if(!isWasmInitialized) {
27564 throw new Error("initializeWasm() must be awaited first!");
27566 const nativeResponseValue = wasm.TS_QueryChannelRange_free(this_obj);
27567 // debug statements here
27569 // const uint8_t (*QueryChannelRange_get_chain_hash(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr))[32];
27571 export function QueryChannelRange_get_chain_hash(this_ptr: bigint): number {
27572 if(!isWasmInitialized) {
27573 throw new Error("initializeWasm() must be awaited first!");
27575 const nativeResponseValue = wasm.TS_QueryChannelRange_get_chain_hash(this_ptr);
27576 return nativeResponseValue;
27578 // void QueryChannelRange_set_chain_hash(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
27580 export function QueryChannelRange_set_chain_hash(this_ptr: bigint, val: number): void {
27581 if(!isWasmInitialized) {
27582 throw new Error("initializeWasm() must be awaited first!");
27584 const nativeResponseValue = wasm.TS_QueryChannelRange_set_chain_hash(this_ptr, val);
27585 // debug statements here
27587 // uint32_t QueryChannelRange_get_first_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
27589 export function QueryChannelRange_get_first_blocknum(this_ptr: bigint): number {
27590 if(!isWasmInitialized) {
27591 throw new Error("initializeWasm() must be awaited first!");
27593 const nativeResponseValue = wasm.TS_QueryChannelRange_get_first_blocknum(this_ptr);
27594 return nativeResponseValue;
27596 // void QueryChannelRange_set_first_blocknum(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
27598 export function QueryChannelRange_set_first_blocknum(this_ptr: bigint, val: number): void {
27599 if(!isWasmInitialized) {
27600 throw new Error("initializeWasm() must be awaited first!");
27602 const nativeResponseValue = wasm.TS_QueryChannelRange_set_first_blocknum(this_ptr, val);
27603 // debug statements here
27605 // uint32_t QueryChannelRange_get_number_of_blocks(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
27607 export function QueryChannelRange_get_number_of_blocks(this_ptr: bigint): number {
27608 if(!isWasmInitialized) {
27609 throw new Error("initializeWasm() must be awaited first!");
27611 const nativeResponseValue = wasm.TS_QueryChannelRange_get_number_of_blocks(this_ptr);
27612 return nativeResponseValue;
27614 // void QueryChannelRange_set_number_of_blocks(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
27616 export function QueryChannelRange_set_number_of_blocks(this_ptr: bigint, val: number): void {
27617 if(!isWasmInitialized) {
27618 throw new Error("initializeWasm() must be awaited first!");
27620 const nativeResponseValue = wasm.TS_QueryChannelRange_set_number_of_blocks(this_ptr, val);
27621 // debug statements here
27623 // MUST_USE_RES struct LDKQueryChannelRange QueryChannelRange_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_blocknum_arg, uint32_t number_of_blocks_arg);
27625 export function QueryChannelRange_new(chain_hash_arg: number, first_blocknum_arg: number, number_of_blocks_arg: number): bigint {
27626 if(!isWasmInitialized) {
27627 throw new Error("initializeWasm() must be awaited first!");
27629 const nativeResponseValue = wasm.TS_QueryChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg);
27630 return nativeResponseValue;
27632 // uint64_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg);
27634 export function QueryChannelRange_clone_ptr(arg: bigint): bigint {
27635 if(!isWasmInitialized) {
27636 throw new Error("initializeWasm() must be awaited first!");
27638 const nativeResponseValue = wasm.TS_QueryChannelRange_clone_ptr(arg);
27639 return nativeResponseValue;
27641 // struct LDKQueryChannelRange QueryChannelRange_clone(const struct LDKQueryChannelRange *NONNULL_PTR orig);
27643 export function QueryChannelRange_clone(orig: bigint): bigint {
27644 if(!isWasmInitialized) {
27645 throw new Error("initializeWasm() must be awaited first!");
27647 const nativeResponseValue = wasm.TS_QueryChannelRange_clone(orig);
27648 return nativeResponseValue;
27650 // bool QueryChannelRange_eq(const struct LDKQueryChannelRange *NONNULL_PTR a, const struct LDKQueryChannelRange *NONNULL_PTR b);
27652 export function QueryChannelRange_eq(a: bigint, b: bigint): boolean {
27653 if(!isWasmInitialized) {
27654 throw new Error("initializeWasm() must be awaited first!");
27656 const nativeResponseValue = wasm.TS_QueryChannelRange_eq(a, b);
27657 return nativeResponseValue;
27659 // void ReplyChannelRange_free(struct LDKReplyChannelRange this_obj);
27661 export function ReplyChannelRange_free(this_obj: bigint): void {
27662 if(!isWasmInitialized) {
27663 throw new Error("initializeWasm() must be awaited first!");
27665 const nativeResponseValue = wasm.TS_ReplyChannelRange_free(this_obj);
27666 // debug statements here
27668 // const uint8_t (*ReplyChannelRange_get_chain_hash(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr))[32];
27670 export function ReplyChannelRange_get_chain_hash(this_ptr: bigint): number {
27671 if(!isWasmInitialized) {
27672 throw new Error("initializeWasm() must be awaited first!");
27674 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_chain_hash(this_ptr);
27675 return nativeResponseValue;
27677 // void ReplyChannelRange_set_chain_hash(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
27679 export function ReplyChannelRange_set_chain_hash(this_ptr: bigint, val: number): void {
27680 if(!isWasmInitialized) {
27681 throw new Error("initializeWasm() must be awaited first!");
27683 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_chain_hash(this_ptr, val);
27684 // debug statements here
27686 // uint32_t ReplyChannelRange_get_first_blocknum(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
27688 export function ReplyChannelRange_get_first_blocknum(this_ptr: bigint): number {
27689 if(!isWasmInitialized) {
27690 throw new Error("initializeWasm() must be awaited first!");
27692 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_first_blocknum(this_ptr);
27693 return nativeResponseValue;
27695 // void ReplyChannelRange_set_first_blocknum(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
27697 export function ReplyChannelRange_set_first_blocknum(this_ptr: bigint, val: number): void {
27698 if(!isWasmInitialized) {
27699 throw new Error("initializeWasm() must be awaited first!");
27701 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_first_blocknum(this_ptr, val);
27702 // debug statements here
27704 // uint32_t ReplyChannelRange_get_number_of_blocks(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
27706 export function ReplyChannelRange_get_number_of_blocks(this_ptr: bigint): number {
27707 if(!isWasmInitialized) {
27708 throw new Error("initializeWasm() must be awaited first!");
27710 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_number_of_blocks(this_ptr);
27711 return nativeResponseValue;
27713 // void ReplyChannelRange_set_number_of_blocks(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
27715 export function ReplyChannelRange_set_number_of_blocks(this_ptr: bigint, val: number): void {
27716 if(!isWasmInitialized) {
27717 throw new Error("initializeWasm() must be awaited first!");
27719 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_number_of_blocks(this_ptr, val);
27720 // debug statements here
27722 // bool ReplyChannelRange_get_sync_complete(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
27724 export function ReplyChannelRange_get_sync_complete(this_ptr: bigint): boolean {
27725 if(!isWasmInitialized) {
27726 throw new Error("initializeWasm() must be awaited first!");
27728 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_sync_complete(this_ptr);
27729 return nativeResponseValue;
27731 // void ReplyChannelRange_set_sync_complete(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, bool val);
27733 export function ReplyChannelRange_set_sync_complete(this_ptr: bigint, val: boolean): void {
27734 if(!isWasmInitialized) {
27735 throw new Error("initializeWasm() must be awaited first!");
27737 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_sync_complete(this_ptr, val);
27738 // debug statements here
27740 // struct LDKCVec_u64Z ReplyChannelRange_get_short_channel_ids(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
27742 export function ReplyChannelRange_get_short_channel_ids(this_ptr: bigint): number {
27743 if(!isWasmInitialized) {
27744 throw new Error("initializeWasm() must be awaited first!");
27746 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_short_channel_ids(this_ptr);
27747 return nativeResponseValue;
27749 // void ReplyChannelRange_set_short_channel_ids(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
27751 export function ReplyChannelRange_set_short_channel_ids(this_ptr: bigint, val: number): void {
27752 if(!isWasmInitialized) {
27753 throw new Error("initializeWasm() must be awaited first!");
27755 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_short_channel_ids(this_ptr, val);
27756 // debug statements here
27758 // 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);
27760 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 {
27761 if(!isWasmInitialized) {
27762 throw new Error("initializeWasm() must be awaited first!");
27764 const nativeResponseValue = wasm.TS_ReplyChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg);
27765 return nativeResponseValue;
27767 // uint64_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg);
27769 export function ReplyChannelRange_clone_ptr(arg: bigint): bigint {
27770 if(!isWasmInitialized) {
27771 throw new Error("initializeWasm() must be awaited first!");
27773 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone_ptr(arg);
27774 return nativeResponseValue;
27776 // struct LDKReplyChannelRange ReplyChannelRange_clone(const struct LDKReplyChannelRange *NONNULL_PTR orig);
27778 export function ReplyChannelRange_clone(orig: bigint): bigint {
27779 if(!isWasmInitialized) {
27780 throw new Error("initializeWasm() must be awaited first!");
27782 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone(orig);
27783 return nativeResponseValue;
27785 // bool ReplyChannelRange_eq(const struct LDKReplyChannelRange *NONNULL_PTR a, const struct LDKReplyChannelRange *NONNULL_PTR b);
27787 export function ReplyChannelRange_eq(a: bigint, b: bigint): boolean {
27788 if(!isWasmInitialized) {
27789 throw new Error("initializeWasm() must be awaited first!");
27791 const nativeResponseValue = wasm.TS_ReplyChannelRange_eq(a, b);
27792 return nativeResponseValue;
27794 // void QueryShortChannelIds_free(struct LDKQueryShortChannelIds this_obj);
27796 export function QueryShortChannelIds_free(this_obj: bigint): void {
27797 if(!isWasmInitialized) {
27798 throw new Error("initializeWasm() must be awaited first!");
27800 const nativeResponseValue = wasm.TS_QueryShortChannelIds_free(this_obj);
27801 // debug statements here
27803 // const uint8_t (*QueryShortChannelIds_get_chain_hash(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr))[32];
27805 export function QueryShortChannelIds_get_chain_hash(this_ptr: bigint): number {
27806 if(!isWasmInitialized) {
27807 throw new Error("initializeWasm() must be awaited first!");
27809 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_chain_hash(this_ptr);
27810 return nativeResponseValue;
27812 // void QueryShortChannelIds_set_chain_hash(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
27814 export function QueryShortChannelIds_set_chain_hash(this_ptr: bigint, val: number): void {
27815 if(!isWasmInitialized) {
27816 throw new Error("initializeWasm() must be awaited first!");
27818 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_chain_hash(this_ptr, val);
27819 // debug statements here
27821 // struct LDKCVec_u64Z QueryShortChannelIds_get_short_channel_ids(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr);
27823 export function QueryShortChannelIds_get_short_channel_ids(this_ptr: bigint): number {
27824 if(!isWasmInitialized) {
27825 throw new Error("initializeWasm() must be awaited first!");
27827 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_short_channel_ids(this_ptr);
27828 return nativeResponseValue;
27830 // void QueryShortChannelIds_set_short_channel_ids(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
27832 export function QueryShortChannelIds_set_short_channel_ids(this_ptr: bigint, val: number): void {
27833 if(!isWasmInitialized) {
27834 throw new Error("initializeWasm() must be awaited first!");
27836 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_short_channel_ids(this_ptr, val);
27837 // debug statements here
27839 // MUST_USE_RES struct LDKQueryShortChannelIds QueryShortChannelIds_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKCVec_u64Z short_channel_ids_arg);
27841 export function QueryShortChannelIds_new(chain_hash_arg: number, short_channel_ids_arg: number): bigint {
27842 if(!isWasmInitialized) {
27843 throw new Error("initializeWasm() must be awaited first!");
27845 const nativeResponseValue = wasm.TS_QueryShortChannelIds_new(chain_hash_arg, short_channel_ids_arg);
27846 return nativeResponseValue;
27848 // uint64_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg);
27850 export function QueryShortChannelIds_clone_ptr(arg: bigint): bigint {
27851 if(!isWasmInitialized) {
27852 throw new Error("initializeWasm() must be awaited first!");
27854 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone_ptr(arg);
27855 return nativeResponseValue;
27857 // struct LDKQueryShortChannelIds QueryShortChannelIds_clone(const struct LDKQueryShortChannelIds *NONNULL_PTR orig);
27859 export function QueryShortChannelIds_clone(orig: bigint): bigint {
27860 if(!isWasmInitialized) {
27861 throw new Error("initializeWasm() must be awaited first!");
27863 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone(orig);
27864 return nativeResponseValue;
27866 // bool QueryShortChannelIds_eq(const struct LDKQueryShortChannelIds *NONNULL_PTR a, const struct LDKQueryShortChannelIds *NONNULL_PTR b);
27868 export function QueryShortChannelIds_eq(a: bigint, b: bigint): boolean {
27869 if(!isWasmInitialized) {
27870 throw new Error("initializeWasm() must be awaited first!");
27872 const nativeResponseValue = wasm.TS_QueryShortChannelIds_eq(a, b);
27873 return nativeResponseValue;
27875 // void ReplyShortChannelIdsEnd_free(struct LDKReplyShortChannelIdsEnd this_obj);
27877 export function ReplyShortChannelIdsEnd_free(this_obj: bigint): void {
27878 if(!isWasmInitialized) {
27879 throw new Error("initializeWasm() must be awaited first!");
27881 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_free(this_obj);
27882 // debug statements here
27884 // const uint8_t (*ReplyShortChannelIdsEnd_get_chain_hash(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr))[32];
27886 export function ReplyShortChannelIdsEnd_get_chain_hash(this_ptr: bigint): number {
27887 if(!isWasmInitialized) {
27888 throw new Error("initializeWasm() must be awaited first!");
27890 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_chain_hash(this_ptr);
27891 return nativeResponseValue;
27893 // void ReplyShortChannelIdsEnd_set_chain_hash(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
27895 export function ReplyShortChannelIdsEnd_set_chain_hash(this_ptr: bigint, val: number): void {
27896 if(!isWasmInitialized) {
27897 throw new Error("initializeWasm() must be awaited first!");
27899 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_chain_hash(this_ptr, val);
27900 // debug statements here
27902 // bool ReplyShortChannelIdsEnd_get_full_information(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr);
27904 export function ReplyShortChannelIdsEnd_get_full_information(this_ptr: bigint): boolean {
27905 if(!isWasmInitialized) {
27906 throw new Error("initializeWasm() must be awaited first!");
27908 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_full_information(this_ptr);
27909 return nativeResponseValue;
27911 // void ReplyShortChannelIdsEnd_set_full_information(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, bool val);
27913 export function ReplyShortChannelIdsEnd_set_full_information(this_ptr: bigint, val: boolean): void {
27914 if(!isWasmInitialized) {
27915 throw new Error("initializeWasm() must be awaited first!");
27917 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_full_information(this_ptr, val);
27918 // debug statements here
27920 // MUST_USE_RES struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_new(struct LDKThirtyTwoBytes chain_hash_arg, bool full_information_arg);
27922 export function ReplyShortChannelIdsEnd_new(chain_hash_arg: number, full_information_arg: boolean): bigint {
27923 if(!isWasmInitialized) {
27924 throw new Error("initializeWasm() must be awaited first!");
27926 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_new(chain_hash_arg, full_information_arg);
27927 return nativeResponseValue;
27929 // uint64_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg);
27931 export function ReplyShortChannelIdsEnd_clone_ptr(arg: bigint): bigint {
27932 if(!isWasmInitialized) {
27933 throw new Error("initializeWasm() must be awaited first!");
27935 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone_ptr(arg);
27936 return nativeResponseValue;
27938 // struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_clone(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR orig);
27940 export function ReplyShortChannelIdsEnd_clone(orig: bigint): bigint {
27941 if(!isWasmInitialized) {
27942 throw new Error("initializeWasm() must be awaited first!");
27944 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone(orig);
27945 return nativeResponseValue;
27947 // bool ReplyShortChannelIdsEnd_eq(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR a, const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR b);
27949 export function ReplyShortChannelIdsEnd_eq(a: bigint, b: bigint): boolean {
27950 if(!isWasmInitialized) {
27951 throw new Error("initializeWasm() must be awaited first!");
27953 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_eq(a, b);
27954 return nativeResponseValue;
27956 // void GossipTimestampFilter_free(struct LDKGossipTimestampFilter this_obj);
27958 export function GossipTimestampFilter_free(this_obj: bigint): void {
27959 if(!isWasmInitialized) {
27960 throw new Error("initializeWasm() must be awaited first!");
27962 const nativeResponseValue = wasm.TS_GossipTimestampFilter_free(this_obj);
27963 // debug statements here
27965 // const uint8_t (*GossipTimestampFilter_get_chain_hash(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr))[32];
27967 export function GossipTimestampFilter_get_chain_hash(this_ptr: bigint): number {
27968 if(!isWasmInitialized) {
27969 throw new Error("initializeWasm() must be awaited first!");
27971 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_chain_hash(this_ptr);
27972 return nativeResponseValue;
27974 // void GossipTimestampFilter_set_chain_hash(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
27976 export function GossipTimestampFilter_set_chain_hash(this_ptr: bigint, val: number): void {
27977 if(!isWasmInitialized) {
27978 throw new Error("initializeWasm() must be awaited first!");
27980 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_chain_hash(this_ptr, val);
27981 // debug statements here
27983 // uint32_t GossipTimestampFilter_get_first_timestamp(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
27985 export function GossipTimestampFilter_get_first_timestamp(this_ptr: bigint): number {
27986 if(!isWasmInitialized) {
27987 throw new Error("initializeWasm() must be awaited first!");
27989 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_first_timestamp(this_ptr);
27990 return nativeResponseValue;
27992 // void GossipTimestampFilter_set_first_timestamp(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
27994 export function GossipTimestampFilter_set_first_timestamp(this_ptr: bigint, val: number): void {
27995 if(!isWasmInitialized) {
27996 throw new Error("initializeWasm() must be awaited first!");
27998 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_first_timestamp(this_ptr, val);
27999 // debug statements here
28001 // uint32_t GossipTimestampFilter_get_timestamp_range(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
28003 export function GossipTimestampFilter_get_timestamp_range(this_ptr: bigint): number {
28004 if(!isWasmInitialized) {
28005 throw new Error("initializeWasm() must be awaited first!");
28007 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_timestamp_range(this_ptr);
28008 return nativeResponseValue;
28010 // void GossipTimestampFilter_set_timestamp_range(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
28012 export function GossipTimestampFilter_set_timestamp_range(this_ptr: bigint, val: number): void {
28013 if(!isWasmInitialized) {
28014 throw new Error("initializeWasm() must be awaited first!");
28016 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_timestamp_range(this_ptr, val);
28017 // debug statements here
28019 // MUST_USE_RES struct LDKGossipTimestampFilter GossipTimestampFilter_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_timestamp_arg, uint32_t timestamp_range_arg);
28021 export function GossipTimestampFilter_new(chain_hash_arg: number, first_timestamp_arg: number, timestamp_range_arg: number): bigint {
28022 if(!isWasmInitialized) {
28023 throw new Error("initializeWasm() must be awaited first!");
28025 const nativeResponseValue = wasm.TS_GossipTimestampFilter_new(chain_hash_arg, first_timestamp_arg, timestamp_range_arg);
28026 return nativeResponseValue;
28028 // uint64_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg);
28030 export function GossipTimestampFilter_clone_ptr(arg: bigint): bigint {
28031 if(!isWasmInitialized) {
28032 throw new Error("initializeWasm() must be awaited first!");
28034 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone_ptr(arg);
28035 return nativeResponseValue;
28037 // struct LDKGossipTimestampFilter GossipTimestampFilter_clone(const struct LDKGossipTimestampFilter *NONNULL_PTR orig);
28039 export function GossipTimestampFilter_clone(orig: bigint): bigint {
28040 if(!isWasmInitialized) {
28041 throw new Error("initializeWasm() must be awaited first!");
28043 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone(orig);
28044 return nativeResponseValue;
28046 // bool GossipTimestampFilter_eq(const struct LDKGossipTimestampFilter *NONNULL_PTR a, const struct LDKGossipTimestampFilter *NONNULL_PTR b);
28048 export function GossipTimestampFilter_eq(a: bigint, b: bigint): boolean {
28049 if(!isWasmInitialized) {
28050 throw new Error("initializeWasm() must be awaited first!");
28052 const nativeResponseValue = wasm.TS_GossipTimestampFilter_eq(a, b);
28053 return nativeResponseValue;
28055 // void ErrorAction_free(struct LDKErrorAction this_ptr);
28057 export function ErrorAction_free(this_ptr: bigint): void {
28058 if(!isWasmInitialized) {
28059 throw new Error("initializeWasm() must be awaited first!");
28061 const nativeResponseValue = wasm.TS_ErrorAction_free(this_ptr);
28062 // debug statements here
28064 // uint64_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg);
28066 export function ErrorAction_clone_ptr(arg: bigint): bigint {
28067 if(!isWasmInitialized) {
28068 throw new Error("initializeWasm() must be awaited first!");
28070 const nativeResponseValue = wasm.TS_ErrorAction_clone_ptr(arg);
28071 return nativeResponseValue;
28073 // struct LDKErrorAction ErrorAction_clone(const struct LDKErrorAction *NONNULL_PTR orig);
28075 export function ErrorAction_clone(orig: bigint): bigint {
28076 if(!isWasmInitialized) {
28077 throw new Error("initializeWasm() must be awaited first!");
28079 const nativeResponseValue = wasm.TS_ErrorAction_clone(orig);
28080 return nativeResponseValue;
28082 // struct LDKErrorAction ErrorAction_disconnect_peer(struct LDKErrorMessage msg);
28084 export function ErrorAction_disconnect_peer(msg: bigint): bigint {
28085 if(!isWasmInitialized) {
28086 throw new Error("initializeWasm() must be awaited first!");
28088 const nativeResponseValue = wasm.TS_ErrorAction_disconnect_peer(msg);
28089 return nativeResponseValue;
28091 // struct LDKErrorAction ErrorAction_ignore_error(void);
28093 export function ErrorAction_ignore_error(): bigint {
28094 if(!isWasmInitialized) {
28095 throw new Error("initializeWasm() must be awaited first!");
28097 const nativeResponseValue = wasm.TS_ErrorAction_ignore_error();
28098 return nativeResponseValue;
28100 // struct LDKErrorAction ErrorAction_ignore_and_log(enum LDKLevel a);
28102 export function ErrorAction_ignore_and_log(a: Level): bigint {
28103 if(!isWasmInitialized) {
28104 throw new Error("initializeWasm() must be awaited first!");
28106 const nativeResponseValue = wasm.TS_ErrorAction_ignore_and_log(a);
28107 return nativeResponseValue;
28109 // struct LDKErrorAction ErrorAction_ignore_duplicate_gossip(void);
28111 export function ErrorAction_ignore_duplicate_gossip(): bigint {
28112 if(!isWasmInitialized) {
28113 throw new Error("initializeWasm() must be awaited first!");
28115 const nativeResponseValue = wasm.TS_ErrorAction_ignore_duplicate_gossip();
28116 return nativeResponseValue;
28118 // struct LDKErrorAction ErrorAction_send_error_message(struct LDKErrorMessage msg);
28120 export function ErrorAction_send_error_message(msg: bigint): bigint {
28121 if(!isWasmInitialized) {
28122 throw new Error("initializeWasm() must be awaited first!");
28124 const nativeResponseValue = wasm.TS_ErrorAction_send_error_message(msg);
28125 return nativeResponseValue;
28127 // struct LDKErrorAction ErrorAction_send_warning_message(struct LDKWarningMessage msg, enum LDKLevel log_level);
28129 export function ErrorAction_send_warning_message(msg: bigint, log_level: Level): bigint {
28130 if(!isWasmInitialized) {
28131 throw new Error("initializeWasm() must be awaited first!");
28133 const nativeResponseValue = wasm.TS_ErrorAction_send_warning_message(msg, log_level);
28134 return nativeResponseValue;
28136 // void LightningError_free(struct LDKLightningError this_obj);
28138 export function LightningError_free(this_obj: bigint): void {
28139 if(!isWasmInitialized) {
28140 throw new Error("initializeWasm() must be awaited first!");
28142 const nativeResponseValue = wasm.TS_LightningError_free(this_obj);
28143 // debug statements here
28145 // struct LDKStr LightningError_get_err(const struct LDKLightningError *NONNULL_PTR this_ptr);
28147 export function LightningError_get_err(this_ptr: bigint): number {
28148 if(!isWasmInitialized) {
28149 throw new Error("initializeWasm() must be awaited first!");
28151 const nativeResponseValue = wasm.TS_LightningError_get_err(this_ptr);
28152 return nativeResponseValue;
28154 // void LightningError_set_err(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKStr val);
28156 export function LightningError_set_err(this_ptr: bigint, val: number): void {
28157 if(!isWasmInitialized) {
28158 throw new Error("initializeWasm() must be awaited first!");
28160 const nativeResponseValue = wasm.TS_LightningError_set_err(this_ptr, val);
28161 // debug statements here
28163 // struct LDKErrorAction LightningError_get_action(const struct LDKLightningError *NONNULL_PTR this_ptr);
28165 export function LightningError_get_action(this_ptr: bigint): bigint {
28166 if(!isWasmInitialized) {
28167 throw new Error("initializeWasm() must be awaited first!");
28169 const nativeResponseValue = wasm.TS_LightningError_get_action(this_ptr);
28170 return nativeResponseValue;
28172 // void LightningError_set_action(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKErrorAction val);
28174 export function LightningError_set_action(this_ptr: bigint, val: bigint): void {
28175 if(!isWasmInitialized) {
28176 throw new Error("initializeWasm() must be awaited first!");
28178 const nativeResponseValue = wasm.TS_LightningError_set_action(this_ptr, val);
28179 // debug statements here
28181 // MUST_USE_RES struct LDKLightningError LightningError_new(struct LDKStr err_arg, struct LDKErrorAction action_arg);
28183 export function LightningError_new(err_arg: number, action_arg: bigint): bigint {
28184 if(!isWasmInitialized) {
28185 throw new Error("initializeWasm() must be awaited first!");
28187 const nativeResponseValue = wasm.TS_LightningError_new(err_arg, action_arg);
28188 return nativeResponseValue;
28190 // uint64_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg);
28192 export function LightningError_clone_ptr(arg: bigint): bigint {
28193 if(!isWasmInitialized) {
28194 throw new Error("initializeWasm() must be awaited first!");
28196 const nativeResponseValue = wasm.TS_LightningError_clone_ptr(arg);
28197 return nativeResponseValue;
28199 // struct LDKLightningError LightningError_clone(const struct LDKLightningError *NONNULL_PTR orig);
28201 export function LightningError_clone(orig: bigint): bigint {
28202 if(!isWasmInitialized) {
28203 throw new Error("initializeWasm() must be awaited first!");
28205 const nativeResponseValue = wasm.TS_LightningError_clone(orig);
28206 return nativeResponseValue;
28208 // void CommitmentUpdate_free(struct LDKCommitmentUpdate this_obj);
28210 export function CommitmentUpdate_free(this_obj: bigint): void {
28211 if(!isWasmInitialized) {
28212 throw new Error("initializeWasm() must be awaited first!");
28214 const nativeResponseValue = wasm.TS_CommitmentUpdate_free(this_obj);
28215 // debug statements here
28217 // struct LDKCVec_UpdateAddHTLCZ CommitmentUpdate_get_update_add_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
28219 export function CommitmentUpdate_get_update_add_htlcs(this_ptr: bigint): number {
28220 if(!isWasmInitialized) {
28221 throw new Error("initializeWasm() must be awaited first!");
28223 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_add_htlcs(this_ptr);
28224 return nativeResponseValue;
28226 // void CommitmentUpdate_set_update_add_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateAddHTLCZ val);
28228 export function CommitmentUpdate_set_update_add_htlcs(this_ptr: bigint, val: number): void {
28229 if(!isWasmInitialized) {
28230 throw new Error("initializeWasm() must be awaited first!");
28232 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_add_htlcs(this_ptr, val);
28233 // debug statements here
28235 // struct LDKCVec_UpdateFulfillHTLCZ CommitmentUpdate_get_update_fulfill_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
28237 export function CommitmentUpdate_get_update_fulfill_htlcs(this_ptr: bigint): number {
28238 if(!isWasmInitialized) {
28239 throw new Error("initializeWasm() must be awaited first!");
28241 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fulfill_htlcs(this_ptr);
28242 return nativeResponseValue;
28244 // void CommitmentUpdate_set_update_fulfill_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFulfillHTLCZ val);
28246 export function CommitmentUpdate_set_update_fulfill_htlcs(this_ptr: bigint, val: number): void {
28247 if(!isWasmInitialized) {
28248 throw new Error("initializeWasm() must be awaited first!");
28250 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fulfill_htlcs(this_ptr, val);
28251 // debug statements here
28253 // struct LDKCVec_UpdateFailHTLCZ CommitmentUpdate_get_update_fail_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
28255 export function CommitmentUpdate_get_update_fail_htlcs(this_ptr: bigint): number {
28256 if(!isWasmInitialized) {
28257 throw new Error("initializeWasm() must be awaited first!");
28259 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_htlcs(this_ptr);
28260 return nativeResponseValue;
28262 // void CommitmentUpdate_set_update_fail_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailHTLCZ val);
28264 export function CommitmentUpdate_set_update_fail_htlcs(this_ptr: bigint, val: number): void {
28265 if(!isWasmInitialized) {
28266 throw new Error("initializeWasm() must be awaited first!");
28268 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_htlcs(this_ptr, val);
28269 // debug statements here
28271 // struct LDKCVec_UpdateFailMalformedHTLCZ CommitmentUpdate_get_update_fail_malformed_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
28273 export function CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr: bigint): number {
28274 if(!isWasmInitialized) {
28275 throw new Error("initializeWasm() must be awaited first!");
28277 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr);
28278 return nativeResponseValue;
28280 // void CommitmentUpdate_set_update_fail_malformed_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailMalformedHTLCZ val);
28282 export function CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr: bigint, val: number): void {
28283 if(!isWasmInitialized) {
28284 throw new Error("initializeWasm() must be awaited first!");
28286 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr, val);
28287 // debug statements here
28289 // struct LDKUpdateFee CommitmentUpdate_get_update_fee(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
28291 export function CommitmentUpdate_get_update_fee(this_ptr: bigint): bigint {
28292 if(!isWasmInitialized) {
28293 throw new Error("initializeWasm() must be awaited first!");
28295 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fee(this_ptr);
28296 return nativeResponseValue;
28298 // void CommitmentUpdate_set_update_fee(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKUpdateFee val);
28300 export function CommitmentUpdate_set_update_fee(this_ptr: bigint, val: bigint): void {
28301 if(!isWasmInitialized) {
28302 throw new Error("initializeWasm() must be awaited first!");
28304 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fee(this_ptr, val);
28305 // debug statements here
28307 // struct LDKCommitmentSigned CommitmentUpdate_get_commitment_signed(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
28309 export function CommitmentUpdate_get_commitment_signed(this_ptr: bigint): bigint {
28310 if(!isWasmInitialized) {
28311 throw new Error("initializeWasm() must be awaited first!");
28313 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_commitment_signed(this_ptr);
28314 return nativeResponseValue;
28316 // void CommitmentUpdate_set_commitment_signed(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCommitmentSigned val);
28318 export function CommitmentUpdate_set_commitment_signed(this_ptr: bigint, val: bigint): void {
28319 if(!isWasmInitialized) {
28320 throw new Error("initializeWasm() must be awaited first!");
28322 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_commitment_signed(this_ptr, val);
28323 // debug statements here
28325 // 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);
28327 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 {
28328 if(!isWasmInitialized) {
28329 throw new Error("initializeWasm() must be awaited first!");
28331 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);
28332 return nativeResponseValue;
28334 // uint64_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg);
28336 export function CommitmentUpdate_clone_ptr(arg: bigint): bigint {
28337 if(!isWasmInitialized) {
28338 throw new Error("initializeWasm() must be awaited first!");
28340 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone_ptr(arg);
28341 return nativeResponseValue;
28343 // struct LDKCommitmentUpdate CommitmentUpdate_clone(const struct LDKCommitmentUpdate *NONNULL_PTR orig);
28345 export function CommitmentUpdate_clone(orig: bigint): bigint {
28346 if(!isWasmInitialized) {
28347 throw new Error("initializeWasm() must be awaited first!");
28349 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone(orig);
28350 return nativeResponseValue;
28352 // bool CommitmentUpdate_eq(const struct LDKCommitmentUpdate *NONNULL_PTR a, const struct LDKCommitmentUpdate *NONNULL_PTR b);
28354 export function CommitmentUpdate_eq(a: bigint, b: bigint): boolean {
28355 if(!isWasmInitialized) {
28356 throw new Error("initializeWasm() must be awaited first!");
28358 const nativeResponseValue = wasm.TS_CommitmentUpdate_eq(a, b);
28359 return nativeResponseValue;
28361 // void ChannelMessageHandler_free(struct LDKChannelMessageHandler this_ptr);
28363 export function ChannelMessageHandler_free(this_ptr: bigint): void {
28364 if(!isWasmInitialized) {
28365 throw new Error("initializeWasm() must be awaited first!");
28367 const nativeResponseValue = wasm.TS_ChannelMessageHandler_free(this_ptr);
28368 // debug statements here
28370 // void RoutingMessageHandler_free(struct LDKRoutingMessageHandler this_ptr);
28372 export function RoutingMessageHandler_free(this_ptr: bigint): void {
28373 if(!isWasmInitialized) {
28374 throw new Error("initializeWasm() must be awaited first!");
28376 const nativeResponseValue = wasm.TS_RoutingMessageHandler_free(this_ptr);
28377 // debug statements here
28379 // void OnionMessageHandler_free(struct LDKOnionMessageHandler this_ptr);
28381 export function OnionMessageHandler_free(this_ptr: bigint): void {
28382 if(!isWasmInitialized) {
28383 throw new Error("initializeWasm() must be awaited first!");
28385 const nativeResponseValue = wasm.TS_OnionMessageHandler_free(this_ptr);
28386 // debug statements here
28388 // struct LDKCVec_u8Z AcceptChannel_write(const struct LDKAcceptChannel *NONNULL_PTR obj);
28390 export function AcceptChannel_write(obj: bigint): number {
28391 if(!isWasmInitialized) {
28392 throw new Error("initializeWasm() must be awaited first!");
28394 const nativeResponseValue = wasm.TS_AcceptChannel_write(obj);
28395 return nativeResponseValue;
28397 // struct LDKCResult_AcceptChannelDecodeErrorZ AcceptChannel_read(struct LDKu8slice ser);
28399 export function AcceptChannel_read(ser: number): bigint {
28400 if(!isWasmInitialized) {
28401 throw new Error("initializeWasm() must be awaited first!");
28403 const nativeResponseValue = wasm.TS_AcceptChannel_read(ser);
28404 return nativeResponseValue;
28406 // struct LDKCVec_u8Z AnnouncementSignatures_write(const struct LDKAnnouncementSignatures *NONNULL_PTR obj);
28408 export function AnnouncementSignatures_write(obj: bigint): number {
28409 if(!isWasmInitialized) {
28410 throw new Error("initializeWasm() must be awaited first!");
28412 const nativeResponseValue = wasm.TS_AnnouncementSignatures_write(obj);
28413 return nativeResponseValue;
28415 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ AnnouncementSignatures_read(struct LDKu8slice ser);
28417 export function AnnouncementSignatures_read(ser: number): bigint {
28418 if(!isWasmInitialized) {
28419 throw new Error("initializeWasm() must be awaited first!");
28421 const nativeResponseValue = wasm.TS_AnnouncementSignatures_read(ser);
28422 return nativeResponseValue;
28424 // struct LDKCVec_u8Z ChannelReestablish_write(const struct LDKChannelReestablish *NONNULL_PTR obj);
28426 export function ChannelReestablish_write(obj: bigint): number {
28427 if(!isWasmInitialized) {
28428 throw new Error("initializeWasm() must be awaited first!");
28430 const nativeResponseValue = wasm.TS_ChannelReestablish_write(obj);
28431 return nativeResponseValue;
28433 // struct LDKCResult_ChannelReestablishDecodeErrorZ ChannelReestablish_read(struct LDKu8slice ser);
28435 export function ChannelReestablish_read(ser: number): bigint {
28436 if(!isWasmInitialized) {
28437 throw new Error("initializeWasm() must be awaited first!");
28439 const nativeResponseValue = wasm.TS_ChannelReestablish_read(ser);
28440 return nativeResponseValue;
28442 // struct LDKCVec_u8Z ClosingSigned_write(const struct LDKClosingSigned *NONNULL_PTR obj);
28444 export function ClosingSigned_write(obj: bigint): number {
28445 if(!isWasmInitialized) {
28446 throw new Error("initializeWasm() must be awaited first!");
28448 const nativeResponseValue = wasm.TS_ClosingSigned_write(obj);
28449 return nativeResponseValue;
28451 // struct LDKCResult_ClosingSignedDecodeErrorZ ClosingSigned_read(struct LDKu8slice ser);
28453 export function ClosingSigned_read(ser: number): bigint {
28454 if(!isWasmInitialized) {
28455 throw new Error("initializeWasm() must be awaited first!");
28457 const nativeResponseValue = wasm.TS_ClosingSigned_read(ser);
28458 return nativeResponseValue;
28460 // struct LDKCVec_u8Z ClosingSignedFeeRange_write(const struct LDKClosingSignedFeeRange *NONNULL_PTR obj);
28462 export function ClosingSignedFeeRange_write(obj: bigint): number {
28463 if(!isWasmInitialized) {
28464 throw new Error("initializeWasm() must be awaited first!");
28466 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_write(obj);
28467 return nativeResponseValue;
28469 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ ClosingSignedFeeRange_read(struct LDKu8slice ser);
28471 export function ClosingSignedFeeRange_read(ser: number): bigint {
28472 if(!isWasmInitialized) {
28473 throw new Error("initializeWasm() must be awaited first!");
28475 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_read(ser);
28476 return nativeResponseValue;
28478 // struct LDKCVec_u8Z CommitmentSigned_write(const struct LDKCommitmentSigned *NONNULL_PTR obj);
28480 export function CommitmentSigned_write(obj: bigint): number {
28481 if(!isWasmInitialized) {
28482 throw new Error("initializeWasm() must be awaited first!");
28484 const nativeResponseValue = wasm.TS_CommitmentSigned_write(obj);
28485 return nativeResponseValue;
28487 // struct LDKCResult_CommitmentSignedDecodeErrorZ CommitmentSigned_read(struct LDKu8slice ser);
28489 export function CommitmentSigned_read(ser: number): bigint {
28490 if(!isWasmInitialized) {
28491 throw new Error("initializeWasm() must be awaited first!");
28493 const nativeResponseValue = wasm.TS_CommitmentSigned_read(ser);
28494 return nativeResponseValue;
28496 // struct LDKCVec_u8Z FundingCreated_write(const struct LDKFundingCreated *NONNULL_PTR obj);
28498 export function FundingCreated_write(obj: bigint): number {
28499 if(!isWasmInitialized) {
28500 throw new Error("initializeWasm() must be awaited first!");
28502 const nativeResponseValue = wasm.TS_FundingCreated_write(obj);
28503 return nativeResponseValue;
28505 // struct LDKCResult_FundingCreatedDecodeErrorZ FundingCreated_read(struct LDKu8slice ser);
28507 export function FundingCreated_read(ser: number): bigint {
28508 if(!isWasmInitialized) {
28509 throw new Error("initializeWasm() must be awaited first!");
28511 const nativeResponseValue = wasm.TS_FundingCreated_read(ser);
28512 return nativeResponseValue;
28514 // struct LDKCVec_u8Z FundingSigned_write(const struct LDKFundingSigned *NONNULL_PTR obj);
28516 export function FundingSigned_write(obj: bigint): number {
28517 if(!isWasmInitialized) {
28518 throw new Error("initializeWasm() must be awaited first!");
28520 const nativeResponseValue = wasm.TS_FundingSigned_write(obj);
28521 return nativeResponseValue;
28523 // struct LDKCResult_FundingSignedDecodeErrorZ FundingSigned_read(struct LDKu8slice ser);
28525 export function FundingSigned_read(ser: number): bigint {
28526 if(!isWasmInitialized) {
28527 throw new Error("initializeWasm() must be awaited first!");
28529 const nativeResponseValue = wasm.TS_FundingSigned_read(ser);
28530 return nativeResponseValue;
28532 // struct LDKCVec_u8Z ChannelReady_write(const struct LDKChannelReady *NONNULL_PTR obj);
28534 export function ChannelReady_write(obj: bigint): number {
28535 if(!isWasmInitialized) {
28536 throw new Error("initializeWasm() must be awaited first!");
28538 const nativeResponseValue = wasm.TS_ChannelReady_write(obj);
28539 return nativeResponseValue;
28541 // struct LDKCResult_ChannelReadyDecodeErrorZ ChannelReady_read(struct LDKu8slice ser);
28543 export function ChannelReady_read(ser: number): bigint {
28544 if(!isWasmInitialized) {
28545 throw new Error("initializeWasm() must be awaited first!");
28547 const nativeResponseValue = wasm.TS_ChannelReady_read(ser);
28548 return nativeResponseValue;
28550 // struct LDKCVec_u8Z Init_write(const struct LDKInit *NONNULL_PTR obj);
28552 export function Init_write(obj: bigint): number {
28553 if(!isWasmInitialized) {
28554 throw new Error("initializeWasm() must be awaited first!");
28556 const nativeResponseValue = wasm.TS_Init_write(obj);
28557 return nativeResponseValue;
28559 // struct LDKCResult_InitDecodeErrorZ Init_read(struct LDKu8slice ser);
28561 export function Init_read(ser: number): bigint {
28562 if(!isWasmInitialized) {
28563 throw new Error("initializeWasm() must be awaited first!");
28565 const nativeResponseValue = wasm.TS_Init_read(ser);
28566 return nativeResponseValue;
28568 // struct LDKCVec_u8Z OpenChannel_write(const struct LDKOpenChannel *NONNULL_PTR obj);
28570 export function OpenChannel_write(obj: bigint): number {
28571 if(!isWasmInitialized) {
28572 throw new Error("initializeWasm() must be awaited first!");
28574 const nativeResponseValue = wasm.TS_OpenChannel_write(obj);
28575 return nativeResponseValue;
28577 // struct LDKCResult_OpenChannelDecodeErrorZ OpenChannel_read(struct LDKu8slice ser);
28579 export function OpenChannel_read(ser: number): bigint {
28580 if(!isWasmInitialized) {
28581 throw new Error("initializeWasm() must be awaited first!");
28583 const nativeResponseValue = wasm.TS_OpenChannel_read(ser);
28584 return nativeResponseValue;
28586 // struct LDKCVec_u8Z RevokeAndACK_write(const struct LDKRevokeAndACK *NONNULL_PTR obj);
28588 export function RevokeAndACK_write(obj: bigint): number {
28589 if(!isWasmInitialized) {
28590 throw new Error("initializeWasm() must be awaited first!");
28592 const nativeResponseValue = wasm.TS_RevokeAndACK_write(obj);
28593 return nativeResponseValue;
28595 // struct LDKCResult_RevokeAndACKDecodeErrorZ RevokeAndACK_read(struct LDKu8slice ser);
28597 export function RevokeAndACK_read(ser: number): bigint {
28598 if(!isWasmInitialized) {
28599 throw new Error("initializeWasm() must be awaited first!");
28601 const nativeResponseValue = wasm.TS_RevokeAndACK_read(ser);
28602 return nativeResponseValue;
28604 // struct LDKCVec_u8Z Shutdown_write(const struct LDKShutdown *NONNULL_PTR obj);
28606 export function Shutdown_write(obj: bigint): number {
28607 if(!isWasmInitialized) {
28608 throw new Error("initializeWasm() must be awaited first!");
28610 const nativeResponseValue = wasm.TS_Shutdown_write(obj);
28611 return nativeResponseValue;
28613 // struct LDKCResult_ShutdownDecodeErrorZ Shutdown_read(struct LDKu8slice ser);
28615 export function Shutdown_read(ser: number): bigint {
28616 if(!isWasmInitialized) {
28617 throw new Error("initializeWasm() must be awaited first!");
28619 const nativeResponseValue = wasm.TS_Shutdown_read(ser);
28620 return nativeResponseValue;
28622 // struct LDKCVec_u8Z UpdateFailHTLC_write(const struct LDKUpdateFailHTLC *NONNULL_PTR obj);
28624 export function UpdateFailHTLC_write(obj: bigint): number {
28625 if(!isWasmInitialized) {
28626 throw new Error("initializeWasm() must be awaited first!");
28628 const nativeResponseValue = wasm.TS_UpdateFailHTLC_write(obj);
28629 return nativeResponseValue;
28631 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ UpdateFailHTLC_read(struct LDKu8slice ser);
28633 export function UpdateFailHTLC_read(ser: number): bigint {
28634 if(!isWasmInitialized) {
28635 throw new Error("initializeWasm() must be awaited first!");
28637 const nativeResponseValue = wasm.TS_UpdateFailHTLC_read(ser);
28638 return nativeResponseValue;
28640 // struct LDKCVec_u8Z UpdateFailMalformedHTLC_write(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR obj);
28642 export function UpdateFailMalformedHTLC_write(obj: bigint): number {
28643 if(!isWasmInitialized) {
28644 throw new Error("initializeWasm() must be awaited first!");
28646 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_write(obj);
28647 return nativeResponseValue;
28649 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ UpdateFailMalformedHTLC_read(struct LDKu8slice ser);
28651 export function UpdateFailMalformedHTLC_read(ser: number): bigint {
28652 if(!isWasmInitialized) {
28653 throw new Error("initializeWasm() must be awaited first!");
28655 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_read(ser);
28656 return nativeResponseValue;
28658 // struct LDKCVec_u8Z UpdateFee_write(const struct LDKUpdateFee *NONNULL_PTR obj);
28660 export function UpdateFee_write(obj: bigint): number {
28661 if(!isWasmInitialized) {
28662 throw new Error("initializeWasm() must be awaited first!");
28664 const nativeResponseValue = wasm.TS_UpdateFee_write(obj);
28665 return nativeResponseValue;
28667 // struct LDKCResult_UpdateFeeDecodeErrorZ UpdateFee_read(struct LDKu8slice ser);
28669 export function UpdateFee_read(ser: number): bigint {
28670 if(!isWasmInitialized) {
28671 throw new Error("initializeWasm() must be awaited first!");
28673 const nativeResponseValue = wasm.TS_UpdateFee_read(ser);
28674 return nativeResponseValue;
28676 // struct LDKCVec_u8Z UpdateFulfillHTLC_write(const struct LDKUpdateFulfillHTLC *NONNULL_PTR obj);
28678 export function UpdateFulfillHTLC_write(obj: bigint): number {
28679 if(!isWasmInitialized) {
28680 throw new Error("initializeWasm() must be awaited first!");
28682 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_write(obj);
28683 return nativeResponseValue;
28685 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ UpdateFulfillHTLC_read(struct LDKu8slice ser);
28687 export function UpdateFulfillHTLC_read(ser: number): bigint {
28688 if(!isWasmInitialized) {
28689 throw new Error("initializeWasm() must be awaited first!");
28691 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_read(ser);
28692 return nativeResponseValue;
28694 // struct LDKCVec_u8Z UpdateAddHTLC_write(const struct LDKUpdateAddHTLC *NONNULL_PTR obj);
28696 export function UpdateAddHTLC_write(obj: bigint): number {
28697 if(!isWasmInitialized) {
28698 throw new Error("initializeWasm() must be awaited first!");
28700 const nativeResponseValue = wasm.TS_UpdateAddHTLC_write(obj);
28701 return nativeResponseValue;
28703 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ UpdateAddHTLC_read(struct LDKu8slice ser);
28705 export function UpdateAddHTLC_read(ser: number): bigint {
28706 if(!isWasmInitialized) {
28707 throw new Error("initializeWasm() must be awaited first!");
28709 const nativeResponseValue = wasm.TS_UpdateAddHTLC_read(ser);
28710 return nativeResponseValue;
28712 // struct LDKCResult_OnionMessageDecodeErrorZ OnionMessage_read(struct LDKu8slice ser);
28714 export function OnionMessage_read(ser: number): bigint {
28715 if(!isWasmInitialized) {
28716 throw new Error("initializeWasm() must be awaited first!");
28718 const nativeResponseValue = wasm.TS_OnionMessage_read(ser);
28719 return nativeResponseValue;
28721 // struct LDKCVec_u8Z OnionMessage_write(const struct LDKOnionMessage *NONNULL_PTR obj);
28723 export function OnionMessage_write(obj: bigint): number {
28724 if(!isWasmInitialized) {
28725 throw new Error("initializeWasm() must be awaited first!");
28727 const nativeResponseValue = wasm.TS_OnionMessage_write(obj);
28728 return nativeResponseValue;
28730 // struct LDKCVec_u8Z Ping_write(const struct LDKPing *NONNULL_PTR obj);
28732 export function Ping_write(obj: bigint): number {
28733 if(!isWasmInitialized) {
28734 throw new Error("initializeWasm() must be awaited first!");
28736 const nativeResponseValue = wasm.TS_Ping_write(obj);
28737 return nativeResponseValue;
28739 // struct LDKCResult_PingDecodeErrorZ Ping_read(struct LDKu8slice ser);
28741 export function Ping_read(ser: number): bigint {
28742 if(!isWasmInitialized) {
28743 throw new Error("initializeWasm() must be awaited first!");
28745 const nativeResponseValue = wasm.TS_Ping_read(ser);
28746 return nativeResponseValue;
28748 // struct LDKCVec_u8Z Pong_write(const struct LDKPong *NONNULL_PTR obj);
28750 export function Pong_write(obj: bigint): number {
28751 if(!isWasmInitialized) {
28752 throw new Error("initializeWasm() must be awaited first!");
28754 const nativeResponseValue = wasm.TS_Pong_write(obj);
28755 return nativeResponseValue;
28757 // struct LDKCResult_PongDecodeErrorZ Pong_read(struct LDKu8slice ser);
28759 export function Pong_read(ser: number): bigint {
28760 if(!isWasmInitialized) {
28761 throw new Error("initializeWasm() must be awaited first!");
28763 const nativeResponseValue = wasm.TS_Pong_read(ser);
28764 return nativeResponseValue;
28766 // struct LDKCVec_u8Z UnsignedChannelAnnouncement_write(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR obj);
28768 export function UnsignedChannelAnnouncement_write(obj: bigint): number {
28769 if(!isWasmInitialized) {
28770 throw new Error("initializeWasm() must be awaited first!");
28772 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_write(obj);
28773 return nativeResponseValue;
28775 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ UnsignedChannelAnnouncement_read(struct LDKu8slice ser);
28777 export function UnsignedChannelAnnouncement_read(ser: number): bigint {
28778 if(!isWasmInitialized) {
28779 throw new Error("initializeWasm() must be awaited first!");
28781 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_read(ser);
28782 return nativeResponseValue;
28784 // struct LDKCVec_u8Z ChannelAnnouncement_write(const struct LDKChannelAnnouncement *NONNULL_PTR obj);
28786 export function ChannelAnnouncement_write(obj: bigint): number {
28787 if(!isWasmInitialized) {
28788 throw new Error("initializeWasm() must be awaited first!");
28790 const nativeResponseValue = wasm.TS_ChannelAnnouncement_write(obj);
28791 return nativeResponseValue;
28793 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ ChannelAnnouncement_read(struct LDKu8slice ser);
28795 export function ChannelAnnouncement_read(ser: number): bigint {
28796 if(!isWasmInitialized) {
28797 throw new Error("initializeWasm() must be awaited first!");
28799 const nativeResponseValue = wasm.TS_ChannelAnnouncement_read(ser);
28800 return nativeResponseValue;
28802 // struct LDKCVec_u8Z UnsignedChannelUpdate_write(const struct LDKUnsignedChannelUpdate *NONNULL_PTR obj);
28804 export function UnsignedChannelUpdate_write(obj: bigint): number {
28805 if(!isWasmInitialized) {
28806 throw new Error("initializeWasm() must be awaited first!");
28808 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_write(obj);
28809 return nativeResponseValue;
28811 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ UnsignedChannelUpdate_read(struct LDKu8slice ser);
28813 export function UnsignedChannelUpdate_read(ser: number): bigint {
28814 if(!isWasmInitialized) {
28815 throw new Error("initializeWasm() must be awaited first!");
28817 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_read(ser);
28818 return nativeResponseValue;
28820 // struct LDKCVec_u8Z ChannelUpdate_write(const struct LDKChannelUpdate *NONNULL_PTR obj);
28822 export function ChannelUpdate_write(obj: bigint): number {
28823 if(!isWasmInitialized) {
28824 throw new Error("initializeWasm() must be awaited first!");
28826 const nativeResponseValue = wasm.TS_ChannelUpdate_write(obj);
28827 return nativeResponseValue;
28829 // struct LDKCResult_ChannelUpdateDecodeErrorZ ChannelUpdate_read(struct LDKu8slice ser);
28831 export function ChannelUpdate_read(ser: number): bigint {
28832 if(!isWasmInitialized) {
28833 throw new Error("initializeWasm() must be awaited first!");
28835 const nativeResponseValue = wasm.TS_ChannelUpdate_read(ser);
28836 return nativeResponseValue;
28838 // struct LDKCVec_u8Z ErrorMessage_write(const struct LDKErrorMessage *NONNULL_PTR obj);
28840 export function ErrorMessage_write(obj: bigint): number {
28841 if(!isWasmInitialized) {
28842 throw new Error("initializeWasm() must be awaited first!");
28844 const nativeResponseValue = wasm.TS_ErrorMessage_write(obj);
28845 return nativeResponseValue;
28847 // struct LDKCResult_ErrorMessageDecodeErrorZ ErrorMessage_read(struct LDKu8slice ser);
28849 export function ErrorMessage_read(ser: number): bigint {
28850 if(!isWasmInitialized) {
28851 throw new Error("initializeWasm() must be awaited first!");
28853 const nativeResponseValue = wasm.TS_ErrorMessage_read(ser);
28854 return nativeResponseValue;
28856 // struct LDKCVec_u8Z WarningMessage_write(const struct LDKWarningMessage *NONNULL_PTR obj);
28858 export function WarningMessage_write(obj: bigint): number {
28859 if(!isWasmInitialized) {
28860 throw new Error("initializeWasm() must be awaited first!");
28862 const nativeResponseValue = wasm.TS_WarningMessage_write(obj);
28863 return nativeResponseValue;
28865 // struct LDKCResult_WarningMessageDecodeErrorZ WarningMessage_read(struct LDKu8slice ser);
28867 export function WarningMessage_read(ser: number): bigint {
28868 if(!isWasmInitialized) {
28869 throw new Error("initializeWasm() must be awaited first!");
28871 const nativeResponseValue = wasm.TS_WarningMessage_read(ser);
28872 return nativeResponseValue;
28874 // struct LDKCVec_u8Z UnsignedNodeAnnouncement_write(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR obj);
28876 export function UnsignedNodeAnnouncement_write(obj: bigint): number {
28877 if(!isWasmInitialized) {
28878 throw new Error("initializeWasm() must be awaited first!");
28880 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_write(obj);
28881 return nativeResponseValue;
28883 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ UnsignedNodeAnnouncement_read(struct LDKu8slice ser);
28885 export function UnsignedNodeAnnouncement_read(ser: number): bigint {
28886 if(!isWasmInitialized) {
28887 throw new Error("initializeWasm() must be awaited first!");
28889 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_read(ser);
28890 return nativeResponseValue;
28892 // struct LDKCVec_u8Z NodeAnnouncement_write(const struct LDKNodeAnnouncement *NONNULL_PTR obj);
28894 export function NodeAnnouncement_write(obj: bigint): number {
28895 if(!isWasmInitialized) {
28896 throw new Error("initializeWasm() must be awaited first!");
28898 const nativeResponseValue = wasm.TS_NodeAnnouncement_write(obj);
28899 return nativeResponseValue;
28901 // struct LDKCResult_NodeAnnouncementDecodeErrorZ NodeAnnouncement_read(struct LDKu8slice ser);
28903 export function NodeAnnouncement_read(ser: number): bigint {
28904 if(!isWasmInitialized) {
28905 throw new Error("initializeWasm() must be awaited first!");
28907 const nativeResponseValue = wasm.TS_NodeAnnouncement_read(ser);
28908 return nativeResponseValue;
28910 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ QueryShortChannelIds_read(struct LDKu8slice ser);
28912 export function QueryShortChannelIds_read(ser: number): bigint {
28913 if(!isWasmInitialized) {
28914 throw new Error("initializeWasm() must be awaited first!");
28916 const nativeResponseValue = wasm.TS_QueryShortChannelIds_read(ser);
28917 return nativeResponseValue;
28919 // struct LDKCVec_u8Z QueryShortChannelIds_write(const struct LDKQueryShortChannelIds *NONNULL_PTR obj);
28921 export function QueryShortChannelIds_write(obj: bigint): number {
28922 if(!isWasmInitialized) {
28923 throw new Error("initializeWasm() must be awaited first!");
28925 const nativeResponseValue = wasm.TS_QueryShortChannelIds_write(obj);
28926 return nativeResponseValue;
28928 // struct LDKCVec_u8Z ReplyShortChannelIdsEnd_write(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR obj);
28930 export function ReplyShortChannelIdsEnd_write(obj: bigint): number {
28931 if(!isWasmInitialized) {
28932 throw new Error("initializeWasm() must be awaited first!");
28934 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_write(obj);
28935 return nativeResponseValue;
28937 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ ReplyShortChannelIdsEnd_read(struct LDKu8slice ser);
28939 export function ReplyShortChannelIdsEnd_read(ser: number): bigint {
28940 if(!isWasmInitialized) {
28941 throw new Error("initializeWasm() must be awaited first!");
28943 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_read(ser);
28944 return nativeResponseValue;
28946 // MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
28948 export function QueryChannelRange_end_blocknum(this_arg: bigint): number {
28949 if(!isWasmInitialized) {
28950 throw new Error("initializeWasm() must be awaited first!");
28952 const nativeResponseValue = wasm.TS_QueryChannelRange_end_blocknum(this_arg);
28953 return nativeResponseValue;
28955 // struct LDKCVec_u8Z QueryChannelRange_write(const struct LDKQueryChannelRange *NONNULL_PTR obj);
28957 export function QueryChannelRange_write(obj: bigint): number {
28958 if(!isWasmInitialized) {
28959 throw new Error("initializeWasm() must be awaited first!");
28961 const nativeResponseValue = wasm.TS_QueryChannelRange_write(obj);
28962 return nativeResponseValue;
28964 // struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
28966 export function QueryChannelRange_read(ser: number): bigint {
28967 if(!isWasmInitialized) {
28968 throw new Error("initializeWasm() must be awaited first!");
28970 const nativeResponseValue = wasm.TS_QueryChannelRange_read(ser);
28971 return nativeResponseValue;
28973 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ ReplyChannelRange_read(struct LDKu8slice ser);
28975 export function ReplyChannelRange_read(ser: number): bigint {
28976 if(!isWasmInitialized) {
28977 throw new Error("initializeWasm() must be awaited first!");
28979 const nativeResponseValue = wasm.TS_ReplyChannelRange_read(ser);
28980 return nativeResponseValue;
28982 // struct LDKCVec_u8Z ReplyChannelRange_write(const struct LDKReplyChannelRange *NONNULL_PTR obj);
28984 export function ReplyChannelRange_write(obj: bigint): number {
28985 if(!isWasmInitialized) {
28986 throw new Error("initializeWasm() must be awaited first!");
28988 const nativeResponseValue = wasm.TS_ReplyChannelRange_write(obj);
28989 return nativeResponseValue;
28991 // struct LDKCVec_u8Z GossipTimestampFilter_write(const struct LDKGossipTimestampFilter *NONNULL_PTR obj);
28993 export function GossipTimestampFilter_write(obj: bigint): number {
28994 if(!isWasmInitialized) {
28995 throw new Error("initializeWasm() must be awaited first!");
28997 const nativeResponseValue = wasm.TS_GossipTimestampFilter_write(obj);
28998 return nativeResponseValue;
29000 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ GossipTimestampFilter_read(struct LDKu8slice ser);
29002 export function GossipTimestampFilter_read(ser: number): bigint {
29003 if(!isWasmInitialized) {
29004 throw new Error("initializeWasm() must be awaited first!");
29006 const nativeResponseValue = wasm.TS_GossipTimestampFilter_read(ser);
29007 return nativeResponseValue;
29009 // void CustomMessageHandler_free(struct LDKCustomMessageHandler this_ptr);
29011 export function CustomMessageHandler_free(this_ptr: bigint): void {
29012 if(!isWasmInitialized) {
29013 throw new Error("initializeWasm() must be awaited first!");
29015 const nativeResponseValue = wasm.TS_CustomMessageHandler_free(this_ptr);
29016 // debug statements here
29018 // void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_obj);
29020 export function IgnoringMessageHandler_free(this_obj: bigint): void {
29021 if(!isWasmInitialized) {
29022 throw new Error("initializeWasm() must be awaited first!");
29024 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_free(this_obj);
29025 // debug statements here
29027 // MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void);
29029 export function IgnoringMessageHandler_new(): bigint {
29030 if(!isWasmInitialized) {
29031 throw new Error("initializeWasm() must be awaited first!");
29033 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_new();
29034 return nativeResponseValue;
29036 // struct LDKMessageSendEventsProvider IgnoringMessageHandler_as_MessageSendEventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
29038 export function IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg: bigint): bigint {
29039 if(!isWasmInitialized) {
29040 throw new Error("initializeWasm() must be awaited first!");
29042 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg);
29043 return nativeResponseValue;
29045 // struct LDKRoutingMessageHandler IgnoringMessageHandler_as_RoutingMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
29047 export function IgnoringMessageHandler_as_RoutingMessageHandler(this_arg: bigint): bigint {
29048 if(!isWasmInitialized) {
29049 throw new Error("initializeWasm() must be awaited first!");
29051 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_RoutingMessageHandler(this_arg);
29052 return nativeResponseValue;
29054 // struct LDKOnionMessageProvider IgnoringMessageHandler_as_OnionMessageProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
29056 export function IgnoringMessageHandler_as_OnionMessageProvider(this_arg: bigint): bigint {
29057 if(!isWasmInitialized) {
29058 throw new Error("initializeWasm() must be awaited first!");
29060 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_OnionMessageProvider(this_arg);
29061 return nativeResponseValue;
29063 // struct LDKOnionMessageHandler IgnoringMessageHandler_as_OnionMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
29065 export function IgnoringMessageHandler_as_OnionMessageHandler(this_arg: bigint): bigint {
29066 if(!isWasmInitialized) {
29067 throw new Error("initializeWasm() must be awaited first!");
29069 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_OnionMessageHandler(this_arg);
29070 return nativeResponseValue;
29072 // struct LDKCustomOnionMessageHandler IgnoringMessageHandler_as_CustomOnionMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
29074 export function IgnoringMessageHandler_as_CustomOnionMessageHandler(this_arg: bigint): bigint {
29075 if(!isWasmInitialized) {
29076 throw new Error("initializeWasm() must be awaited first!");
29078 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomOnionMessageHandler(this_arg);
29079 return nativeResponseValue;
29081 // struct LDKCustomMessageReader IgnoringMessageHandler_as_CustomMessageReader(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
29083 export function IgnoringMessageHandler_as_CustomMessageReader(this_arg: bigint): bigint {
29084 if(!isWasmInitialized) {
29085 throw new Error("initializeWasm() must be awaited first!");
29087 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageReader(this_arg);
29088 return nativeResponseValue;
29090 // struct LDKCustomMessageHandler IgnoringMessageHandler_as_CustomMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
29092 export function IgnoringMessageHandler_as_CustomMessageHandler(this_arg: bigint): bigint {
29093 if(!isWasmInitialized) {
29094 throw new Error("initializeWasm() must be awaited first!");
29096 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageHandler(this_arg);
29097 return nativeResponseValue;
29099 // void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_obj);
29101 export function ErroringMessageHandler_free(this_obj: bigint): void {
29102 if(!isWasmInitialized) {
29103 throw new Error("initializeWasm() must be awaited first!");
29105 const nativeResponseValue = wasm.TS_ErroringMessageHandler_free(this_obj);
29106 // debug statements here
29108 // MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void);
29110 export function ErroringMessageHandler_new(): bigint {
29111 if(!isWasmInitialized) {
29112 throw new Error("initializeWasm() must be awaited first!");
29114 const nativeResponseValue = wasm.TS_ErroringMessageHandler_new();
29115 return nativeResponseValue;
29117 // struct LDKMessageSendEventsProvider ErroringMessageHandler_as_MessageSendEventsProvider(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
29119 export function ErroringMessageHandler_as_MessageSendEventsProvider(this_arg: bigint): bigint {
29120 if(!isWasmInitialized) {
29121 throw new Error("initializeWasm() must be awaited first!");
29123 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_MessageSendEventsProvider(this_arg);
29124 return nativeResponseValue;
29126 // struct LDKChannelMessageHandler ErroringMessageHandler_as_ChannelMessageHandler(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
29128 export function ErroringMessageHandler_as_ChannelMessageHandler(this_arg: bigint): bigint {
29129 if(!isWasmInitialized) {
29130 throw new Error("initializeWasm() must be awaited first!");
29132 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_ChannelMessageHandler(this_arg);
29133 return nativeResponseValue;
29135 // void MessageHandler_free(struct LDKMessageHandler this_obj);
29137 export function MessageHandler_free(this_obj: bigint): void {
29138 if(!isWasmInitialized) {
29139 throw new Error("initializeWasm() must be awaited first!");
29141 const nativeResponseValue = wasm.TS_MessageHandler_free(this_obj);
29142 // debug statements here
29144 // const struct LDKChannelMessageHandler *MessageHandler_get_chan_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
29146 export function MessageHandler_get_chan_handler(this_ptr: bigint): bigint {
29147 if(!isWasmInitialized) {
29148 throw new Error("initializeWasm() must be awaited first!");
29150 const nativeResponseValue = wasm.TS_MessageHandler_get_chan_handler(this_ptr);
29151 return nativeResponseValue;
29153 // void MessageHandler_set_chan_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKChannelMessageHandler val);
29155 export function MessageHandler_set_chan_handler(this_ptr: bigint, val: bigint): void {
29156 if(!isWasmInitialized) {
29157 throw new Error("initializeWasm() must be awaited first!");
29159 const nativeResponseValue = wasm.TS_MessageHandler_set_chan_handler(this_ptr, val);
29160 // debug statements here
29162 // const struct LDKRoutingMessageHandler *MessageHandler_get_route_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
29164 export function MessageHandler_get_route_handler(this_ptr: bigint): bigint {
29165 if(!isWasmInitialized) {
29166 throw new Error("initializeWasm() must be awaited first!");
29168 const nativeResponseValue = wasm.TS_MessageHandler_get_route_handler(this_ptr);
29169 return nativeResponseValue;
29171 // void MessageHandler_set_route_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKRoutingMessageHandler val);
29173 export function MessageHandler_set_route_handler(this_ptr: bigint, val: bigint): void {
29174 if(!isWasmInitialized) {
29175 throw new Error("initializeWasm() must be awaited first!");
29177 const nativeResponseValue = wasm.TS_MessageHandler_set_route_handler(this_ptr, val);
29178 // debug statements here
29180 // const struct LDKOnionMessageHandler *MessageHandler_get_onion_message_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
29182 export function MessageHandler_get_onion_message_handler(this_ptr: bigint): bigint {
29183 if(!isWasmInitialized) {
29184 throw new Error("initializeWasm() must be awaited first!");
29186 const nativeResponseValue = wasm.TS_MessageHandler_get_onion_message_handler(this_ptr);
29187 return nativeResponseValue;
29189 // void MessageHandler_set_onion_message_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKOnionMessageHandler val);
29191 export function MessageHandler_set_onion_message_handler(this_ptr: bigint, val: bigint): void {
29192 if(!isWasmInitialized) {
29193 throw new Error("initializeWasm() must be awaited first!");
29195 const nativeResponseValue = wasm.TS_MessageHandler_set_onion_message_handler(this_ptr, val);
29196 // debug statements here
29198 // MUST_USE_RES struct LDKMessageHandler MessageHandler_new(struct LDKChannelMessageHandler chan_handler_arg, struct LDKRoutingMessageHandler route_handler_arg, struct LDKOnionMessageHandler onion_message_handler_arg);
29200 export function MessageHandler_new(chan_handler_arg: bigint, route_handler_arg: bigint, onion_message_handler_arg: bigint): bigint {
29201 if(!isWasmInitialized) {
29202 throw new Error("initializeWasm() must be awaited first!");
29204 const nativeResponseValue = wasm.TS_MessageHandler_new(chan_handler_arg, route_handler_arg, onion_message_handler_arg);
29205 return nativeResponseValue;
29207 // uint64_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg);
29209 export function SocketDescriptor_clone_ptr(arg: bigint): bigint {
29210 if(!isWasmInitialized) {
29211 throw new Error("initializeWasm() must be awaited first!");
29213 const nativeResponseValue = wasm.TS_SocketDescriptor_clone_ptr(arg);
29214 return nativeResponseValue;
29216 // struct LDKSocketDescriptor SocketDescriptor_clone(const struct LDKSocketDescriptor *NONNULL_PTR orig);
29218 export function SocketDescriptor_clone(orig: bigint): bigint {
29219 if(!isWasmInitialized) {
29220 throw new Error("initializeWasm() must be awaited first!");
29222 const nativeResponseValue = wasm.TS_SocketDescriptor_clone(orig);
29223 return nativeResponseValue;
29225 // void SocketDescriptor_free(struct LDKSocketDescriptor this_ptr);
29227 export function SocketDescriptor_free(this_ptr: bigint): void {
29228 if(!isWasmInitialized) {
29229 throw new Error("initializeWasm() must be awaited first!");
29231 const nativeResponseValue = wasm.TS_SocketDescriptor_free(this_ptr);
29232 // debug statements here
29234 // void PeerHandleError_free(struct LDKPeerHandleError this_obj);
29236 export function PeerHandleError_free(this_obj: bigint): void {
29237 if(!isWasmInitialized) {
29238 throw new Error("initializeWasm() must be awaited first!");
29240 const nativeResponseValue = wasm.TS_PeerHandleError_free(this_obj);
29241 // debug statements here
29243 // MUST_USE_RES struct LDKPeerHandleError PeerHandleError_new(void);
29245 export function PeerHandleError_new(): bigint {
29246 if(!isWasmInitialized) {
29247 throw new Error("initializeWasm() must be awaited first!");
29249 const nativeResponseValue = wasm.TS_PeerHandleError_new();
29250 return nativeResponseValue;
29252 // uint64_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg);
29254 export function PeerHandleError_clone_ptr(arg: bigint): bigint {
29255 if(!isWasmInitialized) {
29256 throw new Error("initializeWasm() must be awaited first!");
29258 const nativeResponseValue = wasm.TS_PeerHandleError_clone_ptr(arg);
29259 return nativeResponseValue;
29261 // struct LDKPeerHandleError PeerHandleError_clone(const struct LDKPeerHandleError *NONNULL_PTR orig);
29263 export function PeerHandleError_clone(orig: bigint): bigint {
29264 if(!isWasmInitialized) {
29265 throw new Error("initializeWasm() must be awaited first!");
29267 const nativeResponseValue = wasm.TS_PeerHandleError_clone(orig);
29268 return nativeResponseValue;
29270 // void PeerManager_free(struct LDKPeerManager this_obj);
29272 export function PeerManager_free(this_obj: bigint): void {
29273 if(!isWasmInitialized) {
29274 throw new Error("initializeWasm() must be awaited first!");
29276 const nativeResponseValue = wasm.TS_PeerManager_free(this_obj);
29277 // debug statements here
29279 // MUST_USE_RES struct LDKPeerManager PeerManager_new(struct LDKMessageHandler message_handler, uint32_t current_time, const uint8_t (*ephemeral_random_data)[32], struct LDKLogger logger, struct LDKCustomMessageHandler custom_message_handler, struct LDKNodeSigner node_signer);
29281 export function PeerManager_new(message_handler: bigint, current_time: number, ephemeral_random_data: number, logger: bigint, custom_message_handler: bigint, node_signer: bigint): bigint {
29282 if(!isWasmInitialized) {
29283 throw new Error("initializeWasm() must be awaited first!");
29285 const nativeResponseValue = wasm.TS_PeerManager_new(message_handler, current_time, ephemeral_random_data, logger, custom_message_handler, node_signer);
29286 return nativeResponseValue;
29288 // MUST_USE_RES struct LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ PeerManager_get_peer_node_ids(const struct LDKPeerManager *NONNULL_PTR this_arg);
29290 export function PeerManager_get_peer_node_ids(this_arg: bigint): number {
29291 if(!isWasmInitialized) {
29292 throw new Error("initializeWasm() must be awaited first!");
29294 const nativeResponseValue = wasm.TS_PeerManager_get_peer_node_ids(this_arg);
29295 return nativeResponseValue;
29297 // 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);
29299 export function PeerManager_new_outbound_connection(this_arg: bigint, their_node_id: number, descriptor: bigint, remote_network_address: bigint): bigint {
29300 if(!isWasmInitialized) {
29301 throw new Error("initializeWasm() must be awaited first!");
29303 const nativeResponseValue = wasm.TS_PeerManager_new_outbound_connection(this_arg, their_node_id, descriptor, remote_network_address);
29304 return nativeResponseValue;
29306 // 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);
29308 export function PeerManager_new_inbound_connection(this_arg: bigint, descriptor: bigint, remote_network_address: bigint): bigint {
29309 if(!isWasmInitialized) {
29310 throw new Error("initializeWasm() must be awaited first!");
29312 const nativeResponseValue = wasm.TS_PeerManager_new_inbound_connection(this_arg, descriptor, remote_network_address);
29313 return nativeResponseValue;
29315 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_write_buffer_space_avail(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor *NONNULL_PTR descriptor);
29317 export function PeerManager_write_buffer_space_avail(this_arg: bigint, descriptor: bigint): bigint {
29318 if(!isWasmInitialized) {
29319 throw new Error("initializeWasm() must be awaited first!");
29321 const nativeResponseValue = wasm.TS_PeerManager_write_buffer_space_avail(this_arg, descriptor);
29322 return nativeResponseValue;
29324 // 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);
29326 export function PeerManager_read_event(this_arg: bigint, peer_descriptor: bigint, data: number): bigint {
29327 if(!isWasmInitialized) {
29328 throw new Error("initializeWasm() must be awaited first!");
29330 const nativeResponseValue = wasm.TS_PeerManager_read_event(this_arg, peer_descriptor, data);
29331 return nativeResponseValue;
29333 // void PeerManager_process_events(const struct LDKPeerManager *NONNULL_PTR this_arg);
29335 export function PeerManager_process_events(this_arg: bigint): void {
29336 if(!isWasmInitialized) {
29337 throw new Error("initializeWasm() must be awaited first!");
29339 const nativeResponseValue = wasm.TS_PeerManager_process_events(this_arg);
29340 // debug statements here
29342 // void PeerManager_socket_disconnected(const struct LDKPeerManager *NONNULL_PTR this_arg, const struct LDKSocketDescriptor *NONNULL_PTR descriptor);
29344 export function PeerManager_socket_disconnected(this_arg: bigint, descriptor: bigint): void {
29345 if(!isWasmInitialized) {
29346 throw new Error("initializeWasm() must be awaited first!");
29348 const nativeResponseValue = wasm.TS_PeerManager_socket_disconnected(this_arg, descriptor);
29349 // debug statements here
29351 // void PeerManager_disconnect_by_node_id(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id);
29353 export function PeerManager_disconnect_by_node_id(this_arg: bigint, node_id: number): void {
29354 if(!isWasmInitialized) {
29355 throw new Error("initializeWasm() must be awaited first!");
29357 const nativeResponseValue = wasm.TS_PeerManager_disconnect_by_node_id(this_arg, node_id);
29358 // debug statements here
29360 // void PeerManager_disconnect_all_peers(const struct LDKPeerManager *NONNULL_PTR this_arg);
29362 export function PeerManager_disconnect_all_peers(this_arg: bigint): void {
29363 if(!isWasmInitialized) {
29364 throw new Error("initializeWasm() must be awaited first!");
29366 const nativeResponseValue = wasm.TS_PeerManager_disconnect_all_peers(this_arg);
29367 // debug statements here
29369 // void PeerManager_timer_tick_occurred(const struct LDKPeerManager *NONNULL_PTR this_arg);
29371 export function PeerManager_timer_tick_occurred(this_arg: bigint): void {
29372 if(!isWasmInitialized) {
29373 throw new Error("initializeWasm() must be awaited first!");
29375 const nativeResponseValue = wasm.TS_PeerManager_timer_tick_occurred(this_arg);
29376 // debug statements here
29378 // void PeerManager_broadcast_node_announcement(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKThreeBytes rgb, struct LDKThirtyTwoBytes alias, struct LDKCVec_NetAddressZ addresses);
29380 export function PeerManager_broadcast_node_announcement(this_arg: bigint, rgb: number, alias: number, addresses: number): void {
29381 if(!isWasmInitialized) {
29382 throw new Error("initializeWasm() must be awaited first!");
29384 const nativeResponseValue = wasm.TS_PeerManager_broadcast_node_announcement(this_arg, rgb, alias, addresses);
29385 // debug statements here
29387 // uint64_t htlc_success_tx_weight(bool opt_anchors);
29389 export function htlc_success_tx_weight(opt_anchors: boolean): bigint {
29390 if(!isWasmInitialized) {
29391 throw new Error("initializeWasm() must be awaited first!");
29393 const nativeResponseValue = wasm.TS_htlc_success_tx_weight(opt_anchors);
29394 return nativeResponseValue;
29396 // uint64_t htlc_timeout_tx_weight(bool opt_anchors);
29398 export function htlc_timeout_tx_weight(opt_anchors: boolean): bigint {
29399 if(!isWasmInitialized) {
29400 throw new Error("initializeWasm() must be awaited first!");
29402 const nativeResponseValue = wasm.TS_htlc_timeout_tx_weight(opt_anchors);
29403 return nativeResponseValue;
29405 // enum LDKHTLCClaim HTLCClaim_clone(const enum LDKHTLCClaim *NONNULL_PTR orig);
29407 export function HTLCClaim_clone(orig: bigint): HTLCClaim {
29408 if(!isWasmInitialized) {
29409 throw new Error("initializeWasm() must be awaited first!");
29411 const nativeResponseValue = wasm.TS_HTLCClaim_clone(orig);
29412 return nativeResponseValue;
29414 // enum LDKHTLCClaim HTLCClaim_offered_timeout(void);
29416 export function HTLCClaim_offered_timeout(): HTLCClaim {
29417 if(!isWasmInitialized) {
29418 throw new Error("initializeWasm() must be awaited first!");
29420 const nativeResponseValue = wasm.TS_HTLCClaim_offered_timeout();
29421 return nativeResponseValue;
29423 // enum LDKHTLCClaim HTLCClaim_offered_preimage(void);
29425 export function HTLCClaim_offered_preimage(): HTLCClaim {
29426 if(!isWasmInitialized) {
29427 throw new Error("initializeWasm() must be awaited first!");
29429 const nativeResponseValue = wasm.TS_HTLCClaim_offered_preimage();
29430 return nativeResponseValue;
29432 // enum LDKHTLCClaim HTLCClaim_accepted_timeout(void);
29434 export function HTLCClaim_accepted_timeout(): HTLCClaim {
29435 if(!isWasmInitialized) {
29436 throw new Error("initializeWasm() must be awaited first!");
29438 const nativeResponseValue = wasm.TS_HTLCClaim_accepted_timeout();
29439 return nativeResponseValue;
29441 // enum LDKHTLCClaim HTLCClaim_accepted_preimage(void);
29443 export function HTLCClaim_accepted_preimage(): HTLCClaim {
29444 if(!isWasmInitialized) {
29445 throw new Error("initializeWasm() must be awaited first!");
29447 const nativeResponseValue = wasm.TS_HTLCClaim_accepted_preimage();
29448 return nativeResponseValue;
29450 // enum LDKHTLCClaim HTLCClaim_revocation(void);
29452 export function HTLCClaim_revocation(): HTLCClaim {
29453 if(!isWasmInitialized) {
29454 throw new Error("initializeWasm() must be awaited first!");
29456 const nativeResponseValue = wasm.TS_HTLCClaim_revocation();
29457 return nativeResponseValue;
29459 // bool HTLCClaim_eq(const enum LDKHTLCClaim *NONNULL_PTR a, const enum LDKHTLCClaim *NONNULL_PTR b);
29461 export function HTLCClaim_eq(a: bigint, b: bigint): boolean {
29462 if(!isWasmInitialized) {
29463 throw new Error("initializeWasm() must be awaited first!");
29465 const nativeResponseValue = wasm.TS_HTLCClaim_eq(a, b);
29466 return nativeResponseValue;
29468 // MUST_USE_RES struct LDKCOption_HTLCClaimZ HTLCClaim_from_witness(struct LDKWitness witness);
29470 export function HTLCClaim_from_witness(witness: number): bigint {
29471 if(!isWasmInitialized) {
29472 throw new Error("initializeWasm() must be awaited first!");
29474 const nativeResponseValue = wasm.TS_HTLCClaim_from_witness(witness);
29475 return nativeResponseValue;
29477 // struct LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx);
29479 export function build_commitment_secret(commitment_seed: number, idx: bigint): number {
29480 if(!isWasmInitialized) {
29481 throw new Error("initializeWasm() must be awaited first!");
29483 const nativeResponseValue = wasm.TS_build_commitment_secret(commitment_seed, idx);
29484 return nativeResponseValue;
29486 // 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);
29488 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 {
29489 if(!isWasmInitialized) {
29490 throw new Error("initializeWasm() must be awaited first!");
29492 const nativeResponseValue = wasm.TS_build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
29493 return nativeResponseValue;
29495 // void CounterpartyCommitmentSecrets_free(struct LDKCounterpartyCommitmentSecrets this_obj);
29497 export function CounterpartyCommitmentSecrets_free(this_obj: bigint): void {
29498 if(!isWasmInitialized) {
29499 throw new Error("initializeWasm() must be awaited first!");
29501 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_free(this_obj);
29502 // debug statements here
29504 // uint64_t CounterpartyCommitmentSecrets_clone_ptr(LDKCounterpartyCommitmentSecrets *NONNULL_PTR arg);
29506 export function CounterpartyCommitmentSecrets_clone_ptr(arg: bigint): bigint {
29507 if(!isWasmInitialized) {
29508 throw new Error("initializeWasm() must be awaited first!");
29510 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone_ptr(arg);
29511 return nativeResponseValue;
29513 // struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_clone(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR orig);
29515 export function CounterpartyCommitmentSecrets_clone(orig: bigint): bigint {
29516 if(!isWasmInitialized) {
29517 throw new Error("initializeWasm() must be awaited first!");
29519 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone(orig);
29520 return nativeResponseValue;
29522 // MUST_USE_RES struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_new(void);
29524 export function CounterpartyCommitmentSecrets_new(): bigint {
29525 if(!isWasmInitialized) {
29526 throw new Error("initializeWasm() must be awaited first!");
29528 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_new();
29529 return nativeResponseValue;
29531 // MUST_USE_RES uint64_t CounterpartyCommitmentSecrets_get_min_seen_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg);
29533 export function CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg: bigint): bigint {
29534 if(!isWasmInitialized) {
29535 throw new Error("initializeWasm() must be awaited first!");
29537 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg);
29538 return nativeResponseValue;
29540 // MUST_USE_RES struct LDKCResult_NoneNoneZ CounterpartyCommitmentSecrets_provide_secret(struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx, struct LDKThirtyTwoBytes secret);
29542 export function CounterpartyCommitmentSecrets_provide_secret(this_arg: bigint, idx: bigint, secret: number): bigint {
29543 if(!isWasmInitialized) {
29544 throw new Error("initializeWasm() must be awaited first!");
29546 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_provide_secret(this_arg, idx, secret);
29547 return nativeResponseValue;
29549 // MUST_USE_RES struct LDKThirtyTwoBytes CounterpartyCommitmentSecrets_get_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx);
29551 export function CounterpartyCommitmentSecrets_get_secret(this_arg: bigint, idx: bigint): number {
29552 if(!isWasmInitialized) {
29553 throw new Error("initializeWasm() must be awaited first!");
29555 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_secret(this_arg, idx);
29556 return nativeResponseValue;
29558 // struct LDKCVec_u8Z CounterpartyCommitmentSecrets_write(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR obj);
29560 export function CounterpartyCommitmentSecrets_write(obj: bigint): number {
29561 if(!isWasmInitialized) {
29562 throw new Error("initializeWasm() must be awaited first!");
29564 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_write(obj);
29565 return nativeResponseValue;
29567 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CounterpartyCommitmentSecrets_read(struct LDKu8slice ser);
29569 export function CounterpartyCommitmentSecrets_read(ser: number): bigint {
29570 if(!isWasmInitialized) {
29571 throw new Error("initializeWasm() must be awaited first!");
29573 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_read(ser);
29574 return nativeResponseValue;
29576 // struct LDKSecretKey derive_private_key(struct LDKPublicKey per_commitment_point, const uint8_t (*base_secret)[32]);
29578 export function derive_private_key(per_commitment_point: number, base_secret: number): number {
29579 if(!isWasmInitialized) {
29580 throw new Error("initializeWasm() must be awaited first!");
29582 const nativeResponseValue = wasm.TS_derive_private_key(per_commitment_point, base_secret);
29583 return nativeResponseValue;
29585 // struct LDKPublicKey derive_public_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey base_point);
29587 export function derive_public_key(per_commitment_point: number, base_point: number): number {
29588 if(!isWasmInitialized) {
29589 throw new Error("initializeWasm() must be awaited first!");
29591 const nativeResponseValue = wasm.TS_derive_public_key(per_commitment_point, base_point);
29592 return nativeResponseValue;
29594 // struct LDKSecretKey derive_private_revocation_key(const uint8_t (*per_commitment_secret)[32], const uint8_t (*countersignatory_revocation_base_secret)[32]);
29596 export function derive_private_revocation_key(per_commitment_secret: number, countersignatory_revocation_base_secret: number): number {
29597 if(!isWasmInitialized) {
29598 throw new Error("initializeWasm() must be awaited first!");
29600 const nativeResponseValue = wasm.TS_derive_private_revocation_key(per_commitment_secret, countersignatory_revocation_base_secret);
29601 return nativeResponseValue;
29603 // struct LDKPublicKey derive_public_revocation_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey countersignatory_revocation_base_point);
29605 export function derive_public_revocation_key(per_commitment_point: number, countersignatory_revocation_base_point: number): number {
29606 if(!isWasmInitialized) {
29607 throw new Error("initializeWasm() must be awaited first!");
29609 const nativeResponseValue = wasm.TS_derive_public_revocation_key(per_commitment_point, countersignatory_revocation_base_point);
29610 return nativeResponseValue;
29612 // void TxCreationKeys_free(struct LDKTxCreationKeys this_obj);
29614 export function TxCreationKeys_free(this_obj: bigint): void {
29615 if(!isWasmInitialized) {
29616 throw new Error("initializeWasm() must be awaited first!");
29618 const nativeResponseValue = wasm.TS_TxCreationKeys_free(this_obj);
29619 // debug statements here
29621 // struct LDKPublicKey TxCreationKeys_get_per_commitment_point(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
29623 export function TxCreationKeys_get_per_commitment_point(this_ptr: bigint): number {
29624 if(!isWasmInitialized) {
29625 throw new Error("initializeWasm() must be awaited first!");
29627 const nativeResponseValue = wasm.TS_TxCreationKeys_get_per_commitment_point(this_ptr);
29628 return nativeResponseValue;
29630 // void TxCreationKeys_set_per_commitment_point(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29632 export function TxCreationKeys_set_per_commitment_point(this_ptr: bigint, val: number): void {
29633 if(!isWasmInitialized) {
29634 throw new Error("initializeWasm() must be awaited first!");
29636 const nativeResponseValue = wasm.TS_TxCreationKeys_set_per_commitment_point(this_ptr, val);
29637 // debug statements here
29639 // struct LDKPublicKey TxCreationKeys_get_revocation_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
29641 export function TxCreationKeys_get_revocation_key(this_ptr: bigint): number {
29642 if(!isWasmInitialized) {
29643 throw new Error("initializeWasm() must be awaited first!");
29645 const nativeResponseValue = wasm.TS_TxCreationKeys_get_revocation_key(this_ptr);
29646 return nativeResponseValue;
29648 // void TxCreationKeys_set_revocation_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29650 export function TxCreationKeys_set_revocation_key(this_ptr: bigint, val: number): void {
29651 if(!isWasmInitialized) {
29652 throw new Error("initializeWasm() must be awaited first!");
29654 const nativeResponseValue = wasm.TS_TxCreationKeys_set_revocation_key(this_ptr, val);
29655 // debug statements here
29657 // struct LDKPublicKey TxCreationKeys_get_broadcaster_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
29659 export function TxCreationKeys_get_broadcaster_htlc_key(this_ptr: bigint): number {
29660 if(!isWasmInitialized) {
29661 throw new Error("initializeWasm() must be awaited first!");
29663 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_htlc_key(this_ptr);
29664 return nativeResponseValue;
29666 // void TxCreationKeys_set_broadcaster_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29668 export function TxCreationKeys_set_broadcaster_htlc_key(this_ptr: bigint, val: number): void {
29669 if(!isWasmInitialized) {
29670 throw new Error("initializeWasm() must be awaited first!");
29672 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_htlc_key(this_ptr, val);
29673 // debug statements here
29675 // struct LDKPublicKey TxCreationKeys_get_countersignatory_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
29677 export function TxCreationKeys_get_countersignatory_htlc_key(this_ptr: bigint): number {
29678 if(!isWasmInitialized) {
29679 throw new Error("initializeWasm() must be awaited first!");
29681 const nativeResponseValue = wasm.TS_TxCreationKeys_get_countersignatory_htlc_key(this_ptr);
29682 return nativeResponseValue;
29684 // void TxCreationKeys_set_countersignatory_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29686 export function TxCreationKeys_set_countersignatory_htlc_key(this_ptr: bigint, val: number): void {
29687 if(!isWasmInitialized) {
29688 throw new Error("initializeWasm() must be awaited first!");
29690 const nativeResponseValue = wasm.TS_TxCreationKeys_set_countersignatory_htlc_key(this_ptr, val);
29691 // debug statements here
29693 // struct LDKPublicKey TxCreationKeys_get_broadcaster_delayed_payment_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
29695 export function TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr: bigint): number {
29696 if(!isWasmInitialized) {
29697 throw new Error("initializeWasm() must be awaited first!");
29699 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr);
29700 return nativeResponseValue;
29702 // void TxCreationKeys_set_broadcaster_delayed_payment_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29704 export function TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr: bigint, val: number): void {
29705 if(!isWasmInitialized) {
29706 throw new Error("initializeWasm() must be awaited first!");
29708 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr, val);
29709 // debug statements here
29711 // 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);
29713 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 {
29714 if(!isWasmInitialized) {
29715 throw new Error("initializeWasm() must be awaited first!");
29717 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);
29718 return nativeResponseValue;
29720 // bool TxCreationKeys_eq(const struct LDKTxCreationKeys *NONNULL_PTR a, const struct LDKTxCreationKeys *NONNULL_PTR b);
29722 export function TxCreationKeys_eq(a: bigint, b: bigint): boolean {
29723 if(!isWasmInitialized) {
29724 throw new Error("initializeWasm() must be awaited first!");
29726 const nativeResponseValue = wasm.TS_TxCreationKeys_eq(a, b);
29727 return nativeResponseValue;
29729 // uint64_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg);
29731 export function TxCreationKeys_clone_ptr(arg: bigint): bigint {
29732 if(!isWasmInitialized) {
29733 throw new Error("initializeWasm() must be awaited first!");
29735 const nativeResponseValue = wasm.TS_TxCreationKeys_clone_ptr(arg);
29736 return nativeResponseValue;
29738 // struct LDKTxCreationKeys TxCreationKeys_clone(const struct LDKTxCreationKeys *NONNULL_PTR orig);
29740 export function TxCreationKeys_clone(orig: bigint): bigint {
29741 if(!isWasmInitialized) {
29742 throw new Error("initializeWasm() must be awaited first!");
29744 const nativeResponseValue = wasm.TS_TxCreationKeys_clone(orig);
29745 return nativeResponseValue;
29747 // struct LDKCVec_u8Z TxCreationKeys_write(const struct LDKTxCreationKeys *NONNULL_PTR obj);
29749 export function TxCreationKeys_write(obj: bigint): number {
29750 if(!isWasmInitialized) {
29751 throw new Error("initializeWasm() must be awaited first!");
29753 const nativeResponseValue = wasm.TS_TxCreationKeys_write(obj);
29754 return nativeResponseValue;
29756 // struct LDKCResult_TxCreationKeysDecodeErrorZ TxCreationKeys_read(struct LDKu8slice ser);
29758 export function TxCreationKeys_read(ser: number): bigint {
29759 if(!isWasmInitialized) {
29760 throw new Error("initializeWasm() must be awaited first!");
29762 const nativeResponseValue = wasm.TS_TxCreationKeys_read(ser);
29763 return nativeResponseValue;
29765 // void ChannelPublicKeys_free(struct LDKChannelPublicKeys this_obj);
29767 export function ChannelPublicKeys_free(this_obj: bigint): void {
29768 if(!isWasmInitialized) {
29769 throw new Error("initializeWasm() must be awaited first!");
29771 const nativeResponseValue = wasm.TS_ChannelPublicKeys_free(this_obj);
29772 // debug statements here
29774 // struct LDKPublicKey ChannelPublicKeys_get_funding_pubkey(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
29776 export function ChannelPublicKeys_get_funding_pubkey(this_ptr: bigint): number {
29777 if(!isWasmInitialized) {
29778 throw new Error("initializeWasm() must be awaited first!");
29780 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_funding_pubkey(this_ptr);
29781 return nativeResponseValue;
29783 // void ChannelPublicKeys_set_funding_pubkey(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29785 export function ChannelPublicKeys_set_funding_pubkey(this_ptr: bigint, val: number): void {
29786 if(!isWasmInitialized) {
29787 throw new Error("initializeWasm() must be awaited first!");
29789 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_funding_pubkey(this_ptr, val);
29790 // debug statements here
29792 // struct LDKPublicKey ChannelPublicKeys_get_revocation_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
29794 export function ChannelPublicKeys_get_revocation_basepoint(this_ptr: bigint): number {
29795 if(!isWasmInitialized) {
29796 throw new Error("initializeWasm() must be awaited first!");
29798 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_revocation_basepoint(this_ptr);
29799 return nativeResponseValue;
29801 // void ChannelPublicKeys_set_revocation_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29803 export function ChannelPublicKeys_set_revocation_basepoint(this_ptr: bigint, val: number): void {
29804 if(!isWasmInitialized) {
29805 throw new Error("initializeWasm() must be awaited first!");
29807 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_revocation_basepoint(this_ptr, val);
29808 // debug statements here
29810 // struct LDKPublicKey ChannelPublicKeys_get_payment_point(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
29812 export function ChannelPublicKeys_get_payment_point(this_ptr: bigint): number {
29813 if(!isWasmInitialized) {
29814 throw new Error("initializeWasm() must be awaited first!");
29816 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_payment_point(this_ptr);
29817 return nativeResponseValue;
29819 // void ChannelPublicKeys_set_payment_point(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29821 export function ChannelPublicKeys_set_payment_point(this_ptr: bigint, val: number): void {
29822 if(!isWasmInitialized) {
29823 throw new Error("initializeWasm() must be awaited first!");
29825 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_payment_point(this_ptr, val);
29826 // debug statements here
29828 // struct LDKPublicKey ChannelPublicKeys_get_delayed_payment_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
29830 export function ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr: bigint): number {
29831 if(!isWasmInitialized) {
29832 throw new Error("initializeWasm() must be awaited first!");
29834 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr);
29835 return nativeResponseValue;
29837 // void ChannelPublicKeys_set_delayed_payment_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29839 export function ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
29840 if(!isWasmInitialized) {
29841 throw new Error("initializeWasm() must be awaited first!");
29843 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr, val);
29844 // debug statements here
29846 // struct LDKPublicKey ChannelPublicKeys_get_htlc_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
29848 export function ChannelPublicKeys_get_htlc_basepoint(this_ptr: bigint): number {
29849 if(!isWasmInitialized) {
29850 throw new Error("initializeWasm() must be awaited first!");
29852 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_htlc_basepoint(this_ptr);
29853 return nativeResponseValue;
29855 // void ChannelPublicKeys_set_htlc_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29857 export function ChannelPublicKeys_set_htlc_basepoint(this_ptr: bigint, val: number): void {
29858 if(!isWasmInitialized) {
29859 throw new Error("initializeWasm() must be awaited first!");
29861 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_htlc_basepoint(this_ptr, val);
29862 // debug statements here
29864 // 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);
29866 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 {
29867 if(!isWasmInitialized) {
29868 throw new Error("initializeWasm() must be awaited first!");
29870 const nativeResponseValue = wasm.TS_ChannelPublicKeys_new(funding_pubkey_arg, revocation_basepoint_arg, payment_point_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg);
29871 return nativeResponseValue;
29873 // uint64_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg);
29875 export function ChannelPublicKeys_clone_ptr(arg: bigint): bigint {
29876 if(!isWasmInitialized) {
29877 throw new Error("initializeWasm() must be awaited first!");
29879 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone_ptr(arg);
29880 return nativeResponseValue;
29882 // struct LDKChannelPublicKeys ChannelPublicKeys_clone(const struct LDKChannelPublicKeys *NONNULL_PTR orig);
29884 export function ChannelPublicKeys_clone(orig: bigint): bigint {
29885 if(!isWasmInitialized) {
29886 throw new Error("initializeWasm() must be awaited first!");
29888 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone(orig);
29889 return nativeResponseValue;
29891 // bool ChannelPublicKeys_eq(const struct LDKChannelPublicKeys *NONNULL_PTR a, const struct LDKChannelPublicKeys *NONNULL_PTR b);
29893 export function ChannelPublicKeys_eq(a: bigint, b: bigint): boolean {
29894 if(!isWasmInitialized) {
29895 throw new Error("initializeWasm() must be awaited first!");
29897 const nativeResponseValue = wasm.TS_ChannelPublicKeys_eq(a, b);
29898 return nativeResponseValue;
29900 // struct LDKCVec_u8Z ChannelPublicKeys_write(const struct LDKChannelPublicKeys *NONNULL_PTR obj);
29902 export function ChannelPublicKeys_write(obj: bigint): number {
29903 if(!isWasmInitialized) {
29904 throw new Error("initializeWasm() must be awaited first!");
29906 const nativeResponseValue = wasm.TS_ChannelPublicKeys_write(obj);
29907 return nativeResponseValue;
29909 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ ChannelPublicKeys_read(struct LDKu8slice ser);
29911 export function ChannelPublicKeys_read(ser: number): bigint {
29912 if(!isWasmInitialized) {
29913 throw new Error("initializeWasm() must be awaited first!");
29915 const nativeResponseValue = wasm.TS_ChannelPublicKeys_read(ser);
29916 return nativeResponseValue;
29918 // MUST_USE_RES struct LDKTxCreationKeys 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);
29920 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 {
29921 if(!isWasmInitialized) {
29922 throw new Error("initializeWasm() must be awaited first!");
29924 const nativeResponseValue = wasm.TS_TxCreationKeys_derive_new(per_commitment_point, broadcaster_delayed_payment_base, broadcaster_htlc_base, countersignatory_revocation_base, countersignatory_htlc_base);
29925 return nativeResponseValue;
29927 // MUST_USE_RES struct LDKTxCreationKeys TxCreationKeys_from_channel_static_keys(struct LDKPublicKey per_commitment_point, const struct LDKChannelPublicKeys *NONNULL_PTR broadcaster_keys, const struct LDKChannelPublicKeys *NONNULL_PTR countersignatory_keys);
29929 export function TxCreationKeys_from_channel_static_keys(per_commitment_point: number, broadcaster_keys: bigint, countersignatory_keys: bigint): bigint {
29930 if(!isWasmInitialized) {
29931 throw new Error("initializeWasm() must be awaited first!");
29933 const nativeResponseValue = wasm.TS_TxCreationKeys_from_channel_static_keys(per_commitment_point, broadcaster_keys, countersignatory_keys);
29934 return nativeResponseValue;
29936 // struct LDKCVec_u8Z get_revokeable_redeemscript(struct LDKPublicKey revocation_key, uint16_t contest_delay, struct LDKPublicKey broadcaster_delayed_payment_key);
29938 export function get_revokeable_redeemscript(revocation_key: number, contest_delay: number, broadcaster_delayed_payment_key: number): number {
29939 if(!isWasmInitialized) {
29940 throw new Error("initializeWasm() must be awaited first!");
29942 const nativeResponseValue = wasm.TS_get_revokeable_redeemscript(revocation_key, contest_delay, broadcaster_delayed_payment_key);
29943 return nativeResponseValue;
29945 // void HTLCOutputInCommitment_free(struct LDKHTLCOutputInCommitment this_obj);
29947 export function HTLCOutputInCommitment_free(this_obj: bigint): void {
29948 if(!isWasmInitialized) {
29949 throw new Error("initializeWasm() must be awaited first!");
29951 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_free(this_obj);
29952 // debug statements here
29954 // bool HTLCOutputInCommitment_get_offered(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
29956 export function HTLCOutputInCommitment_get_offered(this_ptr: bigint): boolean {
29957 if(!isWasmInitialized) {
29958 throw new Error("initializeWasm() must be awaited first!");
29960 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_offered(this_ptr);
29961 return nativeResponseValue;
29963 // void HTLCOutputInCommitment_set_offered(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, bool val);
29965 export function HTLCOutputInCommitment_set_offered(this_ptr: bigint, val: boolean): void {
29966 if(!isWasmInitialized) {
29967 throw new Error("initializeWasm() must be awaited first!");
29969 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_offered(this_ptr, val);
29970 // debug statements here
29972 // uint64_t HTLCOutputInCommitment_get_amount_msat(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
29974 export function HTLCOutputInCommitment_get_amount_msat(this_ptr: bigint): bigint {
29975 if(!isWasmInitialized) {
29976 throw new Error("initializeWasm() must be awaited first!");
29978 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_amount_msat(this_ptr);
29979 return nativeResponseValue;
29981 // void HTLCOutputInCommitment_set_amount_msat(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint64_t val);
29983 export function HTLCOutputInCommitment_set_amount_msat(this_ptr: bigint, val: bigint): void {
29984 if(!isWasmInitialized) {
29985 throw new Error("initializeWasm() must be awaited first!");
29987 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_amount_msat(this_ptr, val);
29988 // debug statements here
29990 // uint32_t HTLCOutputInCommitment_get_cltv_expiry(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
29992 export function HTLCOutputInCommitment_get_cltv_expiry(this_ptr: bigint): number {
29993 if(!isWasmInitialized) {
29994 throw new Error("initializeWasm() must be awaited first!");
29996 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_cltv_expiry(this_ptr);
29997 return nativeResponseValue;
29999 // void HTLCOutputInCommitment_set_cltv_expiry(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint32_t val);
30001 export function HTLCOutputInCommitment_set_cltv_expiry(this_ptr: bigint, val: number): void {
30002 if(!isWasmInitialized) {
30003 throw new Error("initializeWasm() must be awaited first!");
30005 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_cltv_expiry(this_ptr, val);
30006 // debug statements here
30008 // const uint8_t (*HTLCOutputInCommitment_get_payment_hash(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr))[32];
30010 export function HTLCOutputInCommitment_get_payment_hash(this_ptr: bigint): number {
30011 if(!isWasmInitialized) {
30012 throw new Error("initializeWasm() must be awaited first!");
30014 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_payment_hash(this_ptr);
30015 return nativeResponseValue;
30017 // void HTLCOutputInCommitment_set_payment_hash(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
30019 export function HTLCOutputInCommitment_set_payment_hash(this_ptr: bigint, val: number): void {
30020 if(!isWasmInitialized) {
30021 throw new Error("initializeWasm() must be awaited first!");
30023 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_payment_hash(this_ptr, val);
30024 // debug statements here
30026 // struct LDKCOption_u32Z HTLCOutputInCommitment_get_transaction_output_index(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
30028 export function HTLCOutputInCommitment_get_transaction_output_index(this_ptr: bigint): bigint {
30029 if(!isWasmInitialized) {
30030 throw new Error("initializeWasm() must be awaited first!");
30032 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_transaction_output_index(this_ptr);
30033 return nativeResponseValue;
30035 // void HTLCOutputInCommitment_set_transaction_output_index(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
30037 export function HTLCOutputInCommitment_set_transaction_output_index(this_ptr: bigint, val: bigint): void {
30038 if(!isWasmInitialized) {
30039 throw new Error("initializeWasm() must be awaited first!");
30041 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_transaction_output_index(this_ptr, val);
30042 // debug statements here
30044 // 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);
30046 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 {
30047 if(!isWasmInitialized) {
30048 throw new Error("initializeWasm() must be awaited first!");
30050 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg, transaction_output_index_arg);
30051 return nativeResponseValue;
30053 // uint64_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg);
30055 export function HTLCOutputInCommitment_clone_ptr(arg: bigint): bigint {
30056 if(!isWasmInitialized) {
30057 throw new Error("initializeWasm() must be awaited first!");
30059 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone_ptr(arg);
30060 return nativeResponseValue;
30062 // struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_clone(const struct LDKHTLCOutputInCommitment *NONNULL_PTR orig);
30064 export function HTLCOutputInCommitment_clone(orig: bigint): bigint {
30065 if(!isWasmInitialized) {
30066 throw new Error("initializeWasm() must be awaited first!");
30068 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone(orig);
30069 return nativeResponseValue;
30071 // bool HTLCOutputInCommitment_eq(const struct LDKHTLCOutputInCommitment *NONNULL_PTR a, const struct LDKHTLCOutputInCommitment *NONNULL_PTR b);
30073 export function HTLCOutputInCommitment_eq(a: bigint, b: bigint): boolean {
30074 if(!isWasmInitialized) {
30075 throw new Error("initializeWasm() must be awaited first!");
30077 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_eq(a, b);
30078 return nativeResponseValue;
30080 // struct LDKCVec_u8Z HTLCOutputInCommitment_write(const struct LDKHTLCOutputInCommitment *NONNULL_PTR obj);
30082 export function HTLCOutputInCommitment_write(obj: bigint): number {
30083 if(!isWasmInitialized) {
30084 throw new Error("initializeWasm() must be awaited first!");
30086 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_write(obj);
30087 return nativeResponseValue;
30089 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ HTLCOutputInCommitment_read(struct LDKu8slice ser);
30091 export function HTLCOutputInCommitment_read(ser: number): bigint {
30092 if(!isWasmInitialized) {
30093 throw new Error("initializeWasm() must be awaited first!");
30095 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_read(ser);
30096 return nativeResponseValue;
30098 // struct LDKCVec_u8Z get_htlc_redeemscript(const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc, bool opt_anchors, const struct LDKTxCreationKeys *NONNULL_PTR keys);
30100 export function get_htlc_redeemscript(htlc: bigint, opt_anchors: boolean, keys: bigint): number {
30101 if(!isWasmInitialized) {
30102 throw new Error("initializeWasm() must be awaited first!");
30104 const nativeResponseValue = wasm.TS_get_htlc_redeemscript(htlc, opt_anchors, keys);
30105 return nativeResponseValue;
30107 // struct LDKCVec_u8Z make_funding_redeemscript(struct LDKPublicKey broadcaster, struct LDKPublicKey countersignatory);
30109 export function make_funding_redeemscript(broadcaster: number, countersignatory: number): number {
30110 if(!isWasmInitialized) {
30111 throw new Error("initializeWasm() must be awaited first!");
30113 const nativeResponseValue = wasm.TS_make_funding_redeemscript(broadcaster, countersignatory);
30114 return nativeResponseValue;
30116 // 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, bool use_non_zero_fee_anchors, struct LDKPublicKey broadcaster_delayed_payment_key, struct LDKPublicKey revocation_key);
30118 export function build_htlc_transaction(commitment_txid: number, feerate_per_kw: number, contest_delay: number, htlc: bigint, opt_anchors: boolean, use_non_zero_fee_anchors: boolean, broadcaster_delayed_payment_key: number, revocation_key: number): number {
30119 if(!isWasmInitialized) {
30120 throw new Error("initializeWasm() must be awaited first!");
30122 const nativeResponseValue = wasm.TS_build_htlc_transaction(commitment_txid, feerate_per_kw, contest_delay, htlc, opt_anchors, use_non_zero_fee_anchors, broadcaster_delayed_payment_key, revocation_key);
30123 return nativeResponseValue;
30125 // struct LDKWitness build_htlc_input_witness(struct LDKSignature local_sig, struct LDKSignature remote_sig, struct LDKThirtyTwoBytes preimage, struct LDKu8slice redeem_script, bool opt_anchors);
30127 export function build_htlc_input_witness(local_sig: number, remote_sig: number, preimage: number, redeem_script: number, opt_anchors: boolean): number {
30128 if(!isWasmInitialized) {
30129 throw new Error("initializeWasm() must be awaited first!");
30131 const nativeResponseValue = wasm.TS_build_htlc_input_witness(local_sig, remote_sig, preimage, redeem_script, opt_anchors);
30132 return nativeResponseValue;
30134 // struct LDKCVec_u8Z get_to_countersignatory_with_anchors_redeemscript(struct LDKPublicKey payment_point);
30136 export function get_to_countersignatory_with_anchors_redeemscript(payment_point: number): number {
30137 if(!isWasmInitialized) {
30138 throw new Error("initializeWasm() must be awaited first!");
30140 const nativeResponseValue = wasm.TS_get_to_countersignatory_with_anchors_redeemscript(payment_point);
30141 return nativeResponseValue;
30143 // struct LDKCVec_u8Z get_anchor_redeemscript(struct LDKPublicKey funding_pubkey);
30145 export function get_anchor_redeemscript(funding_pubkey: number): number {
30146 if(!isWasmInitialized) {
30147 throw new Error("initializeWasm() must be awaited first!");
30149 const nativeResponseValue = wasm.TS_get_anchor_redeemscript(funding_pubkey);
30150 return nativeResponseValue;
30152 // struct LDKWitness build_anchor_input_witness(struct LDKPublicKey funding_key, struct LDKSignature funding_sig);
30154 export function build_anchor_input_witness(funding_key: number, funding_sig: number): number {
30155 if(!isWasmInitialized) {
30156 throw new Error("initializeWasm() must be awaited first!");
30158 const nativeResponseValue = wasm.TS_build_anchor_input_witness(funding_key, funding_sig);
30159 return nativeResponseValue;
30161 // void ChannelTransactionParameters_free(struct LDKChannelTransactionParameters this_obj);
30163 export function ChannelTransactionParameters_free(this_obj: bigint): void {
30164 if(!isWasmInitialized) {
30165 throw new Error("initializeWasm() must be awaited first!");
30167 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_free(this_obj);
30168 // debug statements here
30170 // struct LDKChannelPublicKeys ChannelTransactionParameters_get_holder_pubkeys(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
30172 export function ChannelTransactionParameters_get_holder_pubkeys(this_ptr: bigint): bigint {
30173 if(!isWasmInitialized) {
30174 throw new Error("initializeWasm() must be awaited first!");
30176 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_pubkeys(this_ptr);
30177 return nativeResponseValue;
30179 // void ChannelTransactionParameters_set_holder_pubkeys(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
30181 export function ChannelTransactionParameters_set_holder_pubkeys(this_ptr: bigint, val: bigint): void {
30182 if(!isWasmInitialized) {
30183 throw new Error("initializeWasm() must be awaited first!");
30185 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_pubkeys(this_ptr, val);
30186 // debug statements here
30188 // uint16_t ChannelTransactionParameters_get_holder_selected_contest_delay(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
30190 export function ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr: bigint): number {
30191 if(!isWasmInitialized) {
30192 throw new Error("initializeWasm() must be awaited first!");
30194 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr);
30195 return nativeResponseValue;
30197 // void ChannelTransactionParameters_set_holder_selected_contest_delay(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
30199 export function ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr: bigint, val: number): void {
30200 if(!isWasmInitialized) {
30201 throw new Error("initializeWasm() must be awaited first!");
30203 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr, val);
30204 // debug statements here
30206 // bool ChannelTransactionParameters_get_is_outbound_from_holder(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
30208 export function ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr: bigint): boolean {
30209 if(!isWasmInitialized) {
30210 throw new Error("initializeWasm() must be awaited first!");
30212 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr);
30213 return nativeResponseValue;
30215 // void ChannelTransactionParameters_set_is_outbound_from_holder(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, bool val);
30217 export function ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr: bigint, val: boolean): void {
30218 if(!isWasmInitialized) {
30219 throw new Error("initializeWasm() must be awaited first!");
30221 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr, val);
30222 // debug statements here
30224 // struct LDKCounterpartyChannelTransactionParameters ChannelTransactionParameters_get_counterparty_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
30226 export function ChannelTransactionParameters_get_counterparty_parameters(this_ptr: bigint): bigint {
30227 if(!isWasmInitialized) {
30228 throw new Error("initializeWasm() must be awaited first!");
30230 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_counterparty_parameters(this_ptr);
30231 return nativeResponseValue;
30233 // void ChannelTransactionParameters_set_counterparty_parameters(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKCounterpartyChannelTransactionParameters val);
30235 export function ChannelTransactionParameters_set_counterparty_parameters(this_ptr: bigint, val: bigint): void {
30236 if(!isWasmInitialized) {
30237 throw new Error("initializeWasm() must be awaited first!");
30239 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_counterparty_parameters(this_ptr, val);
30240 // debug statements here
30242 // struct LDKOutPoint ChannelTransactionParameters_get_funding_outpoint(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
30244 export function ChannelTransactionParameters_get_funding_outpoint(this_ptr: bigint): bigint {
30245 if(!isWasmInitialized) {
30246 throw new Error("initializeWasm() must be awaited first!");
30248 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_funding_outpoint(this_ptr);
30249 return nativeResponseValue;
30251 // void ChannelTransactionParameters_set_funding_outpoint(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKOutPoint val);
30253 export function ChannelTransactionParameters_set_funding_outpoint(this_ptr: bigint, val: bigint): void {
30254 if(!isWasmInitialized) {
30255 throw new Error("initializeWasm() must be awaited first!");
30257 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_funding_outpoint(this_ptr, val);
30258 // debug statements here
30260 // enum LDKCOption_NoneZ ChannelTransactionParameters_get_opt_anchors(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
30262 export function ChannelTransactionParameters_get_opt_anchors(this_ptr: bigint): COption_NoneZ {
30263 if(!isWasmInitialized) {
30264 throw new Error("initializeWasm() must be awaited first!");
30266 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_opt_anchors(this_ptr);
30267 return nativeResponseValue;
30269 // void ChannelTransactionParameters_set_opt_anchors(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
30271 export function ChannelTransactionParameters_set_opt_anchors(this_ptr: bigint, val: COption_NoneZ): void {
30272 if(!isWasmInitialized) {
30273 throw new Error("initializeWasm() must be awaited first!");
30275 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_opt_anchors(this_ptr, val);
30276 // debug statements here
30278 // enum LDKCOption_NoneZ ChannelTransactionParameters_get_opt_non_zero_fee_anchors(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
30280 export function ChannelTransactionParameters_get_opt_non_zero_fee_anchors(this_ptr: bigint): COption_NoneZ {
30281 if(!isWasmInitialized) {
30282 throw new Error("initializeWasm() must be awaited first!");
30284 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_opt_non_zero_fee_anchors(this_ptr);
30285 return nativeResponseValue;
30287 // void ChannelTransactionParameters_set_opt_non_zero_fee_anchors(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
30289 export function ChannelTransactionParameters_set_opt_non_zero_fee_anchors(this_ptr: bigint, val: COption_NoneZ): void {
30290 if(!isWasmInitialized) {
30291 throw new Error("initializeWasm() must be awaited first!");
30293 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_opt_non_zero_fee_anchors(this_ptr, val);
30294 // debug statements here
30296 // 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, enum LDKCOption_NoneZ opt_non_zero_fee_anchors_arg);
30298 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, opt_non_zero_fee_anchors_arg: COption_NoneZ): bigint {
30299 if(!isWasmInitialized) {
30300 throw new Error("initializeWasm() must be awaited first!");
30302 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, opt_non_zero_fee_anchors_arg);
30303 return nativeResponseValue;
30305 // uint64_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg);
30307 export function ChannelTransactionParameters_clone_ptr(arg: bigint): bigint {
30308 if(!isWasmInitialized) {
30309 throw new Error("initializeWasm() must be awaited first!");
30311 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone_ptr(arg);
30312 return nativeResponseValue;
30314 // struct LDKChannelTransactionParameters ChannelTransactionParameters_clone(const struct LDKChannelTransactionParameters *NONNULL_PTR orig);
30316 export function ChannelTransactionParameters_clone(orig: bigint): bigint {
30317 if(!isWasmInitialized) {
30318 throw new Error("initializeWasm() must be awaited first!");
30320 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone(orig);
30321 return nativeResponseValue;
30323 // void CounterpartyChannelTransactionParameters_free(struct LDKCounterpartyChannelTransactionParameters this_obj);
30325 export function CounterpartyChannelTransactionParameters_free(this_obj: bigint): void {
30326 if(!isWasmInitialized) {
30327 throw new Error("initializeWasm() must be awaited first!");
30329 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_free(this_obj);
30330 // debug statements here
30332 // struct LDKChannelPublicKeys CounterpartyChannelTransactionParameters_get_pubkeys(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
30334 export function CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr: bigint): bigint {
30335 if(!isWasmInitialized) {
30336 throw new Error("initializeWasm() must be awaited first!");
30338 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr);
30339 return nativeResponseValue;
30341 // void CounterpartyChannelTransactionParameters_set_pubkeys(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
30343 export function CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr: bigint, val: bigint): void {
30344 if(!isWasmInitialized) {
30345 throw new Error("initializeWasm() must be awaited first!");
30347 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr, val);
30348 // debug statements here
30350 // uint16_t CounterpartyChannelTransactionParameters_get_selected_contest_delay(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
30352 export function CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr: bigint): number {
30353 if(!isWasmInitialized) {
30354 throw new Error("initializeWasm() must be awaited first!");
30356 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr);
30357 return nativeResponseValue;
30359 // void CounterpartyChannelTransactionParameters_set_selected_contest_delay(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
30361 export function CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr: bigint, val: number): void {
30362 if(!isWasmInitialized) {
30363 throw new Error("initializeWasm() must be awaited first!");
30365 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr, val);
30366 // debug statements here
30368 // MUST_USE_RES struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_new(struct LDKChannelPublicKeys pubkeys_arg, uint16_t selected_contest_delay_arg);
30370 export function CounterpartyChannelTransactionParameters_new(pubkeys_arg: bigint, selected_contest_delay_arg: number): bigint {
30371 if(!isWasmInitialized) {
30372 throw new Error("initializeWasm() must be awaited first!");
30374 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_new(pubkeys_arg, selected_contest_delay_arg);
30375 return nativeResponseValue;
30377 // uint64_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg);
30379 export function CounterpartyChannelTransactionParameters_clone_ptr(arg: bigint): bigint {
30380 if(!isWasmInitialized) {
30381 throw new Error("initializeWasm() must be awaited first!");
30383 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone_ptr(arg);
30384 return nativeResponseValue;
30386 // struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_clone(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR orig);
30388 export function CounterpartyChannelTransactionParameters_clone(orig: bigint): bigint {
30389 if(!isWasmInitialized) {
30390 throw new Error("initializeWasm() must be awaited first!");
30392 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone(orig);
30393 return nativeResponseValue;
30395 // MUST_USE_RES bool ChannelTransactionParameters_is_populated(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
30397 export function ChannelTransactionParameters_is_populated(this_arg: bigint): boolean {
30398 if(!isWasmInitialized) {
30399 throw new Error("initializeWasm() must be awaited first!");
30401 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_is_populated(this_arg);
30402 return nativeResponseValue;
30404 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_holder_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
30406 export function ChannelTransactionParameters_as_holder_broadcastable(this_arg: bigint): bigint {
30407 if(!isWasmInitialized) {
30408 throw new Error("initializeWasm() must be awaited first!");
30410 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_holder_broadcastable(this_arg);
30411 return nativeResponseValue;
30413 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_counterparty_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
30415 export function ChannelTransactionParameters_as_counterparty_broadcastable(this_arg: bigint): bigint {
30416 if(!isWasmInitialized) {
30417 throw new Error("initializeWasm() must be awaited first!");
30419 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_counterparty_broadcastable(this_arg);
30420 return nativeResponseValue;
30422 // struct LDKCVec_u8Z CounterpartyChannelTransactionParameters_write(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR obj);
30424 export function CounterpartyChannelTransactionParameters_write(obj: bigint): number {
30425 if(!isWasmInitialized) {
30426 throw new Error("initializeWasm() must be awaited first!");
30428 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_write(obj);
30429 return nativeResponseValue;
30431 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CounterpartyChannelTransactionParameters_read(struct LDKu8slice ser);
30433 export function CounterpartyChannelTransactionParameters_read(ser: number): bigint {
30434 if(!isWasmInitialized) {
30435 throw new Error("initializeWasm() must be awaited first!");
30437 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_read(ser);
30438 return nativeResponseValue;
30440 // struct LDKCVec_u8Z ChannelTransactionParameters_write(const struct LDKChannelTransactionParameters *NONNULL_PTR obj);
30442 export function ChannelTransactionParameters_write(obj: bigint): number {
30443 if(!isWasmInitialized) {
30444 throw new Error("initializeWasm() must be awaited first!");
30446 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_write(obj);
30447 return nativeResponseValue;
30449 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ ChannelTransactionParameters_read(struct LDKu8slice ser);
30451 export function ChannelTransactionParameters_read(ser: number): bigint {
30452 if(!isWasmInitialized) {
30453 throw new Error("initializeWasm() must be awaited first!");
30455 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_read(ser);
30456 return nativeResponseValue;
30458 // void DirectedChannelTransactionParameters_free(struct LDKDirectedChannelTransactionParameters this_obj);
30460 export function DirectedChannelTransactionParameters_free(this_obj: bigint): void {
30461 if(!isWasmInitialized) {
30462 throw new Error("initializeWasm() must be awaited first!");
30464 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_free(this_obj);
30465 // debug statements here
30467 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_broadcaster_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
30469 export function DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg: bigint): bigint {
30470 if(!isWasmInitialized) {
30471 throw new Error("initializeWasm() must be awaited first!");
30473 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg);
30474 return nativeResponseValue;
30476 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_countersignatory_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
30478 export function DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg: bigint): bigint {
30479 if(!isWasmInitialized) {
30480 throw new Error("initializeWasm() must be awaited first!");
30482 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg);
30483 return nativeResponseValue;
30485 // MUST_USE_RES uint16_t DirectedChannelTransactionParameters_contest_delay(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
30487 export function DirectedChannelTransactionParameters_contest_delay(this_arg: bigint): number {
30488 if(!isWasmInitialized) {
30489 throw new Error("initializeWasm() must be awaited first!");
30491 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_contest_delay(this_arg);
30492 return nativeResponseValue;
30494 // MUST_USE_RES bool DirectedChannelTransactionParameters_is_outbound(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
30496 export function DirectedChannelTransactionParameters_is_outbound(this_arg: bigint): boolean {
30497 if(!isWasmInitialized) {
30498 throw new Error("initializeWasm() must be awaited first!");
30500 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_is_outbound(this_arg);
30501 return nativeResponseValue;
30503 // MUST_USE_RES struct LDKOutPoint DirectedChannelTransactionParameters_funding_outpoint(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
30505 export function DirectedChannelTransactionParameters_funding_outpoint(this_arg: bigint): bigint {
30506 if(!isWasmInitialized) {
30507 throw new Error("initializeWasm() must be awaited first!");
30509 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_funding_outpoint(this_arg);
30510 return nativeResponseValue;
30512 // MUST_USE_RES bool DirectedChannelTransactionParameters_opt_anchors(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
30514 export function DirectedChannelTransactionParameters_opt_anchors(this_arg: bigint): boolean {
30515 if(!isWasmInitialized) {
30516 throw new Error("initializeWasm() must be awaited first!");
30518 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_opt_anchors(this_arg);
30519 return nativeResponseValue;
30521 // void HolderCommitmentTransaction_free(struct LDKHolderCommitmentTransaction this_obj);
30523 export function HolderCommitmentTransaction_free(this_obj: bigint): void {
30524 if(!isWasmInitialized) {
30525 throw new Error("initializeWasm() must be awaited first!");
30527 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_free(this_obj);
30528 // debug statements here
30530 // struct LDKSignature HolderCommitmentTransaction_get_counterparty_sig(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
30532 export function HolderCommitmentTransaction_get_counterparty_sig(this_ptr: bigint): number {
30533 if(!isWasmInitialized) {
30534 throw new Error("initializeWasm() must be awaited first!");
30536 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_sig(this_ptr);
30537 return nativeResponseValue;
30539 // void HolderCommitmentTransaction_set_counterparty_sig(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKSignature val);
30541 export function HolderCommitmentTransaction_set_counterparty_sig(this_ptr: bigint, val: number): void {
30542 if(!isWasmInitialized) {
30543 throw new Error("initializeWasm() must be awaited first!");
30545 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_sig(this_ptr, val);
30546 // debug statements here
30548 // struct LDKCVec_SignatureZ HolderCommitmentTransaction_get_counterparty_htlc_sigs(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
30550 export function HolderCommitmentTransaction_get_counterparty_htlc_sigs(this_ptr: bigint): number {
30551 if(!isWasmInitialized) {
30552 throw new Error("initializeWasm() must be awaited first!");
30554 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_htlc_sigs(this_ptr);
30555 return nativeResponseValue;
30557 // void HolderCommitmentTransaction_set_counterparty_htlc_sigs(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
30559 export function HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr: bigint, val: number): void {
30560 if(!isWasmInitialized) {
30561 throw new Error("initializeWasm() must be awaited first!");
30563 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr, val);
30564 // debug statements here
30566 // uint64_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg);
30568 export function HolderCommitmentTransaction_clone_ptr(arg: bigint): bigint {
30569 if(!isWasmInitialized) {
30570 throw new Error("initializeWasm() must be awaited first!");
30572 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone_ptr(arg);
30573 return nativeResponseValue;
30575 // struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_clone(const struct LDKHolderCommitmentTransaction *NONNULL_PTR orig);
30577 export function HolderCommitmentTransaction_clone(orig: bigint): bigint {
30578 if(!isWasmInitialized) {
30579 throw new Error("initializeWasm() must be awaited first!");
30581 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone(orig);
30582 return nativeResponseValue;
30584 // struct LDKCVec_u8Z HolderCommitmentTransaction_write(const struct LDKHolderCommitmentTransaction *NONNULL_PTR obj);
30586 export function HolderCommitmentTransaction_write(obj: bigint): number {
30587 if(!isWasmInitialized) {
30588 throw new Error("initializeWasm() must be awaited first!");
30590 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_write(obj);
30591 return nativeResponseValue;
30593 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ HolderCommitmentTransaction_read(struct LDKu8slice ser);
30595 export function HolderCommitmentTransaction_read(ser: number): bigint {
30596 if(!isWasmInitialized) {
30597 throw new Error("initializeWasm() must be awaited first!");
30599 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_read(ser);
30600 return nativeResponseValue;
30602 // 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);
30604 export function HolderCommitmentTransaction_new(commitment_tx: bigint, counterparty_sig: number, counterparty_htlc_sigs: number, holder_funding_key: number, counterparty_funding_key: number): bigint {
30605 if(!isWasmInitialized) {
30606 throw new Error("initializeWasm() must be awaited first!");
30608 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_new(commitment_tx, counterparty_sig, counterparty_htlc_sigs, holder_funding_key, counterparty_funding_key);
30609 return nativeResponseValue;
30611 // void BuiltCommitmentTransaction_free(struct LDKBuiltCommitmentTransaction this_obj);
30613 export function BuiltCommitmentTransaction_free(this_obj: bigint): void {
30614 if(!isWasmInitialized) {
30615 throw new Error("initializeWasm() must be awaited first!");
30617 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_free(this_obj);
30618 // debug statements here
30620 // struct LDKTransaction BuiltCommitmentTransaction_get_transaction(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr);
30622 export function BuiltCommitmentTransaction_get_transaction(this_ptr: bigint): number {
30623 if(!isWasmInitialized) {
30624 throw new Error("initializeWasm() must be awaited first!");
30626 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_transaction(this_ptr);
30627 return nativeResponseValue;
30629 // void BuiltCommitmentTransaction_set_transaction(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKTransaction val);
30631 export function BuiltCommitmentTransaction_set_transaction(this_ptr: bigint, val: number): void {
30632 if(!isWasmInitialized) {
30633 throw new Error("initializeWasm() must be awaited first!");
30635 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_transaction(this_ptr, val);
30636 // debug statements here
30638 // const uint8_t (*BuiltCommitmentTransaction_get_txid(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr))[32];
30640 export function BuiltCommitmentTransaction_get_txid(this_ptr: bigint): number {
30641 if(!isWasmInitialized) {
30642 throw new Error("initializeWasm() must be awaited first!");
30644 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_txid(this_ptr);
30645 return nativeResponseValue;
30647 // void BuiltCommitmentTransaction_set_txid(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
30649 export function BuiltCommitmentTransaction_set_txid(this_ptr: bigint, val: number): void {
30650 if(!isWasmInitialized) {
30651 throw new Error("initializeWasm() must be awaited first!");
30653 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_txid(this_ptr, val);
30654 // debug statements here
30656 // MUST_USE_RES struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_new(struct LDKTransaction transaction_arg, struct LDKThirtyTwoBytes txid_arg);
30658 export function BuiltCommitmentTransaction_new(transaction_arg: number, txid_arg: number): bigint {
30659 if(!isWasmInitialized) {
30660 throw new Error("initializeWasm() must be awaited first!");
30662 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_new(transaction_arg, txid_arg);
30663 return nativeResponseValue;
30665 // uint64_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg);
30667 export function BuiltCommitmentTransaction_clone_ptr(arg: bigint): bigint {
30668 if(!isWasmInitialized) {
30669 throw new Error("initializeWasm() must be awaited first!");
30671 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone_ptr(arg);
30672 return nativeResponseValue;
30674 // struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_clone(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR orig);
30676 export function BuiltCommitmentTransaction_clone(orig: bigint): bigint {
30677 if(!isWasmInitialized) {
30678 throw new Error("initializeWasm() must be awaited first!");
30680 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone(orig);
30681 return nativeResponseValue;
30683 // struct LDKCVec_u8Z BuiltCommitmentTransaction_write(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR obj);
30685 export function BuiltCommitmentTransaction_write(obj: bigint): number {
30686 if(!isWasmInitialized) {
30687 throw new Error("initializeWasm() must be awaited first!");
30689 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_write(obj);
30690 return nativeResponseValue;
30692 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ BuiltCommitmentTransaction_read(struct LDKu8slice ser);
30694 export function BuiltCommitmentTransaction_read(ser: number): bigint {
30695 if(!isWasmInitialized) {
30696 throw new Error("initializeWasm() must be awaited first!");
30698 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_read(ser);
30699 return nativeResponseValue;
30701 // 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);
30703 export function BuiltCommitmentTransaction_get_sighash_all(this_arg: bigint, funding_redeemscript: number, channel_value_satoshis: bigint): number {
30704 if(!isWasmInitialized) {
30705 throw new Error("initializeWasm() must be awaited first!");
30707 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
30708 return nativeResponseValue;
30710 // 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);
30712 export function BuiltCommitmentTransaction_sign(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
30713 if(!isWasmInitialized) {
30714 throw new Error("initializeWasm() must be awaited first!");
30716 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
30717 return nativeResponseValue;
30719 // void ClosingTransaction_free(struct LDKClosingTransaction this_obj);
30721 export function ClosingTransaction_free(this_obj: bigint): void {
30722 if(!isWasmInitialized) {
30723 throw new Error("initializeWasm() must be awaited first!");
30725 const nativeResponseValue = wasm.TS_ClosingTransaction_free(this_obj);
30726 // debug statements here
30728 // uint64_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg);
30730 export function ClosingTransaction_clone_ptr(arg: bigint): bigint {
30731 if(!isWasmInitialized) {
30732 throw new Error("initializeWasm() must be awaited first!");
30734 const nativeResponseValue = wasm.TS_ClosingTransaction_clone_ptr(arg);
30735 return nativeResponseValue;
30737 // struct LDKClosingTransaction ClosingTransaction_clone(const struct LDKClosingTransaction *NONNULL_PTR orig);
30739 export function ClosingTransaction_clone(orig: bigint): bigint {
30740 if(!isWasmInitialized) {
30741 throw new Error("initializeWasm() must be awaited first!");
30743 const nativeResponseValue = wasm.TS_ClosingTransaction_clone(orig);
30744 return nativeResponseValue;
30746 // uint64_t ClosingTransaction_hash(const struct LDKClosingTransaction *NONNULL_PTR o);
30748 export function ClosingTransaction_hash(o: bigint): bigint {
30749 if(!isWasmInitialized) {
30750 throw new Error("initializeWasm() must be awaited first!");
30752 const nativeResponseValue = wasm.TS_ClosingTransaction_hash(o);
30753 return nativeResponseValue;
30755 // bool ClosingTransaction_eq(const struct LDKClosingTransaction *NONNULL_PTR a, const struct LDKClosingTransaction *NONNULL_PTR b);
30757 export function ClosingTransaction_eq(a: bigint, b: bigint): boolean {
30758 if(!isWasmInitialized) {
30759 throw new Error("initializeWasm() must be awaited first!");
30761 const nativeResponseValue = wasm.TS_ClosingTransaction_eq(a, b);
30762 return nativeResponseValue;
30764 // 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);
30766 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 {
30767 if(!isWasmInitialized) {
30768 throw new Error("initializeWasm() must be awaited first!");
30770 const nativeResponseValue = wasm.TS_ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
30771 return nativeResponseValue;
30773 // MUST_USE_RES struct LDKTrustedClosingTransaction ClosingTransaction_trust(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
30775 export function ClosingTransaction_trust(this_arg: bigint): bigint {
30776 if(!isWasmInitialized) {
30777 throw new Error("initializeWasm() must be awaited first!");
30779 const nativeResponseValue = wasm.TS_ClosingTransaction_trust(this_arg);
30780 return nativeResponseValue;
30782 // MUST_USE_RES struct LDKCResult_TrustedClosingTransactionNoneZ ClosingTransaction_verify(const struct LDKClosingTransaction *NONNULL_PTR this_arg, struct LDKOutPoint funding_outpoint);
30784 export function ClosingTransaction_verify(this_arg: bigint, funding_outpoint: bigint): bigint {
30785 if(!isWasmInitialized) {
30786 throw new Error("initializeWasm() must be awaited first!");
30788 const nativeResponseValue = wasm.TS_ClosingTransaction_verify(this_arg, funding_outpoint);
30789 return nativeResponseValue;
30791 // MUST_USE_RES uint64_t ClosingTransaction_to_holder_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
30793 export function ClosingTransaction_to_holder_value_sat(this_arg: bigint): bigint {
30794 if(!isWasmInitialized) {
30795 throw new Error("initializeWasm() must be awaited first!");
30797 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_value_sat(this_arg);
30798 return nativeResponseValue;
30800 // MUST_USE_RES uint64_t ClosingTransaction_to_counterparty_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
30802 export function ClosingTransaction_to_counterparty_value_sat(this_arg: bigint): bigint {
30803 if(!isWasmInitialized) {
30804 throw new Error("initializeWasm() must be awaited first!");
30806 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_value_sat(this_arg);
30807 return nativeResponseValue;
30809 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_holder_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
30811 export function ClosingTransaction_to_holder_script(this_arg: bigint): number {
30812 if(!isWasmInitialized) {
30813 throw new Error("initializeWasm() must be awaited first!");
30815 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_script(this_arg);
30816 return nativeResponseValue;
30818 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_counterparty_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
30820 export function ClosingTransaction_to_counterparty_script(this_arg: bigint): number {
30821 if(!isWasmInitialized) {
30822 throw new Error("initializeWasm() must be awaited first!");
30824 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_script(this_arg);
30825 return nativeResponseValue;
30827 // void TrustedClosingTransaction_free(struct LDKTrustedClosingTransaction this_obj);
30829 export function TrustedClosingTransaction_free(this_obj: bigint): void {
30830 if(!isWasmInitialized) {
30831 throw new Error("initializeWasm() must be awaited first!");
30833 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_free(this_obj);
30834 // debug statements here
30836 // MUST_USE_RES struct LDKTransaction TrustedClosingTransaction_built_transaction(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg);
30838 export function TrustedClosingTransaction_built_transaction(this_arg: bigint): number {
30839 if(!isWasmInitialized) {
30840 throw new Error("initializeWasm() must be awaited first!");
30842 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_built_transaction(this_arg);
30843 return nativeResponseValue;
30845 // 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);
30847 export function TrustedClosingTransaction_get_sighash_all(this_arg: bigint, funding_redeemscript: number, channel_value_satoshis: bigint): number {
30848 if(!isWasmInitialized) {
30849 throw new Error("initializeWasm() must be awaited first!");
30851 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
30852 return nativeResponseValue;
30854 // 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);
30856 export function TrustedClosingTransaction_sign(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
30857 if(!isWasmInitialized) {
30858 throw new Error("initializeWasm() must be awaited first!");
30860 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
30861 return nativeResponseValue;
30863 // void CommitmentTransaction_free(struct LDKCommitmentTransaction this_obj);
30865 export function CommitmentTransaction_free(this_obj: bigint): void {
30866 if(!isWasmInitialized) {
30867 throw new Error("initializeWasm() must be awaited first!");
30869 const nativeResponseValue = wasm.TS_CommitmentTransaction_free(this_obj);
30870 // debug statements here
30872 // uint64_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg);
30874 export function CommitmentTransaction_clone_ptr(arg: bigint): bigint {
30875 if(!isWasmInitialized) {
30876 throw new Error("initializeWasm() must be awaited first!");
30878 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone_ptr(arg);
30879 return nativeResponseValue;
30881 // struct LDKCommitmentTransaction CommitmentTransaction_clone(const struct LDKCommitmentTransaction *NONNULL_PTR orig);
30883 export function CommitmentTransaction_clone(orig: bigint): bigint {
30884 if(!isWasmInitialized) {
30885 throw new Error("initializeWasm() must be awaited first!");
30887 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone(orig);
30888 return nativeResponseValue;
30890 // struct LDKCVec_u8Z CommitmentTransaction_write(const struct LDKCommitmentTransaction *NONNULL_PTR obj);
30892 export function CommitmentTransaction_write(obj: bigint): number {
30893 if(!isWasmInitialized) {
30894 throw new Error("initializeWasm() must be awaited first!");
30896 const nativeResponseValue = wasm.TS_CommitmentTransaction_write(obj);
30897 return nativeResponseValue;
30899 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CommitmentTransaction_read(struct LDKu8slice ser);
30901 export function CommitmentTransaction_read(ser: number): bigint {
30902 if(!isWasmInitialized) {
30903 throw new Error("initializeWasm() must be awaited first!");
30905 const nativeResponseValue = wasm.TS_CommitmentTransaction_read(ser);
30906 return nativeResponseValue;
30908 // MUST_USE_RES uint64_t CommitmentTransaction_commitment_number(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
30910 export function CommitmentTransaction_commitment_number(this_arg: bigint): bigint {
30911 if(!isWasmInitialized) {
30912 throw new Error("initializeWasm() must be awaited first!");
30914 const nativeResponseValue = wasm.TS_CommitmentTransaction_commitment_number(this_arg);
30915 return nativeResponseValue;
30917 // MUST_USE_RES uint64_t CommitmentTransaction_to_broadcaster_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
30919 export function CommitmentTransaction_to_broadcaster_value_sat(this_arg: bigint): bigint {
30920 if(!isWasmInitialized) {
30921 throw new Error("initializeWasm() must be awaited first!");
30923 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_broadcaster_value_sat(this_arg);
30924 return nativeResponseValue;
30926 // MUST_USE_RES uint64_t CommitmentTransaction_to_countersignatory_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
30928 export function CommitmentTransaction_to_countersignatory_value_sat(this_arg: bigint): bigint {
30929 if(!isWasmInitialized) {
30930 throw new Error("initializeWasm() must be awaited first!");
30932 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_countersignatory_value_sat(this_arg);
30933 return nativeResponseValue;
30935 // MUST_USE_RES uint32_t CommitmentTransaction_feerate_per_kw(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
30937 export function CommitmentTransaction_feerate_per_kw(this_arg: bigint): number {
30938 if(!isWasmInitialized) {
30939 throw new Error("initializeWasm() must be awaited first!");
30941 const nativeResponseValue = wasm.TS_CommitmentTransaction_feerate_per_kw(this_arg);
30942 return nativeResponseValue;
30944 // MUST_USE_RES struct LDKTrustedCommitmentTransaction CommitmentTransaction_trust(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
30946 export function CommitmentTransaction_trust(this_arg: bigint): bigint {
30947 if(!isWasmInitialized) {
30948 throw new Error("initializeWasm() must be awaited first!");
30950 const nativeResponseValue = wasm.TS_CommitmentTransaction_trust(this_arg);
30951 return nativeResponseValue;
30953 // 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);
30955 export function CommitmentTransaction_verify(this_arg: bigint, channel_parameters: bigint, broadcaster_keys: bigint, countersignatory_keys: bigint): bigint {
30956 if(!isWasmInitialized) {
30957 throw new Error("initializeWasm() must be awaited first!");
30959 const nativeResponseValue = wasm.TS_CommitmentTransaction_verify(this_arg, channel_parameters, broadcaster_keys, countersignatory_keys);
30960 return nativeResponseValue;
30962 // void TrustedCommitmentTransaction_free(struct LDKTrustedCommitmentTransaction this_obj);
30964 export function TrustedCommitmentTransaction_free(this_obj: bigint): void {
30965 if(!isWasmInitialized) {
30966 throw new Error("initializeWasm() must be awaited first!");
30968 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_free(this_obj);
30969 // debug statements here
30971 // MUST_USE_RES struct LDKThirtyTwoBytes TrustedCommitmentTransaction_txid(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
30973 export function TrustedCommitmentTransaction_txid(this_arg: bigint): number {
30974 if(!isWasmInitialized) {
30975 throw new Error("initializeWasm() must be awaited first!");
30977 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_txid(this_arg);
30978 return nativeResponseValue;
30980 // MUST_USE_RES struct LDKBuiltCommitmentTransaction TrustedCommitmentTransaction_built_transaction(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
30982 export function TrustedCommitmentTransaction_built_transaction(this_arg: bigint): bigint {
30983 if(!isWasmInitialized) {
30984 throw new Error("initializeWasm() must be awaited first!");
30986 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_built_transaction(this_arg);
30987 return nativeResponseValue;
30989 // MUST_USE_RES struct LDKTxCreationKeys TrustedCommitmentTransaction_keys(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
30991 export function TrustedCommitmentTransaction_keys(this_arg: bigint): bigint {
30992 if(!isWasmInitialized) {
30993 throw new Error("initializeWasm() must be awaited first!");
30995 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_keys(this_arg);
30996 return nativeResponseValue;
30998 // MUST_USE_RES bool TrustedCommitmentTransaction_opt_anchors(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
31000 export function TrustedCommitmentTransaction_opt_anchors(this_arg: bigint): boolean {
31001 if(!isWasmInitialized) {
31002 throw new Error("initializeWasm() must be awaited first!");
31004 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_opt_anchors(this_arg);
31005 return nativeResponseValue;
31007 // 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);
31009 export function TrustedCommitmentTransaction_get_htlc_sigs(this_arg: bigint, htlc_base_key: number, channel_parameters: bigint): bigint {
31010 if(!isWasmInitialized) {
31011 throw new Error("initializeWasm() must be awaited first!");
31013 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_get_htlc_sigs(this_arg, htlc_base_key, channel_parameters);
31014 return nativeResponseValue;
31016 // uint64_t get_commitment_transaction_number_obscure_factor(struct LDKPublicKey broadcaster_payment_basepoint, struct LDKPublicKey countersignatory_payment_basepoint, bool outbound_from_broadcaster);
31018 export function get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint: number, countersignatory_payment_basepoint: number, outbound_from_broadcaster: boolean): bigint {
31019 if(!isWasmInitialized) {
31020 throw new Error("initializeWasm() must be awaited first!");
31022 const nativeResponseValue = wasm.TS_get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint, countersignatory_payment_basepoint, outbound_from_broadcaster);
31023 return nativeResponseValue;
31025 // bool InitFeatures_eq(const struct LDKInitFeatures *NONNULL_PTR a, const struct LDKInitFeatures *NONNULL_PTR b);
31027 export function InitFeatures_eq(a: bigint, b: bigint): boolean {
31028 if(!isWasmInitialized) {
31029 throw new Error("initializeWasm() must be awaited first!");
31031 const nativeResponseValue = wasm.TS_InitFeatures_eq(a, b);
31032 return nativeResponseValue;
31034 // bool NodeFeatures_eq(const struct LDKNodeFeatures *NONNULL_PTR a, const struct LDKNodeFeatures *NONNULL_PTR b);
31036 export function NodeFeatures_eq(a: bigint, b: bigint): boolean {
31037 if(!isWasmInitialized) {
31038 throw new Error("initializeWasm() must be awaited first!");
31040 const nativeResponseValue = wasm.TS_NodeFeatures_eq(a, b);
31041 return nativeResponseValue;
31043 // bool ChannelFeatures_eq(const struct LDKChannelFeatures *NONNULL_PTR a, const struct LDKChannelFeatures *NONNULL_PTR b);
31045 export function ChannelFeatures_eq(a: bigint, b: bigint): boolean {
31046 if(!isWasmInitialized) {
31047 throw new Error("initializeWasm() must be awaited first!");
31049 const nativeResponseValue = wasm.TS_ChannelFeatures_eq(a, b);
31050 return nativeResponseValue;
31052 // bool InvoiceFeatures_eq(const struct LDKInvoiceFeatures *NONNULL_PTR a, const struct LDKInvoiceFeatures *NONNULL_PTR b);
31054 export function InvoiceFeatures_eq(a: bigint, b: bigint): boolean {
31055 if(!isWasmInitialized) {
31056 throw new Error("initializeWasm() must be awaited first!");
31058 const nativeResponseValue = wasm.TS_InvoiceFeatures_eq(a, b);
31059 return nativeResponseValue;
31061 // bool OfferFeatures_eq(const struct LDKOfferFeatures *NONNULL_PTR a, const struct LDKOfferFeatures *NONNULL_PTR b);
31063 export function OfferFeatures_eq(a: bigint, b: bigint): boolean {
31064 if(!isWasmInitialized) {
31065 throw new Error("initializeWasm() must be awaited first!");
31067 const nativeResponseValue = wasm.TS_OfferFeatures_eq(a, b);
31068 return nativeResponseValue;
31070 // bool InvoiceRequestFeatures_eq(const struct LDKInvoiceRequestFeatures *NONNULL_PTR a, const struct LDKInvoiceRequestFeatures *NONNULL_PTR b);
31072 export function InvoiceRequestFeatures_eq(a: bigint, b: bigint): boolean {
31073 if(!isWasmInitialized) {
31074 throw new Error("initializeWasm() must be awaited first!");
31076 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_eq(a, b);
31077 return nativeResponseValue;
31079 // bool Bolt12InvoiceFeatures_eq(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR a, const struct LDKBolt12InvoiceFeatures *NONNULL_PTR b);
31081 export function Bolt12InvoiceFeatures_eq(a: bigint, b: bigint): boolean {
31082 if(!isWasmInitialized) {
31083 throw new Error("initializeWasm() must be awaited first!");
31085 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_eq(a, b);
31086 return nativeResponseValue;
31088 // bool BlindedHopFeatures_eq(const struct LDKBlindedHopFeatures *NONNULL_PTR a, const struct LDKBlindedHopFeatures *NONNULL_PTR b);
31090 export function BlindedHopFeatures_eq(a: bigint, b: bigint): boolean {
31091 if(!isWasmInitialized) {
31092 throw new Error("initializeWasm() must be awaited first!");
31094 const nativeResponseValue = wasm.TS_BlindedHopFeatures_eq(a, b);
31095 return nativeResponseValue;
31097 // bool ChannelTypeFeatures_eq(const struct LDKChannelTypeFeatures *NONNULL_PTR a, const struct LDKChannelTypeFeatures *NONNULL_PTR b);
31099 export function ChannelTypeFeatures_eq(a: bigint, b: bigint): boolean {
31100 if(!isWasmInitialized) {
31101 throw new Error("initializeWasm() must be awaited first!");
31103 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_eq(a, b);
31104 return nativeResponseValue;
31106 // uint64_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg);
31108 export function InitFeatures_clone_ptr(arg: bigint): bigint {
31109 if(!isWasmInitialized) {
31110 throw new Error("initializeWasm() must be awaited first!");
31112 const nativeResponseValue = wasm.TS_InitFeatures_clone_ptr(arg);
31113 return nativeResponseValue;
31115 // struct LDKInitFeatures InitFeatures_clone(const struct LDKInitFeatures *NONNULL_PTR orig);
31117 export function InitFeatures_clone(orig: bigint): bigint {
31118 if(!isWasmInitialized) {
31119 throw new Error("initializeWasm() must be awaited first!");
31121 const nativeResponseValue = wasm.TS_InitFeatures_clone(orig);
31122 return nativeResponseValue;
31124 // uint64_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg);
31126 export function NodeFeatures_clone_ptr(arg: bigint): bigint {
31127 if(!isWasmInitialized) {
31128 throw new Error("initializeWasm() must be awaited first!");
31130 const nativeResponseValue = wasm.TS_NodeFeatures_clone_ptr(arg);
31131 return nativeResponseValue;
31133 // struct LDKNodeFeatures NodeFeatures_clone(const struct LDKNodeFeatures *NONNULL_PTR orig);
31135 export function NodeFeatures_clone(orig: bigint): bigint {
31136 if(!isWasmInitialized) {
31137 throw new Error("initializeWasm() must be awaited first!");
31139 const nativeResponseValue = wasm.TS_NodeFeatures_clone(orig);
31140 return nativeResponseValue;
31142 // uint64_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg);
31144 export function ChannelFeatures_clone_ptr(arg: bigint): bigint {
31145 if(!isWasmInitialized) {
31146 throw new Error("initializeWasm() must be awaited first!");
31148 const nativeResponseValue = wasm.TS_ChannelFeatures_clone_ptr(arg);
31149 return nativeResponseValue;
31151 // struct LDKChannelFeatures ChannelFeatures_clone(const struct LDKChannelFeatures *NONNULL_PTR orig);
31153 export function ChannelFeatures_clone(orig: bigint): bigint {
31154 if(!isWasmInitialized) {
31155 throw new Error("initializeWasm() must be awaited first!");
31157 const nativeResponseValue = wasm.TS_ChannelFeatures_clone(orig);
31158 return nativeResponseValue;
31160 // uint64_t InvoiceFeatures_clone_ptr(LDKInvoiceFeatures *NONNULL_PTR arg);
31162 export function InvoiceFeatures_clone_ptr(arg: bigint): bigint {
31163 if(!isWasmInitialized) {
31164 throw new Error("initializeWasm() must be awaited first!");
31166 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone_ptr(arg);
31167 return nativeResponseValue;
31169 // struct LDKInvoiceFeatures InvoiceFeatures_clone(const struct LDKInvoiceFeatures *NONNULL_PTR orig);
31171 export function InvoiceFeatures_clone(orig: bigint): bigint {
31172 if(!isWasmInitialized) {
31173 throw new Error("initializeWasm() must be awaited first!");
31175 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone(orig);
31176 return nativeResponseValue;
31178 // uint64_t OfferFeatures_clone_ptr(LDKOfferFeatures *NONNULL_PTR arg);
31180 export function OfferFeatures_clone_ptr(arg: bigint): bigint {
31181 if(!isWasmInitialized) {
31182 throw new Error("initializeWasm() must be awaited first!");
31184 const nativeResponseValue = wasm.TS_OfferFeatures_clone_ptr(arg);
31185 return nativeResponseValue;
31187 // struct LDKOfferFeatures OfferFeatures_clone(const struct LDKOfferFeatures *NONNULL_PTR orig);
31189 export function OfferFeatures_clone(orig: bigint): bigint {
31190 if(!isWasmInitialized) {
31191 throw new Error("initializeWasm() must be awaited first!");
31193 const nativeResponseValue = wasm.TS_OfferFeatures_clone(orig);
31194 return nativeResponseValue;
31196 // uint64_t InvoiceRequestFeatures_clone_ptr(LDKInvoiceRequestFeatures *NONNULL_PTR arg);
31198 export function InvoiceRequestFeatures_clone_ptr(arg: bigint): bigint {
31199 if(!isWasmInitialized) {
31200 throw new Error("initializeWasm() must be awaited first!");
31202 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_clone_ptr(arg);
31203 return nativeResponseValue;
31205 // struct LDKInvoiceRequestFeatures InvoiceRequestFeatures_clone(const struct LDKInvoiceRequestFeatures *NONNULL_PTR orig);
31207 export function InvoiceRequestFeatures_clone(orig: bigint): bigint {
31208 if(!isWasmInitialized) {
31209 throw new Error("initializeWasm() must be awaited first!");
31211 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_clone(orig);
31212 return nativeResponseValue;
31214 // uint64_t Bolt12InvoiceFeatures_clone_ptr(LDKBolt12InvoiceFeatures *NONNULL_PTR arg);
31216 export function Bolt12InvoiceFeatures_clone_ptr(arg: bigint): bigint {
31217 if(!isWasmInitialized) {
31218 throw new Error("initializeWasm() must be awaited first!");
31220 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_clone_ptr(arg);
31221 return nativeResponseValue;
31223 // struct LDKBolt12InvoiceFeatures Bolt12InvoiceFeatures_clone(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR orig);
31225 export function Bolt12InvoiceFeatures_clone(orig: bigint): bigint {
31226 if(!isWasmInitialized) {
31227 throw new Error("initializeWasm() must be awaited first!");
31229 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_clone(orig);
31230 return nativeResponseValue;
31232 // uint64_t BlindedHopFeatures_clone_ptr(LDKBlindedHopFeatures *NONNULL_PTR arg);
31234 export function BlindedHopFeatures_clone_ptr(arg: bigint): bigint {
31235 if(!isWasmInitialized) {
31236 throw new Error("initializeWasm() must be awaited first!");
31238 const nativeResponseValue = wasm.TS_BlindedHopFeatures_clone_ptr(arg);
31239 return nativeResponseValue;
31241 // struct LDKBlindedHopFeatures BlindedHopFeatures_clone(const struct LDKBlindedHopFeatures *NONNULL_PTR orig);
31243 export function BlindedHopFeatures_clone(orig: bigint): bigint {
31244 if(!isWasmInitialized) {
31245 throw new Error("initializeWasm() must be awaited first!");
31247 const nativeResponseValue = wasm.TS_BlindedHopFeatures_clone(orig);
31248 return nativeResponseValue;
31250 // uint64_t ChannelTypeFeatures_clone_ptr(LDKChannelTypeFeatures *NONNULL_PTR arg);
31252 export function ChannelTypeFeatures_clone_ptr(arg: bigint): bigint {
31253 if(!isWasmInitialized) {
31254 throw new Error("initializeWasm() must be awaited first!");
31256 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone_ptr(arg);
31257 return nativeResponseValue;
31259 // struct LDKChannelTypeFeatures ChannelTypeFeatures_clone(const struct LDKChannelTypeFeatures *NONNULL_PTR orig);
31261 export function ChannelTypeFeatures_clone(orig: bigint): bigint {
31262 if(!isWasmInitialized) {
31263 throw new Error("initializeWasm() must be awaited first!");
31265 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone(orig);
31266 return nativeResponseValue;
31268 // void InitFeatures_free(struct LDKInitFeatures this_obj);
31270 export function InitFeatures_free(this_obj: bigint): void {
31271 if(!isWasmInitialized) {
31272 throw new Error("initializeWasm() must be awaited first!");
31274 const nativeResponseValue = wasm.TS_InitFeatures_free(this_obj);
31275 // debug statements here
31277 // void NodeFeatures_free(struct LDKNodeFeatures this_obj);
31279 export function NodeFeatures_free(this_obj: bigint): void {
31280 if(!isWasmInitialized) {
31281 throw new Error("initializeWasm() must be awaited first!");
31283 const nativeResponseValue = wasm.TS_NodeFeatures_free(this_obj);
31284 // debug statements here
31286 // void ChannelFeatures_free(struct LDKChannelFeatures this_obj);
31288 export function ChannelFeatures_free(this_obj: bigint): void {
31289 if(!isWasmInitialized) {
31290 throw new Error("initializeWasm() must be awaited first!");
31292 const nativeResponseValue = wasm.TS_ChannelFeatures_free(this_obj);
31293 // debug statements here
31295 // void InvoiceFeatures_free(struct LDKInvoiceFeatures this_obj);
31297 export function InvoiceFeatures_free(this_obj: bigint): void {
31298 if(!isWasmInitialized) {
31299 throw new Error("initializeWasm() must be awaited first!");
31301 const nativeResponseValue = wasm.TS_InvoiceFeatures_free(this_obj);
31302 // debug statements here
31304 // void OfferFeatures_free(struct LDKOfferFeatures this_obj);
31306 export function OfferFeatures_free(this_obj: bigint): void {
31307 if(!isWasmInitialized) {
31308 throw new Error("initializeWasm() must be awaited first!");
31310 const nativeResponseValue = wasm.TS_OfferFeatures_free(this_obj);
31311 // debug statements here
31313 // void InvoiceRequestFeatures_free(struct LDKInvoiceRequestFeatures this_obj);
31315 export function InvoiceRequestFeatures_free(this_obj: bigint): void {
31316 if(!isWasmInitialized) {
31317 throw new Error("initializeWasm() must be awaited first!");
31319 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_free(this_obj);
31320 // debug statements here
31322 // void Bolt12InvoiceFeatures_free(struct LDKBolt12InvoiceFeatures this_obj);
31324 export function Bolt12InvoiceFeatures_free(this_obj: bigint): void {
31325 if(!isWasmInitialized) {
31326 throw new Error("initializeWasm() must be awaited first!");
31328 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_free(this_obj);
31329 // debug statements here
31331 // void BlindedHopFeatures_free(struct LDKBlindedHopFeatures this_obj);
31333 export function BlindedHopFeatures_free(this_obj: bigint): void {
31334 if(!isWasmInitialized) {
31335 throw new Error("initializeWasm() must be awaited first!");
31337 const nativeResponseValue = wasm.TS_BlindedHopFeatures_free(this_obj);
31338 // debug statements here
31340 // void ChannelTypeFeatures_free(struct LDKChannelTypeFeatures this_obj);
31342 export function ChannelTypeFeatures_free(this_obj: bigint): void {
31343 if(!isWasmInitialized) {
31344 throw new Error("initializeWasm() must be awaited first!");
31346 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_free(this_obj);
31347 // debug statements here
31349 // MUST_USE_RES struct LDKInitFeatures InitFeatures_empty(void);
31351 export function InitFeatures_empty(): bigint {
31352 if(!isWasmInitialized) {
31353 throw new Error("initializeWasm() must be awaited first!");
31355 const nativeResponseValue = wasm.TS_InitFeatures_empty();
31356 return nativeResponseValue;
31358 // MUST_USE_RES bool InitFeatures_requires_unknown_bits(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31360 export function InitFeatures_requires_unknown_bits(this_arg: bigint): boolean {
31361 if(!isWasmInitialized) {
31362 throw new Error("initializeWasm() must be awaited first!");
31364 const nativeResponseValue = wasm.TS_InitFeatures_requires_unknown_bits(this_arg);
31365 return nativeResponseValue;
31367 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_empty(void);
31369 export function NodeFeatures_empty(): bigint {
31370 if(!isWasmInitialized) {
31371 throw new Error("initializeWasm() must be awaited first!");
31373 const nativeResponseValue = wasm.TS_NodeFeatures_empty();
31374 return nativeResponseValue;
31376 // MUST_USE_RES bool NodeFeatures_requires_unknown_bits(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31378 export function NodeFeatures_requires_unknown_bits(this_arg: bigint): boolean {
31379 if(!isWasmInitialized) {
31380 throw new Error("initializeWasm() must be awaited first!");
31382 const nativeResponseValue = wasm.TS_NodeFeatures_requires_unknown_bits(this_arg);
31383 return nativeResponseValue;
31385 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_empty(void);
31387 export function ChannelFeatures_empty(): bigint {
31388 if(!isWasmInitialized) {
31389 throw new Error("initializeWasm() must be awaited first!");
31391 const nativeResponseValue = wasm.TS_ChannelFeatures_empty();
31392 return nativeResponseValue;
31394 // MUST_USE_RES bool ChannelFeatures_requires_unknown_bits(const struct LDKChannelFeatures *NONNULL_PTR this_arg);
31396 export function ChannelFeatures_requires_unknown_bits(this_arg: bigint): boolean {
31397 if(!isWasmInitialized) {
31398 throw new Error("initializeWasm() must be awaited first!");
31400 const nativeResponseValue = wasm.TS_ChannelFeatures_requires_unknown_bits(this_arg);
31401 return nativeResponseValue;
31403 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_empty(void);
31405 export function InvoiceFeatures_empty(): bigint {
31406 if(!isWasmInitialized) {
31407 throw new Error("initializeWasm() must be awaited first!");
31409 const nativeResponseValue = wasm.TS_InvoiceFeatures_empty();
31410 return nativeResponseValue;
31412 // MUST_USE_RES bool InvoiceFeatures_requires_unknown_bits(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
31414 export function InvoiceFeatures_requires_unknown_bits(this_arg: bigint): boolean {
31415 if(!isWasmInitialized) {
31416 throw new Error("initializeWasm() must be awaited first!");
31418 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_unknown_bits(this_arg);
31419 return nativeResponseValue;
31421 // MUST_USE_RES struct LDKOfferFeatures OfferFeatures_empty(void);
31423 export function OfferFeatures_empty(): bigint {
31424 if(!isWasmInitialized) {
31425 throw new Error("initializeWasm() must be awaited first!");
31427 const nativeResponseValue = wasm.TS_OfferFeatures_empty();
31428 return nativeResponseValue;
31430 // MUST_USE_RES bool OfferFeatures_requires_unknown_bits(const struct LDKOfferFeatures *NONNULL_PTR this_arg);
31432 export function OfferFeatures_requires_unknown_bits(this_arg: bigint): boolean {
31433 if(!isWasmInitialized) {
31434 throw new Error("initializeWasm() must be awaited first!");
31436 const nativeResponseValue = wasm.TS_OfferFeatures_requires_unknown_bits(this_arg);
31437 return nativeResponseValue;
31439 // MUST_USE_RES struct LDKInvoiceRequestFeatures InvoiceRequestFeatures_empty(void);
31441 export function InvoiceRequestFeatures_empty(): bigint {
31442 if(!isWasmInitialized) {
31443 throw new Error("initializeWasm() must be awaited first!");
31445 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_empty();
31446 return nativeResponseValue;
31448 // MUST_USE_RES bool InvoiceRequestFeatures_requires_unknown_bits(const struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg);
31450 export function InvoiceRequestFeatures_requires_unknown_bits(this_arg: bigint): boolean {
31451 if(!isWasmInitialized) {
31452 throw new Error("initializeWasm() must be awaited first!");
31454 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_requires_unknown_bits(this_arg);
31455 return nativeResponseValue;
31457 // MUST_USE_RES struct LDKBolt12InvoiceFeatures Bolt12InvoiceFeatures_empty(void);
31459 export function Bolt12InvoiceFeatures_empty(): bigint {
31460 if(!isWasmInitialized) {
31461 throw new Error("initializeWasm() must be awaited first!");
31463 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_empty();
31464 return nativeResponseValue;
31466 // MUST_USE_RES bool Bolt12InvoiceFeatures_requires_unknown_bits(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
31468 export function Bolt12InvoiceFeatures_requires_unknown_bits(this_arg: bigint): boolean {
31469 if(!isWasmInitialized) {
31470 throw new Error("initializeWasm() must be awaited first!");
31472 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_requires_unknown_bits(this_arg);
31473 return nativeResponseValue;
31475 // MUST_USE_RES struct LDKBlindedHopFeatures BlindedHopFeatures_empty(void);
31477 export function BlindedHopFeatures_empty(): bigint {
31478 if(!isWasmInitialized) {
31479 throw new Error("initializeWasm() must be awaited first!");
31481 const nativeResponseValue = wasm.TS_BlindedHopFeatures_empty();
31482 return nativeResponseValue;
31484 // MUST_USE_RES bool BlindedHopFeatures_requires_unknown_bits(const struct LDKBlindedHopFeatures *NONNULL_PTR this_arg);
31486 export function BlindedHopFeatures_requires_unknown_bits(this_arg: bigint): boolean {
31487 if(!isWasmInitialized) {
31488 throw new Error("initializeWasm() must be awaited first!");
31490 const nativeResponseValue = wasm.TS_BlindedHopFeatures_requires_unknown_bits(this_arg);
31491 return nativeResponseValue;
31493 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_empty(void);
31495 export function ChannelTypeFeatures_empty(): bigint {
31496 if(!isWasmInitialized) {
31497 throw new Error("initializeWasm() must be awaited first!");
31499 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_empty();
31500 return nativeResponseValue;
31502 // MUST_USE_RES bool ChannelTypeFeatures_requires_unknown_bits(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
31504 export function ChannelTypeFeatures_requires_unknown_bits(this_arg: bigint): boolean {
31505 if(!isWasmInitialized) {
31506 throw new Error("initializeWasm() must be awaited first!");
31508 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_unknown_bits(this_arg);
31509 return nativeResponseValue;
31511 // struct LDKCVec_u8Z InitFeatures_write(const struct LDKInitFeatures *NONNULL_PTR obj);
31513 export function InitFeatures_write(obj: bigint): number {
31514 if(!isWasmInitialized) {
31515 throw new Error("initializeWasm() must be awaited first!");
31517 const nativeResponseValue = wasm.TS_InitFeatures_write(obj);
31518 return nativeResponseValue;
31520 // struct LDKCResult_InitFeaturesDecodeErrorZ InitFeatures_read(struct LDKu8slice ser);
31522 export function InitFeatures_read(ser: number): bigint {
31523 if(!isWasmInitialized) {
31524 throw new Error("initializeWasm() must be awaited first!");
31526 const nativeResponseValue = wasm.TS_InitFeatures_read(ser);
31527 return nativeResponseValue;
31529 // struct LDKCVec_u8Z ChannelFeatures_write(const struct LDKChannelFeatures *NONNULL_PTR obj);
31531 export function ChannelFeatures_write(obj: bigint): number {
31532 if(!isWasmInitialized) {
31533 throw new Error("initializeWasm() must be awaited first!");
31535 const nativeResponseValue = wasm.TS_ChannelFeatures_write(obj);
31536 return nativeResponseValue;
31538 // struct LDKCResult_ChannelFeaturesDecodeErrorZ ChannelFeatures_read(struct LDKu8slice ser);
31540 export function ChannelFeatures_read(ser: number): bigint {
31541 if(!isWasmInitialized) {
31542 throw new Error("initializeWasm() must be awaited first!");
31544 const nativeResponseValue = wasm.TS_ChannelFeatures_read(ser);
31545 return nativeResponseValue;
31547 // struct LDKCVec_u8Z NodeFeatures_write(const struct LDKNodeFeatures *NONNULL_PTR obj);
31549 export function NodeFeatures_write(obj: bigint): number {
31550 if(!isWasmInitialized) {
31551 throw new Error("initializeWasm() must be awaited first!");
31553 const nativeResponseValue = wasm.TS_NodeFeatures_write(obj);
31554 return nativeResponseValue;
31556 // struct LDKCResult_NodeFeaturesDecodeErrorZ NodeFeatures_read(struct LDKu8slice ser);
31558 export function NodeFeatures_read(ser: number): bigint {
31559 if(!isWasmInitialized) {
31560 throw new Error("initializeWasm() must be awaited first!");
31562 const nativeResponseValue = wasm.TS_NodeFeatures_read(ser);
31563 return nativeResponseValue;
31565 // struct LDKCVec_u8Z InvoiceFeatures_write(const struct LDKInvoiceFeatures *NONNULL_PTR obj);
31567 export function InvoiceFeatures_write(obj: bigint): number {
31568 if(!isWasmInitialized) {
31569 throw new Error("initializeWasm() must be awaited first!");
31571 const nativeResponseValue = wasm.TS_InvoiceFeatures_write(obj);
31572 return nativeResponseValue;
31574 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ InvoiceFeatures_read(struct LDKu8slice ser);
31576 export function InvoiceFeatures_read(ser: number): bigint {
31577 if(!isWasmInitialized) {
31578 throw new Error("initializeWasm() must be awaited first!");
31580 const nativeResponseValue = wasm.TS_InvoiceFeatures_read(ser);
31581 return nativeResponseValue;
31583 // struct LDKCVec_u8Z BlindedHopFeatures_write(const struct LDKBlindedHopFeatures *NONNULL_PTR obj);
31585 export function BlindedHopFeatures_write(obj: bigint): number {
31586 if(!isWasmInitialized) {
31587 throw new Error("initializeWasm() must be awaited first!");
31589 const nativeResponseValue = wasm.TS_BlindedHopFeatures_write(obj);
31590 return nativeResponseValue;
31592 // struct LDKCResult_BlindedHopFeaturesDecodeErrorZ BlindedHopFeatures_read(struct LDKu8slice ser);
31594 export function BlindedHopFeatures_read(ser: number): bigint {
31595 if(!isWasmInitialized) {
31596 throw new Error("initializeWasm() must be awaited first!");
31598 const nativeResponseValue = wasm.TS_BlindedHopFeatures_read(ser);
31599 return nativeResponseValue;
31601 // struct LDKCVec_u8Z ChannelTypeFeatures_write(const struct LDKChannelTypeFeatures *NONNULL_PTR obj);
31603 export function ChannelTypeFeatures_write(obj: bigint): number {
31604 if(!isWasmInitialized) {
31605 throw new Error("initializeWasm() must be awaited first!");
31607 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_write(obj);
31608 return nativeResponseValue;
31610 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ ChannelTypeFeatures_read(struct LDKu8slice ser);
31612 export function ChannelTypeFeatures_read(ser: number): bigint {
31613 if(!isWasmInitialized) {
31614 throw new Error("initializeWasm() must be awaited first!");
31616 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_read(ser);
31617 return nativeResponseValue;
31619 // void InitFeatures_set_data_loss_protect_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
31621 export function InitFeatures_set_data_loss_protect_optional(this_arg: bigint): void {
31622 if(!isWasmInitialized) {
31623 throw new Error("initializeWasm() must be awaited first!");
31625 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_optional(this_arg);
31626 // debug statements here
31628 // void InitFeatures_set_data_loss_protect_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
31630 export function InitFeatures_set_data_loss_protect_required(this_arg: bigint): void {
31631 if(!isWasmInitialized) {
31632 throw new Error("initializeWasm() must be awaited first!");
31634 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_required(this_arg);
31635 // debug statements here
31637 // MUST_USE_RES bool InitFeatures_supports_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31639 export function InitFeatures_supports_data_loss_protect(this_arg: bigint): boolean {
31640 if(!isWasmInitialized) {
31641 throw new Error("initializeWasm() must be awaited first!");
31643 const nativeResponseValue = wasm.TS_InitFeatures_supports_data_loss_protect(this_arg);
31644 return nativeResponseValue;
31646 // void NodeFeatures_set_data_loss_protect_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31648 export function NodeFeatures_set_data_loss_protect_optional(this_arg: bigint): void {
31649 if(!isWasmInitialized) {
31650 throw new Error("initializeWasm() must be awaited first!");
31652 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_optional(this_arg);
31653 // debug statements here
31655 // void NodeFeatures_set_data_loss_protect_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31657 export function NodeFeatures_set_data_loss_protect_required(this_arg: bigint): void {
31658 if(!isWasmInitialized) {
31659 throw new Error("initializeWasm() must be awaited first!");
31661 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_required(this_arg);
31662 // debug statements here
31664 // MUST_USE_RES bool NodeFeatures_supports_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31666 export function NodeFeatures_supports_data_loss_protect(this_arg: bigint): boolean {
31667 if(!isWasmInitialized) {
31668 throw new Error("initializeWasm() must be awaited first!");
31670 const nativeResponseValue = wasm.TS_NodeFeatures_supports_data_loss_protect(this_arg);
31671 return nativeResponseValue;
31673 // MUST_USE_RES bool InitFeatures_requires_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31675 export function InitFeatures_requires_data_loss_protect(this_arg: bigint): boolean {
31676 if(!isWasmInitialized) {
31677 throw new Error("initializeWasm() must be awaited first!");
31679 const nativeResponseValue = wasm.TS_InitFeatures_requires_data_loss_protect(this_arg);
31680 return nativeResponseValue;
31682 // MUST_USE_RES bool NodeFeatures_requires_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31684 export function NodeFeatures_requires_data_loss_protect(this_arg: bigint): boolean {
31685 if(!isWasmInitialized) {
31686 throw new Error("initializeWasm() must be awaited first!");
31688 const nativeResponseValue = wasm.TS_NodeFeatures_requires_data_loss_protect(this_arg);
31689 return nativeResponseValue;
31691 // void InitFeatures_set_initial_routing_sync_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
31693 export function InitFeatures_set_initial_routing_sync_optional(this_arg: bigint): void {
31694 if(!isWasmInitialized) {
31695 throw new Error("initializeWasm() must be awaited first!");
31697 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_optional(this_arg);
31698 // debug statements here
31700 // void InitFeatures_set_initial_routing_sync_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
31702 export function InitFeatures_set_initial_routing_sync_required(this_arg: bigint): void {
31703 if(!isWasmInitialized) {
31704 throw new Error("initializeWasm() must be awaited first!");
31706 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_required(this_arg);
31707 // debug statements here
31709 // MUST_USE_RES bool InitFeatures_initial_routing_sync(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31711 export function InitFeatures_initial_routing_sync(this_arg: bigint): boolean {
31712 if(!isWasmInitialized) {
31713 throw new Error("initializeWasm() must be awaited first!");
31715 const nativeResponseValue = wasm.TS_InitFeatures_initial_routing_sync(this_arg);
31716 return nativeResponseValue;
31718 // void InitFeatures_set_upfront_shutdown_script_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
31720 export function InitFeatures_set_upfront_shutdown_script_optional(this_arg: bigint): void {
31721 if(!isWasmInitialized) {
31722 throw new Error("initializeWasm() must be awaited first!");
31724 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_optional(this_arg);
31725 // debug statements here
31727 // void InitFeatures_set_upfront_shutdown_script_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
31729 export function InitFeatures_set_upfront_shutdown_script_required(this_arg: bigint): void {
31730 if(!isWasmInitialized) {
31731 throw new Error("initializeWasm() must be awaited first!");
31733 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_required(this_arg);
31734 // debug statements here
31736 // MUST_USE_RES bool InitFeatures_supports_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31738 export function InitFeatures_supports_upfront_shutdown_script(this_arg: bigint): boolean {
31739 if(!isWasmInitialized) {
31740 throw new Error("initializeWasm() must be awaited first!");
31742 const nativeResponseValue = wasm.TS_InitFeatures_supports_upfront_shutdown_script(this_arg);
31743 return nativeResponseValue;
31745 // void NodeFeatures_set_upfront_shutdown_script_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31747 export function NodeFeatures_set_upfront_shutdown_script_optional(this_arg: bigint): void {
31748 if(!isWasmInitialized) {
31749 throw new Error("initializeWasm() must be awaited first!");
31751 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_optional(this_arg);
31752 // debug statements here
31754 // void NodeFeatures_set_upfront_shutdown_script_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31756 export function NodeFeatures_set_upfront_shutdown_script_required(this_arg: bigint): void {
31757 if(!isWasmInitialized) {
31758 throw new Error("initializeWasm() must be awaited first!");
31760 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_required(this_arg);
31761 // debug statements here
31763 // MUST_USE_RES bool NodeFeatures_supports_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31765 export function NodeFeatures_supports_upfront_shutdown_script(this_arg: bigint): boolean {
31766 if(!isWasmInitialized) {
31767 throw new Error("initializeWasm() must be awaited first!");
31769 const nativeResponseValue = wasm.TS_NodeFeatures_supports_upfront_shutdown_script(this_arg);
31770 return nativeResponseValue;
31772 // MUST_USE_RES bool InitFeatures_requires_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31774 export function InitFeatures_requires_upfront_shutdown_script(this_arg: bigint): boolean {
31775 if(!isWasmInitialized) {
31776 throw new Error("initializeWasm() must be awaited first!");
31778 const nativeResponseValue = wasm.TS_InitFeatures_requires_upfront_shutdown_script(this_arg);
31779 return nativeResponseValue;
31781 // MUST_USE_RES bool NodeFeatures_requires_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31783 export function NodeFeatures_requires_upfront_shutdown_script(this_arg: bigint): boolean {
31784 if(!isWasmInitialized) {
31785 throw new Error("initializeWasm() must be awaited first!");
31787 const nativeResponseValue = wasm.TS_NodeFeatures_requires_upfront_shutdown_script(this_arg);
31788 return nativeResponseValue;
31790 // void InitFeatures_set_gossip_queries_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
31792 export function InitFeatures_set_gossip_queries_optional(this_arg: bigint): void {
31793 if(!isWasmInitialized) {
31794 throw new Error("initializeWasm() must be awaited first!");
31796 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_optional(this_arg);
31797 // debug statements here
31799 // void InitFeatures_set_gossip_queries_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
31801 export function InitFeatures_set_gossip_queries_required(this_arg: bigint): void {
31802 if(!isWasmInitialized) {
31803 throw new Error("initializeWasm() must be awaited first!");
31805 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_required(this_arg);
31806 // debug statements here
31808 // MUST_USE_RES bool InitFeatures_supports_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31810 export function InitFeatures_supports_gossip_queries(this_arg: bigint): boolean {
31811 if(!isWasmInitialized) {
31812 throw new Error("initializeWasm() must be awaited first!");
31814 const nativeResponseValue = wasm.TS_InitFeatures_supports_gossip_queries(this_arg);
31815 return nativeResponseValue;
31817 // void NodeFeatures_set_gossip_queries_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31819 export function NodeFeatures_set_gossip_queries_optional(this_arg: bigint): void {
31820 if(!isWasmInitialized) {
31821 throw new Error("initializeWasm() must be awaited first!");
31823 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_optional(this_arg);
31824 // debug statements here
31826 // void NodeFeatures_set_gossip_queries_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31828 export function NodeFeatures_set_gossip_queries_required(this_arg: bigint): void {
31829 if(!isWasmInitialized) {
31830 throw new Error("initializeWasm() must be awaited first!");
31832 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_required(this_arg);
31833 // debug statements here
31835 // MUST_USE_RES bool NodeFeatures_supports_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31837 export function NodeFeatures_supports_gossip_queries(this_arg: bigint): boolean {
31838 if(!isWasmInitialized) {
31839 throw new Error("initializeWasm() must be awaited first!");
31841 const nativeResponseValue = wasm.TS_NodeFeatures_supports_gossip_queries(this_arg);
31842 return nativeResponseValue;
31844 // MUST_USE_RES bool InitFeatures_requires_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31846 export function InitFeatures_requires_gossip_queries(this_arg: bigint): boolean {
31847 if(!isWasmInitialized) {
31848 throw new Error("initializeWasm() must be awaited first!");
31850 const nativeResponseValue = wasm.TS_InitFeatures_requires_gossip_queries(this_arg);
31851 return nativeResponseValue;
31853 // MUST_USE_RES bool NodeFeatures_requires_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31855 export function NodeFeatures_requires_gossip_queries(this_arg: bigint): boolean {
31856 if(!isWasmInitialized) {
31857 throw new Error("initializeWasm() must be awaited first!");
31859 const nativeResponseValue = wasm.TS_NodeFeatures_requires_gossip_queries(this_arg);
31860 return nativeResponseValue;
31862 // void InitFeatures_set_variable_length_onion_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
31864 export function InitFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
31865 if(!isWasmInitialized) {
31866 throw new Error("initializeWasm() must be awaited first!");
31868 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_optional(this_arg);
31869 // debug statements here
31871 // void InitFeatures_set_variable_length_onion_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
31873 export function InitFeatures_set_variable_length_onion_required(this_arg: bigint): void {
31874 if(!isWasmInitialized) {
31875 throw new Error("initializeWasm() must be awaited first!");
31877 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_required(this_arg);
31878 // debug statements here
31880 // MUST_USE_RES bool InitFeatures_supports_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31882 export function InitFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
31883 if(!isWasmInitialized) {
31884 throw new Error("initializeWasm() must be awaited first!");
31886 const nativeResponseValue = wasm.TS_InitFeatures_supports_variable_length_onion(this_arg);
31887 return nativeResponseValue;
31889 // void NodeFeatures_set_variable_length_onion_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31891 export function NodeFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
31892 if(!isWasmInitialized) {
31893 throw new Error("initializeWasm() must be awaited first!");
31895 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_optional(this_arg);
31896 // debug statements here
31898 // void NodeFeatures_set_variable_length_onion_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31900 export function NodeFeatures_set_variable_length_onion_required(this_arg: bigint): void {
31901 if(!isWasmInitialized) {
31902 throw new Error("initializeWasm() must be awaited first!");
31904 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_required(this_arg);
31905 // debug statements here
31907 // MUST_USE_RES bool NodeFeatures_supports_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31909 export function NodeFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
31910 if(!isWasmInitialized) {
31911 throw new Error("initializeWasm() must be awaited first!");
31913 const nativeResponseValue = wasm.TS_NodeFeatures_supports_variable_length_onion(this_arg);
31914 return nativeResponseValue;
31916 // void InvoiceFeatures_set_variable_length_onion_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
31918 export function InvoiceFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
31919 if(!isWasmInitialized) {
31920 throw new Error("initializeWasm() must be awaited first!");
31922 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_variable_length_onion_optional(this_arg);
31923 // debug statements here
31925 // void InvoiceFeatures_set_variable_length_onion_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
31927 export function InvoiceFeatures_set_variable_length_onion_required(this_arg: bigint): void {
31928 if(!isWasmInitialized) {
31929 throw new Error("initializeWasm() must be awaited first!");
31931 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_variable_length_onion_required(this_arg);
31932 // debug statements here
31934 // MUST_USE_RES bool InvoiceFeatures_supports_variable_length_onion(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
31936 export function InvoiceFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
31937 if(!isWasmInitialized) {
31938 throw new Error("initializeWasm() must be awaited first!");
31940 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_variable_length_onion(this_arg);
31941 return nativeResponseValue;
31943 // MUST_USE_RES bool InitFeatures_requires_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31945 export function InitFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
31946 if(!isWasmInitialized) {
31947 throw new Error("initializeWasm() must be awaited first!");
31949 const nativeResponseValue = wasm.TS_InitFeatures_requires_variable_length_onion(this_arg);
31950 return nativeResponseValue;
31952 // MUST_USE_RES bool NodeFeatures_requires_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31954 export function NodeFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
31955 if(!isWasmInitialized) {
31956 throw new Error("initializeWasm() must be awaited first!");
31958 const nativeResponseValue = wasm.TS_NodeFeatures_requires_variable_length_onion(this_arg);
31959 return nativeResponseValue;
31961 // MUST_USE_RES bool InvoiceFeatures_requires_variable_length_onion(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
31963 export function InvoiceFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
31964 if(!isWasmInitialized) {
31965 throw new Error("initializeWasm() must be awaited first!");
31967 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_variable_length_onion(this_arg);
31968 return nativeResponseValue;
31970 // void InitFeatures_set_static_remote_key_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
31972 export function InitFeatures_set_static_remote_key_optional(this_arg: bigint): void {
31973 if(!isWasmInitialized) {
31974 throw new Error("initializeWasm() must be awaited first!");
31976 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_optional(this_arg);
31977 // debug statements here
31979 // void InitFeatures_set_static_remote_key_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
31981 export function InitFeatures_set_static_remote_key_required(this_arg: bigint): void {
31982 if(!isWasmInitialized) {
31983 throw new Error("initializeWasm() must be awaited first!");
31985 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_required(this_arg);
31986 // debug statements here
31988 // MUST_USE_RES bool InitFeatures_supports_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31990 export function InitFeatures_supports_static_remote_key(this_arg: bigint): boolean {
31991 if(!isWasmInitialized) {
31992 throw new Error("initializeWasm() must be awaited first!");
31994 const nativeResponseValue = wasm.TS_InitFeatures_supports_static_remote_key(this_arg);
31995 return nativeResponseValue;
31997 // void NodeFeatures_set_static_remote_key_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31999 export function NodeFeatures_set_static_remote_key_optional(this_arg: bigint): void {
32000 if(!isWasmInitialized) {
32001 throw new Error("initializeWasm() must be awaited first!");
32003 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_optional(this_arg);
32004 // debug statements here
32006 // void NodeFeatures_set_static_remote_key_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
32008 export function NodeFeatures_set_static_remote_key_required(this_arg: bigint): void {
32009 if(!isWasmInitialized) {
32010 throw new Error("initializeWasm() must be awaited first!");
32012 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_required(this_arg);
32013 // debug statements here
32015 // MUST_USE_RES bool NodeFeatures_supports_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
32017 export function NodeFeatures_supports_static_remote_key(this_arg: bigint): boolean {
32018 if(!isWasmInitialized) {
32019 throw new Error("initializeWasm() must be awaited first!");
32021 const nativeResponseValue = wasm.TS_NodeFeatures_supports_static_remote_key(this_arg);
32022 return nativeResponseValue;
32024 // void ChannelTypeFeatures_set_static_remote_key_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
32026 export function ChannelTypeFeatures_set_static_remote_key_optional(this_arg: bigint): void {
32027 if(!isWasmInitialized) {
32028 throw new Error("initializeWasm() must be awaited first!");
32030 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_optional(this_arg);
32031 // debug statements here
32033 // void ChannelTypeFeatures_set_static_remote_key_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
32035 export function ChannelTypeFeatures_set_static_remote_key_required(this_arg: bigint): void {
32036 if(!isWasmInitialized) {
32037 throw new Error("initializeWasm() must be awaited first!");
32039 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_required(this_arg);
32040 // debug statements here
32042 // MUST_USE_RES bool ChannelTypeFeatures_supports_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
32044 export function ChannelTypeFeatures_supports_static_remote_key(this_arg: bigint): boolean {
32045 if(!isWasmInitialized) {
32046 throw new Error("initializeWasm() must be awaited first!");
32048 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_static_remote_key(this_arg);
32049 return nativeResponseValue;
32051 // MUST_USE_RES bool InitFeatures_requires_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
32053 export function InitFeatures_requires_static_remote_key(this_arg: bigint): boolean {
32054 if(!isWasmInitialized) {
32055 throw new Error("initializeWasm() must be awaited first!");
32057 const nativeResponseValue = wasm.TS_InitFeatures_requires_static_remote_key(this_arg);
32058 return nativeResponseValue;
32060 // MUST_USE_RES bool NodeFeatures_requires_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
32062 export function NodeFeatures_requires_static_remote_key(this_arg: bigint): boolean {
32063 if(!isWasmInitialized) {
32064 throw new Error("initializeWasm() must be awaited first!");
32066 const nativeResponseValue = wasm.TS_NodeFeatures_requires_static_remote_key(this_arg);
32067 return nativeResponseValue;
32069 // MUST_USE_RES bool ChannelTypeFeatures_requires_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
32071 export function ChannelTypeFeatures_requires_static_remote_key(this_arg: bigint): boolean {
32072 if(!isWasmInitialized) {
32073 throw new Error("initializeWasm() must be awaited first!");
32075 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_static_remote_key(this_arg);
32076 return nativeResponseValue;
32078 // void InitFeatures_set_payment_secret_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
32080 export function InitFeatures_set_payment_secret_optional(this_arg: bigint): void {
32081 if(!isWasmInitialized) {
32082 throw new Error("initializeWasm() must be awaited first!");
32084 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_optional(this_arg);
32085 // debug statements here
32087 // void InitFeatures_set_payment_secret_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
32089 export function InitFeatures_set_payment_secret_required(this_arg: bigint): void {
32090 if(!isWasmInitialized) {
32091 throw new Error("initializeWasm() must be awaited first!");
32093 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_required(this_arg);
32094 // debug statements here
32096 // MUST_USE_RES bool InitFeatures_supports_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
32098 export function InitFeatures_supports_payment_secret(this_arg: bigint): boolean {
32099 if(!isWasmInitialized) {
32100 throw new Error("initializeWasm() must be awaited first!");
32102 const nativeResponseValue = wasm.TS_InitFeatures_supports_payment_secret(this_arg);
32103 return nativeResponseValue;
32105 // void NodeFeatures_set_payment_secret_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
32107 export function NodeFeatures_set_payment_secret_optional(this_arg: bigint): void {
32108 if(!isWasmInitialized) {
32109 throw new Error("initializeWasm() must be awaited first!");
32111 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_optional(this_arg);
32112 // debug statements here
32114 // void NodeFeatures_set_payment_secret_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
32116 export function NodeFeatures_set_payment_secret_required(this_arg: bigint): void {
32117 if(!isWasmInitialized) {
32118 throw new Error("initializeWasm() must be awaited first!");
32120 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_required(this_arg);
32121 // debug statements here
32123 // MUST_USE_RES bool NodeFeatures_supports_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
32125 export function NodeFeatures_supports_payment_secret(this_arg: bigint): boolean {
32126 if(!isWasmInitialized) {
32127 throw new Error("initializeWasm() must be awaited first!");
32129 const nativeResponseValue = wasm.TS_NodeFeatures_supports_payment_secret(this_arg);
32130 return nativeResponseValue;
32132 // void InvoiceFeatures_set_payment_secret_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
32134 export function InvoiceFeatures_set_payment_secret_optional(this_arg: bigint): void {
32135 if(!isWasmInitialized) {
32136 throw new Error("initializeWasm() must be awaited first!");
32138 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_payment_secret_optional(this_arg);
32139 // debug statements here
32141 // void InvoiceFeatures_set_payment_secret_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
32143 export function InvoiceFeatures_set_payment_secret_required(this_arg: bigint): void {
32144 if(!isWasmInitialized) {
32145 throw new Error("initializeWasm() must be awaited first!");
32147 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_payment_secret_required(this_arg);
32148 // debug statements here
32150 // MUST_USE_RES bool InvoiceFeatures_supports_payment_secret(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
32152 export function InvoiceFeatures_supports_payment_secret(this_arg: bigint): boolean {
32153 if(!isWasmInitialized) {
32154 throw new Error("initializeWasm() must be awaited first!");
32156 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_payment_secret(this_arg);
32157 return nativeResponseValue;
32159 // MUST_USE_RES bool InitFeatures_requires_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
32161 export function InitFeatures_requires_payment_secret(this_arg: bigint): boolean {
32162 if(!isWasmInitialized) {
32163 throw new Error("initializeWasm() must be awaited first!");
32165 const nativeResponseValue = wasm.TS_InitFeatures_requires_payment_secret(this_arg);
32166 return nativeResponseValue;
32168 // MUST_USE_RES bool NodeFeatures_requires_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
32170 export function NodeFeatures_requires_payment_secret(this_arg: bigint): boolean {
32171 if(!isWasmInitialized) {
32172 throw new Error("initializeWasm() must be awaited first!");
32174 const nativeResponseValue = wasm.TS_NodeFeatures_requires_payment_secret(this_arg);
32175 return nativeResponseValue;
32177 // MUST_USE_RES bool InvoiceFeatures_requires_payment_secret(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
32179 export function InvoiceFeatures_requires_payment_secret(this_arg: bigint): boolean {
32180 if(!isWasmInitialized) {
32181 throw new Error("initializeWasm() must be awaited first!");
32183 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_payment_secret(this_arg);
32184 return nativeResponseValue;
32186 // void InitFeatures_set_basic_mpp_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
32188 export function InitFeatures_set_basic_mpp_optional(this_arg: bigint): void {
32189 if(!isWasmInitialized) {
32190 throw new Error("initializeWasm() must be awaited first!");
32192 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_optional(this_arg);
32193 // debug statements here
32195 // void InitFeatures_set_basic_mpp_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
32197 export function InitFeatures_set_basic_mpp_required(this_arg: bigint): void {
32198 if(!isWasmInitialized) {
32199 throw new Error("initializeWasm() must be awaited first!");
32201 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_required(this_arg);
32202 // debug statements here
32204 // MUST_USE_RES bool InitFeatures_supports_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
32206 export function InitFeatures_supports_basic_mpp(this_arg: bigint): boolean {
32207 if(!isWasmInitialized) {
32208 throw new Error("initializeWasm() must be awaited first!");
32210 const nativeResponseValue = wasm.TS_InitFeatures_supports_basic_mpp(this_arg);
32211 return nativeResponseValue;
32213 // void NodeFeatures_set_basic_mpp_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
32215 export function NodeFeatures_set_basic_mpp_optional(this_arg: bigint): void {
32216 if(!isWasmInitialized) {
32217 throw new Error("initializeWasm() must be awaited first!");
32219 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_optional(this_arg);
32220 // debug statements here
32222 // void NodeFeatures_set_basic_mpp_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
32224 export function NodeFeatures_set_basic_mpp_required(this_arg: bigint): void {
32225 if(!isWasmInitialized) {
32226 throw new Error("initializeWasm() must be awaited first!");
32228 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_required(this_arg);
32229 // debug statements here
32231 // MUST_USE_RES bool NodeFeatures_supports_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
32233 export function NodeFeatures_supports_basic_mpp(this_arg: bigint): boolean {
32234 if(!isWasmInitialized) {
32235 throw new Error("initializeWasm() must be awaited first!");
32237 const nativeResponseValue = wasm.TS_NodeFeatures_supports_basic_mpp(this_arg);
32238 return nativeResponseValue;
32240 // void InvoiceFeatures_set_basic_mpp_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
32242 export function InvoiceFeatures_set_basic_mpp_optional(this_arg: bigint): void {
32243 if(!isWasmInitialized) {
32244 throw new Error("initializeWasm() must be awaited first!");
32246 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_basic_mpp_optional(this_arg);
32247 // debug statements here
32249 // void InvoiceFeatures_set_basic_mpp_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
32251 export function InvoiceFeatures_set_basic_mpp_required(this_arg: bigint): void {
32252 if(!isWasmInitialized) {
32253 throw new Error("initializeWasm() must be awaited first!");
32255 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_basic_mpp_required(this_arg);
32256 // debug statements here
32258 // MUST_USE_RES bool InvoiceFeatures_supports_basic_mpp(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
32260 export function InvoiceFeatures_supports_basic_mpp(this_arg: bigint): boolean {
32261 if(!isWasmInitialized) {
32262 throw new Error("initializeWasm() must be awaited first!");
32264 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_basic_mpp(this_arg);
32265 return nativeResponseValue;
32267 // void Bolt12InvoiceFeatures_set_basic_mpp_optional(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
32269 export function Bolt12InvoiceFeatures_set_basic_mpp_optional(this_arg: bigint): void {
32270 if(!isWasmInitialized) {
32271 throw new Error("initializeWasm() must be awaited first!");
32273 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_basic_mpp_optional(this_arg);
32274 // debug statements here
32276 // void Bolt12InvoiceFeatures_set_basic_mpp_required(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
32278 export function Bolt12InvoiceFeatures_set_basic_mpp_required(this_arg: bigint): void {
32279 if(!isWasmInitialized) {
32280 throw new Error("initializeWasm() must be awaited first!");
32282 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_basic_mpp_required(this_arg);
32283 // debug statements here
32285 // MUST_USE_RES bool Bolt12InvoiceFeatures_supports_basic_mpp(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
32287 export function Bolt12InvoiceFeatures_supports_basic_mpp(this_arg: bigint): boolean {
32288 if(!isWasmInitialized) {
32289 throw new Error("initializeWasm() must be awaited first!");
32291 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_supports_basic_mpp(this_arg);
32292 return nativeResponseValue;
32294 // MUST_USE_RES bool InitFeatures_requires_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
32296 export function InitFeatures_requires_basic_mpp(this_arg: bigint): boolean {
32297 if(!isWasmInitialized) {
32298 throw new Error("initializeWasm() must be awaited first!");
32300 const nativeResponseValue = wasm.TS_InitFeatures_requires_basic_mpp(this_arg);
32301 return nativeResponseValue;
32303 // MUST_USE_RES bool NodeFeatures_requires_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
32305 export function NodeFeatures_requires_basic_mpp(this_arg: bigint): boolean {
32306 if(!isWasmInitialized) {
32307 throw new Error("initializeWasm() must be awaited first!");
32309 const nativeResponseValue = wasm.TS_NodeFeatures_requires_basic_mpp(this_arg);
32310 return nativeResponseValue;
32312 // MUST_USE_RES bool InvoiceFeatures_requires_basic_mpp(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
32314 export function InvoiceFeatures_requires_basic_mpp(this_arg: bigint): boolean {
32315 if(!isWasmInitialized) {
32316 throw new Error("initializeWasm() must be awaited first!");
32318 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_basic_mpp(this_arg);
32319 return nativeResponseValue;
32321 // MUST_USE_RES bool Bolt12InvoiceFeatures_requires_basic_mpp(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
32323 export function Bolt12InvoiceFeatures_requires_basic_mpp(this_arg: bigint): boolean {
32324 if(!isWasmInitialized) {
32325 throw new Error("initializeWasm() must be awaited first!");
32327 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_requires_basic_mpp(this_arg);
32328 return nativeResponseValue;
32330 // void InitFeatures_set_wumbo_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
32332 export function InitFeatures_set_wumbo_optional(this_arg: bigint): void {
32333 if(!isWasmInitialized) {
32334 throw new Error("initializeWasm() must be awaited first!");
32336 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_optional(this_arg);
32337 // debug statements here
32339 // void InitFeatures_set_wumbo_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
32341 export function InitFeatures_set_wumbo_required(this_arg: bigint): void {
32342 if(!isWasmInitialized) {
32343 throw new Error("initializeWasm() must be awaited first!");
32345 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_required(this_arg);
32346 // debug statements here
32348 // MUST_USE_RES bool InitFeatures_supports_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
32350 export function InitFeatures_supports_wumbo(this_arg: bigint): boolean {
32351 if(!isWasmInitialized) {
32352 throw new Error("initializeWasm() must be awaited first!");
32354 const nativeResponseValue = wasm.TS_InitFeatures_supports_wumbo(this_arg);
32355 return nativeResponseValue;
32357 // void NodeFeatures_set_wumbo_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
32359 export function NodeFeatures_set_wumbo_optional(this_arg: bigint): void {
32360 if(!isWasmInitialized) {
32361 throw new Error("initializeWasm() must be awaited first!");
32363 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_optional(this_arg);
32364 // debug statements here
32366 // void NodeFeatures_set_wumbo_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
32368 export function NodeFeatures_set_wumbo_required(this_arg: bigint): void {
32369 if(!isWasmInitialized) {
32370 throw new Error("initializeWasm() must be awaited first!");
32372 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_required(this_arg);
32373 // debug statements here
32375 // MUST_USE_RES bool NodeFeatures_supports_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
32377 export function NodeFeatures_supports_wumbo(this_arg: bigint): boolean {
32378 if(!isWasmInitialized) {
32379 throw new Error("initializeWasm() must be awaited first!");
32381 const nativeResponseValue = wasm.TS_NodeFeatures_supports_wumbo(this_arg);
32382 return nativeResponseValue;
32384 // MUST_USE_RES bool InitFeatures_requires_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
32386 export function InitFeatures_requires_wumbo(this_arg: bigint): boolean {
32387 if(!isWasmInitialized) {
32388 throw new Error("initializeWasm() must be awaited first!");
32390 const nativeResponseValue = wasm.TS_InitFeatures_requires_wumbo(this_arg);
32391 return nativeResponseValue;
32393 // MUST_USE_RES bool NodeFeatures_requires_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
32395 export function NodeFeatures_requires_wumbo(this_arg: bigint): boolean {
32396 if(!isWasmInitialized) {
32397 throw new Error("initializeWasm() must be awaited first!");
32399 const nativeResponseValue = wasm.TS_NodeFeatures_requires_wumbo(this_arg);
32400 return nativeResponseValue;
32402 // void InitFeatures_set_anchors_zero_fee_htlc_tx_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
32404 export function InitFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg: bigint): void {
32405 if(!isWasmInitialized) {
32406 throw new Error("initializeWasm() must be awaited first!");
32408 const nativeResponseValue = wasm.TS_InitFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg);
32409 // debug statements here
32411 // void InitFeatures_set_anchors_zero_fee_htlc_tx_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
32413 export function InitFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg: bigint): void {
32414 if(!isWasmInitialized) {
32415 throw new Error("initializeWasm() must be awaited first!");
32417 const nativeResponseValue = wasm.TS_InitFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg);
32418 // debug statements here
32420 // MUST_USE_RES bool InitFeatures_supports_anchors_zero_fee_htlc_tx(const struct LDKInitFeatures *NONNULL_PTR this_arg);
32422 export function InitFeatures_supports_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
32423 if(!isWasmInitialized) {
32424 throw new Error("initializeWasm() must be awaited first!");
32426 const nativeResponseValue = wasm.TS_InitFeatures_supports_anchors_zero_fee_htlc_tx(this_arg);
32427 return nativeResponseValue;
32429 // void NodeFeatures_set_anchors_zero_fee_htlc_tx_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
32431 export function NodeFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg: bigint): void {
32432 if(!isWasmInitialized) {
32433 throw new Error("initializeWasm() must be awaited first!");
32435 const nativeResponseValue = wasm.TS_NodeFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg);
32436 // debug statements here
32438 // void NodeFeatures_set_anchors_zero_fee_htlc_tx_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
32440 export function NodeFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg: bigint): void {
32441 if(!isWasmInitialized) {
32442 throw new Error("initializeWasm() must be awaited first!");
32444 const nativeResponseValue = wasm.TS_NodeFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg);
32445 // debug statements here
32447 // MUST_USE_RES bool NodeFeatures_supports_anchors_zero_fee_htlc_tx(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
32449 export function NodeFeatures_supports_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
32450 if(!isWasmInitialized) {
32451 throw new Error("initializeWasm() must be awaited first!");
32453 const nativeResponseValue = wasm.TS_NodeFeatures_supports_anchors_zero_fee_htlc_tx(this_arg);
32454 return nativeResponseValue;
32456 // void ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
32458 export function ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg: bigint): void {
32459 if(!isWasmInitialized) {
32460 throw new Error("initializeWasm() must be awaited first!");
32462 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg);
32463 // debug statements here
32465 // void ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
32467 export function ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg: bigint): void {
32468 if(!isWasmInitialized) {
32469 throw new Error("initializeWasm() must be awaited first!");
32471 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg);
32472 // debug statements here
32474 // MUST_USE_RES bool ChannelTypeFeatures_supports_anchors_zero_fee_htlc_tx(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
32476 export function ChannelTypeFeatures_supports_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
32477 if(!isWasmInitialized) {
32478 throw new Error("initializeWasm() must be awaited first!");
32480 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_anchors_zero_fee_htlc_tx(this_arg);
32481 return nativeResponseValue;
32483 // MUST_USE_RES bool InitFeatures_requires_anchors_zero_fee_htlc_tx(const struct LDKInitFeatures *NONNULL_PTR this_arg);
32485 export function InitFeatures_requires_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
32486 if(!isWasmInitialized) {
32487 throw new Error("initializeWasm() must be awaited first!");
32489 const nativeResponseValue = wasm.TS_InitFeatures_requires_anchors_zero_fee_htlc_tx(this_arg);
32490 return nativeResponseValue;
32492 // MUST_USE_RES bool NodeFeatures_requires_anchors_zero_fee_htlc_tx(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
32494 export function NodeFeatures_requires_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
32495 if(!isWasmInitialized) {
32496 throw new Error("initializeWasm() must be awaited first!");
32498 const nativeResponseValue = wasm.TS_NodeFeatures_requires_anchors_zero_fee_htlc_tx(this_arg);
32499 return nativeResponseValue;
32501 // MUST_USE_RES bool ChannelTypeFeatures_requires_anchors_zero_fee_htlc_tx(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
32503 export function ChannelTypeFeatures_requires_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
32504 if(!isWasmInitialized) {
32505 throw new Error("initializeWasm() must be awaited first!");
32507 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_anchors_zero_fee_htlc_tx(this_arg);
32508 return nativeResponseValue;
32510 // void InitFeatures_set_shutdown_any_segwit_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
32512 export function InitFeatures_set_shutdown_any_segwit_optional(this_arg: bigint): void {
32513 if(!isWasmInitialized) {
32514 throw new Error("initializeWasm() must be awaited first!");
32516 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_optional(this_arg);
32517 // debug statements here
32519 // void InitFeatures_set_shutdown_any_segwit_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
32521 export function InitFeatures_set_shutdown_any_segwit_required(this_arg: bigint): void {
32522 if(!isWasmInitialized) {
32523 throw new Error("initializeWasm() must be awaited first!");
32525 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_required(this_arg);
32526 // debug statements here
32528 // MUST_USE_RES bool InitFeatures_supports_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
32530 export function InitFeatures_supports_shutdown_anysegwit(this_arg: bigint): boolean {
32531 if(!isWasmInitialized) {
32532 throw new Error("initializeWasm() must be awaited first!");
32534 const nativeResponseValue = wasm.TS_InitFeatures_supports_shutdown_anysegwit(this_arg);
32535 return nativeResponseValue;
32537 // void NodeFeatures_set_shutdown_any_segwit_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
32539 export function NodeFeatures_set_shutdown_any_segwit_optional(this_arg: bigint): void {
32540 if(!isWasmInitialized) {
32541 throw new Error("initializeWasm() must be awaited first!");
32543 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_optional(this_arg);
32544 // debug statements here
32546 // void NodeFeatures_set_shutdown_any_segwit_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
32548 export function NodeFeatures_set_shutdown_any_segwit_required(this_arg: bigint): void {
32549 if(!isWasmInitialized) {
32550 throw new Error("initializeWasm() must be awaited first!");
32552 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_required(this_arg);
32553 // debug statements here
32555 // MUST_USE_RES bool NodeFeatures_supports_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
32557 export function NodeFeatures_supports_shutdown_anysegwit(this_arg: bigint): boolean {
32558 if(!isWasmInitialized) {
32559 throw new Error("initializeWasm() must be awaited first!");
32561 const nativeResponseValue = wasm.TS_NodeFeatures_supports_shutdown_anysegwit(this_arg);
32562 return nativeResponseValue;
32564 // MUST_USE_RES bool InitFeatures_requires_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
32566 export function InitFeatures_requires_shutdown_anysegwit(this_arg: bigint): boolean {
32567 if(!isWasmInitialized) {
32568 throw new Error("initializeWasm() must be awaited first!");
32570 const nativeResponseValue = wasm.TS_InitFeatures_requires_shutdown_anysegwit(this_arg);
32571 return nativeResponseValue;
32573 // MUST_USE_RES bool NodeFeatures_requires_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
32575 export function NodeFeatures_requires_shutdown_anysegwit(this_arg: bigint): boolean {
32576 if(!isWasmInitialized) {
32577 throw new Error("initializeWasm() must be awaited first!");
32579 const nativeResponseValue = wasm.TS_NodeFeatures_requires_shutdown_anysegwit(this_arg);
32580 return nativeResponseValue;
32582 // void InitFeatures_set_onion_messages_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
32584 export function InitFeatures_set_onion_messages_optional(this_arg: bigint): void {
32585 if(!isWasmInitialized) {
32586 throw new Error("initializeWasm() must be awaited first!");
32588 const nativeResponseValue = wasm.TS_InitFeatures_set_onion_messages_optional(this_arg);
32589 // debug statements here
32591 // void InitFeatures_set_onion_messages_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
32593 export function InitFeatures_set_onion_messages_required(this_arg: bigint): void {
32594 if(!isWasmInitialized) {
32595 throw new Error("initializeWasm() must be awaited first!");
32597 const nativeResponseValue = wasm.TS_InitFeatures_set_onion_messages_required(this_arg);
32598 // debug statements here
32600 // MUST_USE_RES bool InitFeatures_supports_onion_messages(const struct LDKInitFeatures *NONNULL_PTR this_arg);
32602 export function InitFeatures_supports_onion_messages(this_arg: bigint): boolean {
32603 if(!isWasmInitialized) {
32604 throw new Error("initializeWasm() must be awaited first!");
32606 const nativeResponseValue = wasm.TS_InitFeatures_supports_onion_messages(this_arg);
32607 return nativeResponseValue;
32609 // void NodeFeatures_set_onion_messages_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
32611 export function NodeFeatures_set_onion_messages_optional(this_arg: bigint): void {
32612 if(!isWasmInitialized) {
32613 throw new Error("initializeWasm() must be awaited first!");
32615 const nativeResponseValue = wasm.TS_NodeFeatures_set_onion_messages_optional(this_arg);
32616 // debug statements here
32618 // void NodeFeatures_set_onion_messages_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
32620 export function NodeFeatures_set_onion_messages_required(this_arg: bigint): void {
32621 if(!isWasmInitialized) {
32622 throw new Error("initializeWasm() must be awaited first!");
32624 const nativeResponseValue = wasm.TS_NodeFeatures_set_onion_messages_required(this_arg);
32625 // debug statements here
32627 // MUST_USE_RES bool NodeFeatures_supports_onion_messages(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
32629 export function NodeFeatures_supports_onion_messages(this_arg: bigint): boolean {
32630 if(!isWasmInitialized) {
32631 throw new Error("initializeWasm() must be awaited first!");
32633 const nativeResponseValue = wasm.TS_NodeFeatures_supports_onion_messages(this_arg);
32634 return nativeResponseValue;
32636 // MUST_USE_RES bool InitFeatures_requires_onion_messages(const struct LDKInitFeatures *NONNULL_PTR this_arg);
32638 export function InitFeatures_requires_onion_messages(this_arg: bigint): boolean {
32639 if(!isWasmInitialized) {
32640 throw new Error("initializeWasm() must be awaited first!");
32642 const nativeResponseValue = wasm.TS_InitFeatures_requires_onion_messages(this_arg);
32643 return nativeResponseValue;
32645 // MUST_USE_RES bool NodeFeatures_requires_onion_messages(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
32647 export function NodeFeatures_requires_onion_messages(this_arg: bigint): boolean {
32648 if(!isWasmInitialized) {
32649 throw new Error("initializeWasm() must be awaited first!");
32651 const nativeResponseValue = wasm.TS_NodeFeatures_requires_onion_messages(this_arg);
32652 return nativeResponseValue;
32654 // void InitFeatures_set_channel_type_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
32656 export function InitFeatures_set_channel_type_optional(this_arg: bigint): void {
32657 if(!isWasmInitialized) {
32658 throw new Error("initializeWasm() must be awaited first!");
32660 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_optional(this_arg);
32661 // debug statements here
32663 // void InitFeatures_set_channel_type_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
32665 export function InitFeatures_set_channel_type_required(this_arg: bigint): void {
32666 if(!isWasmInitialized) {
32667 throw new Error("initializeWasm() must be awaited first!");
32669 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_required(this_arg);
32670 // debug statements here
32672 // MUST_USE_RES bool InitFeatures_supports_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
32674 export function InitFeatures_supports_channel_type(this_arg: bigint): boolean {
32675 if(!isWasmInitialized) {
32676 throw new Error("initializeWasm() must be awaited first!");
32678 const nativeResponseValue = wasm.TS_InitFeatures_supports_channel_type(this_arg);
32679 return nativeResponseValue;
32681 // void NodeFeatures_set_channel_type_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
32683 export function NodeFeatures_set_channel_type_optional(this_arg: bigint): void {
32684 if(!isWasmInitialized) {
32685 throw new Error("initializeWasm() must be awaited first!");
32687 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_optional(this_arg);
32688 // debug statements here
32690 // void NodeFeatures_set_channel_type_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
32692 export function NodeFeatures_set_channel_type_required(this_arg: bigint): void {
32693 if(!isWasmInitialized) {
32694 throw new Error("initializeWasm() must be awaited first!");
32696 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_required(this_arg);
32697 // debug statements here
32699 // MUST_USE_RES bool NodeFeatures_supports_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
32701 export function NodeFeatures_supports_channel_type(this_arg: bigint): boolean {
32702 if(!isWasmInitialized) {
32703 throw new Error("initializeWasm() must be awaited first!");
32705 const nativeResponseValue = wasm.TS_NodeFeatures_supports_channel_type(this_arg);
32706 return nativeResponseValue;
32708 // MUST_USE_RES bool InitFeatures_requires_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
32710 export function InitFeatures_requires_channel_type(this_arg: bigint): boolean {
32711 if(!isWasmInitialized) {
32712 throw new Error("initializeWasm() must be awaited first!");
32714 const nativeResponseValue = wasm.TS_InitFeatures_requires_channel_type(this_arg);
32715 return nativeResponseValue;
32717 // MUST_USE_RES bool NodeFeatures_requires_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
32719 export function NodeFeatures_requires_channel_type(this_arg: bigint): boolean {
32720 if(!isWasmInitialized) {
32721 throw new Error("initializeWasm() must be awaited first!");
32723 const nativeResponseValue = wasm.TS_NodeFeatures_requires_channel_type(this_arg);
32724 return nativeResponseValue;
32726 // void InitFeatures_set_scid_privacy_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
32728 export function InitFeatures_set_scid_privacy_optional(this_arg: bigint): void {
32729 if(!isWasmInitialized) {
32730 throw new Error("initializeWasm() must be awaited first!");
32732 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_optional(this_arg);
32733 // debug statements here
32735 // void InitFeatures_set_scid_privacy_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
32737 export function InitFeatures_set_scid_privacy_required(this_arg: bigint): void {
32738 if(!isWasmInitialized) {
32739 throw new Error("initializeWasm() must be awaited first!");
32741 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_required(this_arg);
32742 // debug statements here
32744 // MUST_USE_RES bool InitFeatures_supports_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
32746 export function InitFeatures_supports_scid_privacy(this_arg: bigint): boolean {
32747 if(!isWasmInitialized) {
32748 throw new Error("initializeWasm() must be awaited first!");
32750 const nativeResponseValue = wasm.TS_InitFeatures_supports_scid_privacy(this_arg);
32751 return nativeResponseValue;
32753 // void NodeFeatures_set_scid_privacy_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
32755 export function NodeFeatures_set_scid_privacy_optional(this_arg: bigint): void {
32756 if(!isWasmInitialized) {
32757 throw new Error("initializeWasm() must be awaited first!");
32759 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_optional(this_arg);
32760 // debug statements here
32762 // void NodeFeatures_set_scid_privacy_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
32764 export function NodeFeatures_set_scid_privacy_required(this_arg: bigint): void {
32765 if(!isWasmInitialized) {
32766 throw new Error("initializeWasm() must be awaited first!");
32768 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_required(this_arg);
32769 // debug statements here
32771 // MUST_USE_RES bool NodeFeatures_supports_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
32773 export function NodeFeatures_supports_scid_privacy(this_arg: bigint): boolean {
32774 if(!isWasmInitialized) {
32775 throw new Error("initializeWasm() must be awaited first!");
32777 const nativeResponseValue = wasm.TS_NodeFeatures_supports_scid_privacy(this_arg);
32778 return nativeResponseValue;
32780 // void ChannelTypeFeatures_set_scid_privacy_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
32782 export function ChannelTypeFeatures_set_scid_privacy_optional(this_arg: bigint): void {
32783 if(!isWasmInitialized) {
32784 throw new Error("initializeWasm() must be awaited first!");
32786 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_optional(this_arg);
32787 // debug statements here
32789 // void ChannelTypeFeatures_set_scid_privacy_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
32791 export function ChannelTypeFeatures_set_scid_privacy_required(this_arg: bigint): void {
32792 if(!isWasmInitialized) {
32793 throw new Error("initializeWasm() must be awaited first!");
32795 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_required(this_arg);
32796 // debug statements here
32798 // MUST_USE_RES bool ChannelTypeFeatures_supports_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
32800 export function ChannelTypeFeatures_supports_scid_privacy(this_arg: bigint): boolean {
32801 if(!isWasmInitialized) {
32802 throw new Error("initializeWasm() must be awaited first!");
32804 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_scid_privacy(this_arg);
32805 return nativeResponseValue;
32807 // MUST_USE_RES bool InitFeatures_requires_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
32809 export function InitFeatures_requires_scid_privacy(this_arg: bigint): boolean {
32810 if(!isWasmInitialized) {
32811 throw new Error("initializeWasm() must be awaited first!");
32813 const nativeResponseValue = wasm.TS_InitFeatures_requires_scid_privacy(this_arg);
32814 return nativeResponseValue;
32816 // MUST_USE_RES bool NodeFeatures_requires_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
32818 export function NodeFeatures_requires_scid_privacy(this_arg: bigint): boolean {
32819 if(!isWasmInitialized) {
32820 throw new Error("initializeWasm() must be awaited first!");
32822 const nativeResponseValue = wasm.TS_NodeFeatures_requires_scid_privacy(this_arg);
32823 return nativeResponseValue;
32825 // MUST_USE_RES bool ChannelTypeFeatures_requires_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
32827 export function ChannelTypeFeatures_requires_scid_privacy(this_arg: bigint): boolean {
32828 if(!isWasmInitialized) {
32829 throw new Error("initializeWasm() must be awaited first!");
32831 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_scid_privacy(this_arg);
32832 return nativeResponseValue;
32834 // void InitFeatures_set_zero_conf_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
32836 export function InitFeatures_set_zero_conf_optional(this_arg: bigint): void {
32837 if(!isWasmInitialized) {
32838 throw new Error("initializeWasm() must be awaited first!");
32840 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_optional(this_arg);
32841 // debug statements here
32843 // void InitFeatures_set_zero_conf_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
32845 export function InitFeatures_set_zero_conf_required(this_arg: bigint): void {
32846 if(!isWasmInitialized) {
32847 throw new Error("initializeWasm() must be awaited first!");
32849 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_required(this_arg);
32850 // debug statements here
32852 // MUST_USE_RES bool InitFeatures_supports_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
32854 export function InitFeatures_supports_zero_conf(this_arg: bigint): boolean {
32855 if(!isWasmInitialized) {
32856 throw new Error("initializeWasm() must be awaited first!");
32858 const nativeResponseValue = wasm.TS_InitFeatures_supports_zero_conf(this_arg);
32859 return nativeResponseValue;
32861 // void NodeFeatures_set_zero_conf_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
32863 export function NodeFeatures_set_zero_conf_optional(this_arg: bigint): void {
32864 if(!isWasmInitialized) {
32865 throw new Error("initializeWasm() must be awaited first!");
32867 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_optional(this_arg);
32868 // debug statements here
32870 // void NodeFeatures_set_zero_conf_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
32872 export function NodeFeatures_set_zero_conf_required(this_arg: bigint): void {
32873 if(!isWasmInitialized) {
32874 throw new Error("initializeWasm() must be awaited first!");
32876 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_required(this_arg);
32877 // debug statements here
32879 // MUST_USE_RES bool NodeFeatures_supports_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
32881 export function NodeFeatures_supports_zero_conf(this_arg: bigint): boolean {
32882 if(!isWasmInitialized) {
32883 throw new Error("initializeWasm() must be awaited first!");
32885 const nativeResponseValue = wasm.TS_NodeFeatures_supports_zero_conf(this_arg);
32886 return nativeResponseValue;
32888 // void ChannelTypeFeatures_set_zero_conf_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
32890 export function ChannelTypeFeatures_set_zero_conf_optional(this_arg: bigint): void {
32891 if(!isWasmInitialized) {
32892 throw new Error("initializeWasm() must be awaited first!");
32894 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_optional(this_arg);
32895 // debug statements here
32897 // void ChannelTypeFeatures_set_zero_conf_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
32899 export function ChannelTypeFeatures_set_zero_conf_required(this_arg: bigint): void {
32900 if(!isWasmInitialized) {
32901 throw new Error("initializeWasm() must be awaited first!");
32903 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_required(this_arg);
32904 // debug statements here
32906 // MUST_USE_RES bool ChannelTypeFeatures_supports_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
32908 export function ChannelTypeFeatures_supports_zero_conf(this_arg: bigint): boolean {
32909 if(!isWasmInitialized) {
32910 throw new Error("initializeWasm() must be awaited first!");
32912 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_zero_conf(this_arg);
32913 return nativeResponseValue;
32915 // MUST_USE_RES bool InitFeatures_requires_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
32917 export function InitFeatures_requires_zero_conf(this_arg: bigint): boolean {
32918 if(!isWasmInitialized) {
32919 throw new Error("initializeWasm() must be awaited first!");
32921 const nativeResponseValue = wasm.TS_InitFeatures_requires_zero_conf(this_arg);
32922 return nativeResponseValue;
32924 // MUST_USE_RES bool NodeFeatures_requires_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
32926 export function NodeFeatures_requires_zero_conf(this_arg: bigint): boolean {
32927 if(!isWasmInitialized) {
32928 throw new Error("initializeWasm() must be awaited first!");
32930 const nativeResponseValue = wasm.TS_NodeFeatures_requires_zero_conf(this_arg);
32931 return nativeResponseValue;
32933 // MUST_USE_RES bool ChannelTypeFeatures_requires_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
32935 export function ChannelTypeFeatures_requires_zero_conf(this_arg: bigint): boolean {
32936 if(!isWasmInitialized) {
32937 throw new Error("initializeWasm() must be awaited first!");
32939 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_zero_conf(this_arg);
32940 return nativeResponseValue;
32942 // void NodeFeatures_set_keysend_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
32944 export function NodeFeatures_set_keysend_optional(this_arg: bigint): void {
32945 if(!isWasmInitialized) {
32946 throw new Error("initializeWasm() must be awaited first!");
32948 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_optional(this_arg);
32949 // debug statements here
32951 // void NodeFeatures_set_keysend_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
32953 export function NodeFeatures_set_keysend_required(this_arg: bigint): void {
32954 if(!isWasmInitialized) {
32955 throw new Error("initializeWasm() must be awaited first!");
32957 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_required(this_arg);
32958 // debug statements here
32960 // MUST_USE_RES bool NodeFeatures_supports_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
32962 export function NodeFeatures_supports_keysend(this_arg: bigint): boolean {
32963 if(!isWasmInitialized) {
32964 throw new Error("initializeWasm() must be awaited first!");
32966 const nativeResponseValue = wasm.TS_NodeFeatures_supports_keysend(this_arg);
32967 return nativeResponseValue;
32969 // MUST_USE_RES bool NodeFeatures_requires_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
32971 export function NodeFeatures_requires_keysend(this_arg: bigint): boolean {
32972 if(!isWasmInitialized) {
32973 throw new Error("initializeWasm() must be awaited first!");
32975 const nativeResponseValue = wasm.TS_NodeFeatures_requires_keysend(this_arg);
32976 return nativeResponseValue;
32978 // void ShutdownScript_free(struct LDKShutdownScript this_obj);
32980 export function ShutdownScript_free(this_obj: bigint): void {
32981 if(!isWasmInitialized) {
32982 throw new Error("initializeWasm() must be awaited first!");
32984 const nativeResponseValue = wasm.TS_ShutdownScript_free(this_obj);
32985 // debug statements here
32987 // uint64_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg);
32989 export function ShutdownScript_clone_ptr(arg: bigint): bigint {
32990 if(!isWasmInitialized) {
32991 throw new Error("initializeWasm() must be awaited first!");
32993 const nativeResponseValue = wasm.TS_ShutdownScript_clone_ptr(arg);
32994 return nativeResponseValue;
32996 // struct LDKShutdownScript ShutdownScript_clone(const struct LDKShutdownScript *NONNULL_PTR orig);
32998 export function ShutdownScript_clone(orig: bigint): bigint {
32999 if(!isWasmInitialized) {
33000 throw new Error("initializeWasm() must be awaited first!");
33002 const nativeResponseValue = wasm.TS_ShutdownScript_clone(orig);
33003 return nativeResponseValue;
33005 // bool ShutdownScript_eq(const struct LDKShutdownScript *NONNULL_PTR a, const struct LDKShutdownScript *NONNULL_PTR b);
33007 export function ShutdownScript_eq(a: bigint, b: bigint): boolean {
33008 if(!isWasmInitialized) {
33009 throw new Error("initializeWasm() must be awaited first!");
33011 const nativeResponseValue = wasm.TS_ShutdownScript_eq(a, b);
33012 return nativeResponseValue;
33014 // void InvalidShutdownScript_free(struct LDKInvalidShutdownScript this_obj);
33016 export function InvalidShutdownScript_free(this_obj: bigint): void {
33017 if(!isWasmInitialized) {
33018 throw new Error("initializeWasm() must be awaited first!");
33020 const nativeResponseValue = wasm.TS_InvalidShutdownScript_free(this_obj);
33021 // debug statements here
33023 // struct LDKu8slice InvalidShutdownScript_get_script(const struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr);
33025 export function InvalidShutdownScript_get_script(this_ptr: bigint): number {
33026 if(!isWasmInitialized) {
33027 throw new Error("initializeWasm() must be awaited first!");
33029 const nativeResponseValue = wasm.TS_InvalidShutdownScript_get_script(this_ptr);
33030 return nativeResponseValue;
33032 // void InvalidShutdownScript_set_script(struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
33034 export function InvalidShutdownScript_set_script(this_ptr: bigint, val: number): void {
33035 if(!isWasmInitialized) {
33036 throw new Error("initializeWasm() must be awaited first!");
33038 const nativeResponseValue = wasm.TS_InvalidShutdownScript_set_script(this_ptr, val);
33039 // debug statements here
33041 // MUST_USE_RES struct LDKInvalidShutdownScript InvalidShutdownScript_new(struct LDKCVec_u8Z script_arg);
33043 export function InvalidShutdownScript_new(script_arg: number): bigint {
33044 if(!isWasmInitialized) {
33045 throw new Error("initializeWasm() must be awaited first!");
33047 const nativeResponseValue = wasm.TS_InvalidShutdownScript_new(script_arg);
33048 return nativeResponseValue;
33050 // uint64_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg);
33052 export function InvalidShutdownScript_clone_ptr(arg: bigint): bigint {
33053 if(!isWasmInitialized) {
33054 throw new Error("initializeWasm() must be awaited first!");
33056 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone_ptr(arg);
33057 return nativeResponseValue;
33059 // struct LDKInvalidShutdownScript InvalidShutdownScript_clone(const struct LDKInvalidShutdownScript *NONNULL_PTR orig);
33061 export function InvalidShutdownScript_clone(orig: bigint): bigint {
33062 if(!isWasmInitialized) {
33063 throw new Error("initializeWasm() must be awaited first!");
33065 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone(orig);
33066 return nativeResponseValue;
33068 // struct LDKCVec_u8Z ShutdownScript_write(const struct LDKShutdownScript *NONNULL_PTR obj);
33070 export function ShutdownScript_write(obj: bigint): number {
33071 if(!isWasmInitialized) {
33072 throw new Error("initializeWasm() must be awaited first!");
33074 const nativeResponseValue = wasm.TS_ShutdownScript_write(obj);
33075 return nativeResponseValue;
33077 // struct LDKCResult_ShutdownScriptDecodeErrorZ ShutdownScript_read(struct LDKu8slice ser);
33079 export function ShutdownScript_read(ser: number): bigint {
33080 if(!isWasmInitialized) {
33081 throw new Error("initializeWasm() must be awaited first!");
33083 const nativeResponseValue = wasm.TS_ShutdownScript_read(ser);
33084 return nativeResponseValue;
33086 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wpkh(const uint8_t (*pubkey_hash)[20]);
33088 export function ShutdownScript_new_p2wpkh(pubkey_hash: number): bigint {
33089 if(!isWasmInitialized) {
33090 throw new Error("initializeWasm() must be awaited first!");
33092 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wpkh(pubkey_hash);
33093 return nativeResponseValue;
33095 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wsh(const uint8_t (*script_hash)[32]);
33097 export function ShutdownScript_new_p2wsh(script_hash: number): bigint {
33098 if(!isWasmInitialized) {
33099 throw new Error("initializeWasm() must be awaited first!");
33101 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wsh(script_hash);
33102 return nativeResponseValue;
33104 // MUST_USE_RES struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ ShutdownScript_new_witness_program(struct LDKWitnessVersion version, struct LDKu8slice program);
33106 export function ShutdownScript_new_witness_program(version: number, program: number): bigint {
33107 if(!isWasmInitialized) {
33108 throw new Error("initializeWasm() must be awaited first!");
33110 const nativeResponseValue = wasm.TS_ShutdownScript_new_witness_program(version, program);
33111 return nativeResponseValue;
33113 // MUST_USE_RES struct LDKCVec_u8Z ShutdownScript_into_inner(struct LDKShutdownScript this_arg);
33115 export function ShutdownScript_into_inner(this_arg: bigint): number {
33116 if(!isWasmInitialized) {
33117 throw new Error("initializeWasm() must be awaited first!");
33119 const nativeResponseValue = wasm.TS_ShutdownScript_into_inner(this_arg);
33120 return nativeResponseValue;
33122 // MUST_USE_RES struct LDKPublicKey ShutdownScript_as_legacy_pubkey(const struct LDKShutdownScript *NONNULL_PTR this_arg);
33124 export function ShutdownScript_as_legacy_pubkey(this_arg: bigint): number {
33125 if(!isWasmInitialized) {
33126 throw new Error("initializeWasm() must be awaited first!");
33128 const nativeResponseValue = wasm.TS_ShutdownScript_as_legacy_pubkey(this_arg);
33129 return nativeResponseValue;
33131 // MUST_USE_RES bool ShutdownScript_is_compatible(const struct LDKShutdownScript *NONNULL_PTR this_arg, const struct LDKInitFeatures *NONNULL_PTR features);
33133 export function ShutdownScript_is_compatible(this_arg: bigint, features: bigint): boolean {
33134 if(!isWasmInitialized) {
33135 throw new Error("initializeWasm() must be awaited first!");
33137 const nativeResponseValue = wasm.TS_ShutdownScript_is_compatible(this_arg, features);
33138 return nativeResponseValue;
33140 // void Retry_free(struct LDKRetry this_ptr);
33142 export function Retry_free(this_ptr: bigint): void {
33143 if(!isWasmInitialized) {
33144 throw new Error("initializeWasm() must be awaited first!");
33146 const nativeResponseValue = wasm.TS_Retry_free(this_ptr);
33147 // debug statements here
33149 // uint64_t Retry_clone_ptr(LDKRetry *NONNULL_PTR arg);
33151 export function Retry_clone_ptr(arg: bigint): bigint {
33152 if(!isWasmInitialized) {
33153 throw new Error("initializeWasm() must be awaited first!");
33155 const nativeResponseValue = wasm.TS_Retry_clone_ptr(arg);
33156 return nativeResponseValue;
33158 // struct LDKRetry Retry_clone(const struct LDKRetry *NONNULL_PTR orig);
33160 export function Retry_clone(orig: bigint): bigint {
33161 if(!isWasmInitialized) {
33162 throw new Error("initializeWasm() must be awaited first!");
33164 const nativeResponseValue = wasm.TS_Retry_clone(orig);
33165 return nativeResponseValue;
33167 // struct LDKRetry Retry_attempts(uintptr_t a);
33169 export function Retry_attempts(a: number): bigint {
33170 if(!isWasmInitialized) {
33171 throw new Error("initializeWasm() must be awaited first!");
33173 const nativeResponseValue = wasm.TS_Retry_attempts(a);
33174 return nativeResponseValue;
33176 // bool Retry_eq(const struct LDKRetry *NONNULL_PTR a, const struct LDKRetry *NONNULL_PTR b);
33178 export function Retry_eq(a: bigint, b: bigint): boolean {
33179 if(!isWasmInitialized) {
33180 throw new Error("initializeWasm() must be awaited first!");
33182 const nativeResponseValue = wasm.TS_Retry_eq(a, b);
33183 return nativeResponseValue;
33185 // uint64_t Retry_hash(const struct LDKRetry *NONNULL_PTR o);
33187 export function Retry_hash(o: bigint): bigint {
33188 if(!isWasmInitialized) {
33189 throw new Error("initializeWasm() must be awaited first!");
33191 const nativeResponseValue = wasm.TS_Retry_hash(o);
33192 return nativeResponseValue;
33194 // enum LDKRetryableSendFailure RetryableSendFailure_clone(const enum LDKRetryableSendFailure *NONNULL_PTR orig);
33196 export function RetryableSendFailure_clone(orig: bigint): RetryableSendFailure {
33197 if(!isWasmInitialized) {
33198 throw new Error("initializeWasm() must be awaited first!");
33200 const nativeResponseValue = wasm.TS_RetryableSendFailure_clone(orig);
33201 return nativeResponseValue;
33203 // enum LDKRetryableSendFailure RetryableSendFailure_payment_expired(void);
33205 export function RetryableSendFailure_payment_expired(): RetryableSendFailure {
33206 if(!isWasmInitialized) {
33207 throw new Error("initializeWasm() must be awaited first!");
33209 const nativeResponseValue = wasm.TS_RetryableSendFailure_payment_expired();
33210 return nativeResponseValue;
33212 // enum LDKRetryableSendFailure RetryableSendFailure_route_not_found(void);
33214 export function RetryableSendFailure_route_not_found(): RetryableSendFailure {
33215 if(!isWasmInitialized) {
33216 throw new Error("initializeWasm() must be awaited first!");
33218 const nativeResponseValue = wasm.TS_RetryableSendFailure_route_not_found();
33219 return nativeResponseValue;
33221 // enum LDKRetryableSendFailure RetryableSendFailure_duplicate_payment(void);
33223 export function RetryableSendFailure_duplicate_payment(): RetryableSendFailure {
33224 if(!isWasmInitialized) {
33225 throw new Error("initializeWasm() must be awaited first!");
33227 const nativeResponseValue = wasm.TS_RetryableSendFailure_duplicate_payment();
33228 return nativeResponseValue;
33230 // void PaymentSendFailure_free(struct LDKPaymentSendFailure this_ptr);
33232 export function PaymentSendFailure_free(this_ptr: bigint): void {
33233 if(!isWasmInitialized) {
33234 throw new Error("initializeWasm() must be awaited first!");
33236 const nativeResponseValue = wasm.TS_PaymentSendFailure_free(this_ptr);
33237 // debug statements here
33239 // uint64_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg);
33241 export function PaymentSendFailure_clone_ptr(arg: bigint): bigint {
33242 if(!isWasmInitialized) {
33243 throw new Error("initializeWasm() must be awaited first!");
33245 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone_ptr(arg);
33246 return nativeResponseValue;
33248 // struct LDKPaymentSendFailure PaymentSendFailure_clone(const struct LDKPaymentSendFailure *NONNULL_PTR orig);
33250 export function PaymentSendFailure_clone(orig: bigint): bigint {
33251 if(!isWasmInitialized) {
33252 throw new Error("initializeWasm() must be awaited first!");
33254 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone(orig);
33255 return nativeResponseValue;
33257 // struct LDKPaymentSendFailure PaymentSendFailure_parameter_error(struct LDKAPIError a);
33259 export function PaymentSendFailure_parameter_error(a: bigint): bigint {
33260 if(!isWasmInitialized) {
33261 throw new Error("initializeWasm() must be awaited first!");
33263 const nativeResponseValue = wasm.TS_PaymentSendFailure_parameter_error(a);
33264 return nativeResponseValue;
33266 // struct LDKPaymentSendFailure PaymentSendFailure_path_parameter_error(struct LDKCVec_CResult_NoneAPIErrorZZ a);
33268 export function PaymentSendFailure_path_parameter_error(a: number): bigint {
33269 if(!isWasmInitialized) {
33270 throw new Error("initializeWasm() must be awaited first!");
33272 const nativeResponseValue = wasm.TS_PaymentSendFailure_path_parameter_error(a);
33273 return nativeResponseValue;
33275 // struct LDKPaymentSendFailure PaymentSendFailure_all_failed_resend_safe(struct LDKCVec_APIErrorZ a);
33277 export function PaymentSendFailure_all_failed_resend_safe(a: number): bigint {
33278 if(!isWasmInitialized) {
33279 throw new Error("initializeWasm() must be awaited first!");
33281 const nativeResponseValue = wasm.TS_PaymentSendFailure_all_failed_resend_safe(a);
33282 return nativeResponseValue;
33284 // struct LDKPaymentSendFailure PaymentSendFailure_duplicate_payment(void);
33286 export function PaymentSendFailure_duplicate_payment(): bigint {
33287 if(!isWasmInitialized) {
33288 throw new Error("initializeWasm() must be awaited first!");
33290 const nativeResponseValue = wasm.TS_PaymentSendFailure_duplicate_payment();
33291 return nativeResponseValue;
33293 // struct LDKPaymentSendFailure PaymentSendFailure_partial_failure(struct LDKCVec_CResult_NoneAPIErrorZZ results, struct LDKRouteParameters failed_paths_retry, struct LDKThirtyTwoBytes payment_id);
33295 export function PaymentSendFailure_partial_failure(results: number, failed_paths_retry: bigint, payment_id: number): bigint {
33296 if(!isWasmInitialized) {
33297 throw new Error("initializeWasm() must be awaited first!");
33299 const nativeResponseValue = wasm.TS_PaymentSendFailure_partial_failure(results, failed_paths_retry, payment_id);
33300 return nativeResponseValue;
33302 // void CustomMessageReader_free(struct LDKCustomMessageReader this_ptr);
33304 export function CustomMessageReader_free(this_ptr: bigint): void {
33305 if(!isWasmInitialized) {
33306 throw new Error("initializeWasm() must be awaited first!");
33308 const nativeResponseValue = wasm.TS_CustomMessageReader_free(this_ptr);
33309 // debug statements here
33311 // uint64_t Type_clone_ptr(LDKType *NONNULL_PTR arg);
33313 export function Type_clone_ptr(arg: bigint): bigint {
33314 if(!isWasmInitialized) {
33315 throw new Error("initializeWasm() must be awaited first!");
33317 const nativeResponseValue = wasm.TS_Type_clone_ptr(arg);
33318 return nativeResponseValue;
33320 // struct LDKType Type_clone(const struct LDKType *NONNULL_PTR orig);
33322 export function Type_clone(orig: bigint): bigint {
33323 if(!isWasmInitialized) {
33324 throw new Error("initializeWasm() must be awaited first!");
33326 const nativeResponseValue = wasm.TS_Type_clone(orig);
33327 return nativeResponseValue;
33329 // void Type_free(struct LDKType this_ptr);
33331 export function Type_free(this_ptr: bigint): void {
33332 if(!isWasmInitialized) {
33333 throw new Error("initializeWasm() must be awaited first!");
33335 const nativeResponseValue = wasm.TS_Type_free(this_ptr);
33336 // debug statements here
33338 // enum LDKUtxoLookupError UtxoLookupError_clone(const enum LDKUtxoLookupError *NONNULL_PTR orig);
33340 export function UtxoLookupError_clone(orig: bigint): UtxoLookupError {
33341 if(!isWasmInitialized) {
33342 throw new Error("initializeWasm() must be awaited first!");
33344 const nativeResponseValue = wasm.TS_UtxoLookupError_clone(orig);
33345 return nativeResponseValue;
33347 // enum LDKUtxoLookupError UtxoLookupError_unknown_chain(void);
33349 export function UtxoLookupError_unknown_chain(): UtxoLookupError {
33350 if(!isWasmInitialized) {
33351 throw new Error("initializeWasm() must be awaited first!");
33353 const nativeResponseValue = wasm.TS_UtxoLookupError_unknown_chain();
33354 return nativeResponseValue;
33356 // enum LDKUtxoLookupError UtxoLookupError_unknown_tx(void);
33358 export function UtxoLookupError_unknown_tx(): UtxoLookupError {
33359 if(!isWasmInitialized) {
33360 throw new Error("initializeWasm() must be awaited first!");
33362 const nativeResponseValue = wasm.TS_UtxoLookupError_unknown_tx();
33363 return nativeResponseValue;
33365 // void UtxoResult_free(struct LDKUtxoResult this_ptr);
33367 export function UtxoResult_free(this_ptr: bigint): void {
33368 if(!isWasmInitialized) {
33369 throw new Error("initializeWasm() must be awaited first!");
33371 const nativeResponseValue = wasm.TS_UtxoResult_free(this_ptr);
33372 // debug statements here
33374 // uint64_t UtxoResult_clone_ptr(LDKUtxoResult *NONNULL_PTR arg);
33376 export function UtxoResult_clone_ptr(arg: bigint): bigint {
33377 if(!isWasmInitialized) {
33378 throw new Error("initializeWasm() must be awaited first!");
33380 const nativeResponseValue = wasm.TS_UtxoResult_clone_ptr(arg);
33381 return nativeResponseValue;
33383 // struct LDKUtxoResult UtxoResult_clone(const struct LDKUtxoResult *NONNULL_PTR orig);
33385 export function UtxoResult_clone(orig: bigint): bigint {
33386 if(!isWasmInitialized) {
33387 throw new Error("initializeWasm() must be awaited first!");
33389 const nativeResponseValue = wasm.TS_UtxoResult_clone(orig);
33390 return nativeResponseValue;
33392 // struct LDKUtxoResult UtxoResult_sync(struct LDKCResult_TxOutUtxoLookupErrorZ a);
33394 export function UtxoResult_sync(a: bigint): bigint {
33395 if(!isWasmInitialized) {
33396 throw new Error("initializeWasm() must be awaited first!");
33398 const nativeResponseValue = wasm.TS_UtxoResult_sync(a);
33399 return nativeResponseValue;
33401 // struct LDKUtxoResult UtxoResult_async(struct LDKUtxoFuture a);
33403 export function UtxoResult_async(a: bigint): bigint {
33404 if(!isWasmInitialized) {
33405 throw new Error("initializeWasm() must be awaited first!");
33407 const nativeResponseValue = wasm.TS_UtxoResult_async(a);
33408 return nativeResponseValue;
33410 // void UtxoLookup_free(struct LDKUtxoLookup this_ptr);
33412 export function UtxoLookup_free(this_ptr: bigint): void {
33413 if(!isWasmInitialized) {
33414 throw new Error("initializeWasm() must be awaited first!");
33416 const nativeResponseValue = wasm.TS_UtxoLookup_free(this_ptr);
33417 // debug statements here
33419 // void UtxoFuture_free(struct LDKUtxoFuture this_obj);
33421 export function UtxoFuture_free(this_obj: bigint): void {
33422 if(!isWasmInitialized) {
33423 throw new Error("initializeWasm() must be awaited first!");
33425 const nativeResponseValue = wasm.TS_UtxoFuture_free(this_obj);
33426 // debug statements here
33428 // uint64_t UtxoFuture_clone_ptr(LDKUtxoFuture *NONNULL_PTR arg);
33430 export function UtxoFuture_clone_ptr(arg: bigint): bigint {
33431 if(!isWasmInitialized) {
33432 throw new Error("initializeWasm() must be awaited first!");
33434 const nativeResponseValue = wasm.TS_UtxoFuture_clone_ptr(arg);
33435 return nativeResponseValue;
33437 // struct LDKUtxoFuture UtxoFuture_clone(const struct LDKUtxoFuture *NONNULL_PTR orig);
33439 export function UtxoFuture_clone(orig: bigint): bigint {
33440 if(!isWasmInitialized) {
33441 throw new Error("initializeWasm() must be awaited first!");
33443 const nativeResponseValue = wasm.TS_UtxoFuture_clone(orig);
33444 return nativeResponseValue;
33446 // MUST_USE_RES struct LDKUtxoFuture UtxoFuture_new(void);
33448 export function UtxoFuture_new(): bigint {
33449 if(!isWasmInitialized) {
33450 throw new Error("initializeWasm() must be awaited first!");
33452 const nativeResponseValue = wasm.TS_UtxoFuture_new();
33453 return nativeResponseValue;
33455 // void UtxoFuture_resolve_without_forwarding(const struct LDKUtxoFuture *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR graph, struct LDKCResult_TxOutUtxoLookupErrorZ result);
33457 export function UtxoFuture_resolve_without_forwarding(this_arg: bigint, graph: bigint, result: bigint): void {
33458 if(!isWasmInitialized) {
33459 throw new Error("initializeWasm() must be awaited first!");
33461 const nativeResponseValue = wasm.TS_UtxoFuture_resolve_without_forwarding(this_arg, graph, result);
33462 // debug statements here
33464 // void UtxoFuture_resolve(const struct LDKUtxoFuture *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR graph, const struct LDKP2PGossipSync *NONNULL_PTR gossip, struct LDKCResult_TxOutUtxoLookupErrorZ result);
33466 export function UtxoFuture_resolve(this_arg: bigint, graph: bigint, gossip: bigint, result: bigint): void {
33467 if(!isWasmInitialized) {
33468 throw new Error("initializeWasm() must be awaited first!");
33470 const nativeResponseValue = wasm.TS_UtxoFuture_resolve(this_arg, graph, gossip, result);
33471 // debug statements here
33473 // void NodeId_free(struct LDKNodeId this_obj);
33475 export function NodeId_free(this_obj: bigint): void {
33476 if(!isWasmInitialized) {
33477 throw new Error("initializeWasm() must be awaited first!");
33479 const nativeResponseValue = wasm.TS_NodeId_free(this_obj);
33480 // debug statements here
33482 // uint64_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg);
33484 export function NodeId_clone_ptr(arg: bigint): bigint {
33485 if(!isWasmInitialized) {
33486 throw new Error("initializeWasm() must be awaited first!");
33488 const nativeResponseValue = wasm.TS_NodeId_clone_ptr(arg);
33489 return nativeResponseValue;
33491 // struct LDKNodeId NodeId_clone(const struct LDKNodeId *NONNULL_PTR orig);
33493 export function NodeId_clone(orig: bigint): bigint {
33494 if(!isWasmInitialized) {
33495 throw new Error("initializeWasm() must be awaited first!");
33497 const nativeResponseValue = wasm.TS_NodeId_clone(orig);
33498 return nativeResponseValue;
33500 // MUST_USE_RES struct LDKNodeId NodeId_from_pubkey(struct LDKPublicKey pubkey);
33502 export function NodeId_from_pubkey(pubkey: number): bigint {
33503 if(!isWasmInitialized) {
33504 throw new Error("initializeWasm() must be awaited first!");
33506 const nativeResponseValue = wasm.TS_NodeId_from_pubkey(pubkey);
33507 return nativeResponseValue;
33509 // MUST_USE_RES struct LDKu8slice NodeId_as_slice(const struct LDKNodeId *NONNULL_PTR this_arg);
33511 export function NodeId_as_slice(this_arg: bigint): number {
33512 if(!isWasmInitialized) {
33513 throw new Error("initializeWasm() must be awaited first!");
33515 const nativeResponseValue = wasm.TS_NodeId_as_slice(this_arg);
33516 return nativeResponseValue;
33518 // uint64_t NodeId_hash(const struct LDKNodeId *NONNULL_PTR o);
33520 export function NodeId_hash(o: bigint): bigint {
33521 if(!isWasmInitialized) {
33522 throw new Error("initializeWasm() must be awaited first!");
33524 const nativeResponseValue = wasm.TS_NodeId_hash(o);
33525 return nativeResponseValue;
33527 // struct LDKCVec_u8Z NodeId_write(const struct LDKNodeId *NONNULL_PTR obj);
33529 export function NodeId_write(obj: bigint): number {
33530 if(!isWasmInitialized) {
33531 throw new Error("initializeWasm() must be awaited first!");
33533 const nativeResponseValue = wasm.TS_NodeId_write(obj);
33534 return nativeResponseValue;
33536 // struct LDKCResult_NodeIdDecodeErrorZ NodeId_read(struct LDKu8slice ser);
33538 export function NodeId_read(ser: number): bigint {
33539 if(!isWasmInitialized) {
33540 throw new Error("initializeWasm() must be awaited first!");
33542 const nativeResponseValue = wasm.TS_NodeId_read(ser);
33543 return nativeResponseValue;
33545 // void NetworkGraph_free(struct LDKNetworkGraph this_obj);
33547 export function NetworkGraph_free(this_obj: bigint): void {
33548 if(!isWasmInitialized) {
33549 throw new Error("initializeWasm() must be awaited first!");
33551 const nativeResponseValue = wasm.TS_NetworkGraph_free(this_obj);
33552 // debug statements here
33554 // void ReadOnlyNetworkGraph_free(struct LDKReadOnlyNetworkGraph this_obj);
33556 export function ReadOnlyNetworkGraph_free(this_obj: bigint): void {
33557 if(!isWasmInitialized) {
33558 throw new Error("initializeWasm() must be awaited first!");
33560 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_free(this_obj);
33561 // debug statements here
33563 // void NetworkUpdate_free(struct LDKNetworkUpdate this_ptr);
33565 export function NetworkUpdate_free(this_ptr: bigint): void {
33566 if(!isWasmInitialized) {
33567 throw new Error("initializeWasm() must be awaited first!");
33569 const nativeResponseValue = wasm.TS_NetworkUpdate_free(this_ptr);
33570 // debug statements here
33572 // uint64_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg);
33574 export function NetworkUpdate_clone_ptr(arg: bigint): bigint {
33575 if(!isWasmInitialized) {
33576 throw new Error("initializeWasm() must be awaited first!");
33578 const nativeResponseValue = wasm.TS_NetworkUpdate_clone_ptr(arg);
33579 return nativeResponseValue;
33581 // struct LDKNetworkUpdate NetworkUpdate_clone(const struct LDKNetworkUpdate *NONNULL_PTR orig);
33583 export function NetworkUpdate_clone(orig: bigint): bigint {
33584 if(!isWasmInitialized) {
33585 throw new Error("initializeWasm() must be awaited first!");
33587 const nativeResponseValue = wasm.TS_NetworkUpdate_clone(orig);
33588 return nativeResponseValue;
33590 // struct LDKNetworkUpdate NetworkUpdate_channel_update_message(struct LDKChannelUpdate msg);
33592 export function NetworkUpdate_channel_update_message(msg: bigint): bigint {
33593 if(!isWasmInitialized) {
33594 throw new Error("initializeWasm() must be awaited first!");
33596 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_update_message(msg);
33597 return nativeResponseValue;
33599 // struct LDKNetworkUpdate NetworkUpdate_channel_failure(uint64_t short_channel_id, bool is_permanent);
33601 export function NetworkUpdate_channel_failure(short_channel_id: bigint, is_permanent: boolean): bigint {
33602 if(!isWasmInitialized) {
33603 throw new Error("initializeWasm() must be awaited first!");
33605 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_failure(short_channel_id, is_permanent);
33606 return nativeResponseValue;
33608 // struct LDKNetworkUpdate NetworkUpdate_node_failure(struct LDKPublicKey node_id, bool is_permanent);
33610 export function NetworkUpdate_node_failure(node_id: number, is_permanent: boolean): bigint {
33611 if(!isWasmInitialized) {
33612 throw new Error("initializeWasm() must be awaited first!");
33614 const nativeResponseValue = wasm.TS_NetworkUpdate_node_failure(node_id, is_permanent);
33615 return nativeResponseValue;
33617 // bool NetworkUpdate_eq(const struct LDKNetworkUpdate *NONNULL_PTR a, const struct LDKNetworkUpdate *NONNULL_PTR b);
33619 export function NetworkUpdate_eq(a: bigint, b: bigint): boolean {
33620 if(!isWasmInitialized) {
33621 throw new Error("initializeWasm() must be awaited first!");
33623 const nativeResponseValue = wasm.TS_NetworkUpdate_eq(a, b);
33624 return nativeResponseValue;
33626 // struct LDKCVec_u8Z NetworkUpdate_write(const struct LDKNetworkUpdate *NONNULL_PTR obj);
33628 export function NetworkUpdate_write(obj: bigint): number {
33629 if(!isWasmInitialized) {
33630 throw new Error("initializeWasm() must be awaited first!");
33632 const nativeResponseValue = wasm.TS_NetworkUpdate_write(obj);
33633 return nativeResponseValue;
33635 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ NetworkUpdate_read(struct LDKu8slice ser);
33637 export function NetworkUpdate_read(ser: number): bigint {
33638 if(!isWasmInitialized) {
33639 throw new Error("initializeWasm() must be awaited first!");
33641 const nativeResponseValue = wasm.TS_NetworkUpdate_read(ser);
33642 return nativeResponseValue;
33644 // void P2PGossipSync_free(struct LDKP2PGossipSync this_obj);
33646 export function P2PGossipSync_free(this_obj: bigint): void {
33647 if(!isWasmInitialized) {
33648 throw new Error("initializeWasm() must be awaited first!");
33650 const nativeResponseValue = wasm.TS_P2PGossipSync_free(this_obj);
33651 // debug statements here
33653 // MUST_USE_RES struct LDKP2PGossipSync P2PGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCOption_UtxoLookupZ utxo_lookup, struct LDKLogger logger);
33655 export function P2PGossipSync_new(network_graph: bigint, utxo_lookup: bigint, logger: bigint): bigint {
33656 if(!isWasmInitialized) {
33657 throw new Error("initializeWasm() must be awaited first!");
33659 const nativeResponseValue = wasm.TS_P2PGossipSync_new(network_graph, utxo_lookup, logger);
33660 return nativeResponseValue;
33662 // void P2PGossipSync_add_utxo_lookup(struct LDKP2PGossipSync *NONNULL_PTR this_arg, struct LDKCOption_UtxoLookupZ utxo_lookup);
33664 export function P2PGossipSync_add_utxo_lookup(this_arg: bigint, utxo_lookup: bigint): void {
33665 if(!isWasmInitialized) {
33666 throw new Error("initializeWasm() must be awaited first!");
33668 const nativeResponseValue = wasm.TS_P2PGossipSync_add_utxo_lookup(this_arg, utxo_lookup);
33669 // debug statements here
33671 // void NetworkGraph_handle_network_update(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNetworkUpdate *NONNULL_PTR network_update);
33673 export function NetworkGraph_handle_network_update(this_arg: bigint, network_update: bigint): void {
33674 if(!isWasmInitialized) {
33675 throw new Error("initializeWasm() must be awaited first!");
33677 const nativeResponseValue = wasm.TS_NetworkGraph_handle_network_update(this_arg, network_update);
33678 // debug statements here
33680 // struct LDKRoutingMessageHandler P2PGossipSync_as_RoutingMessageHandler(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
33682 export function P2PGossipSync_as_RoutingMessageHandler(this_arg: bigint): bigint {
33683 if(!isWasmInitialized) {
33684 throw new Error("initializeWasm() must be awaited first!");
33686 const nativeResponseValue = wasm.TS_P2PGossipSync_as_RoutingMessageHandler(this_arg);
33687 return nativeResponseValue;
33689 // struct LDKMessageSendEventsProvider P2PGossipSync_as_MessageSendEventsProvider(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
33691 export function P2PGossipSync_as_MessageSendEventsProvider(this_arg: bigint): bigint {
33692 if(!isWasmInitialized) {
33693 throw new Error("initializeWasm() must be awaited first!");
33695 const nativeResponseValue = wasm.TS_P2PGossipSync_as_MessageSendEventsProvider(this_arg);
33696 return nativeResponseValue;
33698 // void ChannelUpdateInfo_free(struct LDKChannelUpdateInfo this_obj);
33700 export function ChannelUpdateInfo_free(this_obj: bigint): void {
33701 if(!isWasmInitialized) {
33702 throw new Error("initializeWasm() must be awaited first!");
33704 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_free(this_obj);
33705 // debug statements here
33707 // uint32_t ChannelUpdateInfo_get_last_update(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
33709 export function ChannelUpdateInfo_get_last_update(this_ptr: bigint): number {
33710 if(!isWasmInitialized) {
33711 throw new Error("initializeWasm() must be awaited first!");
33713 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update(this_ptr);
33714 return nativeResponseValue;
33716 // void ChannelUpdateInfo_set_last_update(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint32_t val);
33718 export function ChannelUpdateInfo_set_last_update(this_ptr: bigint, val: number): void {
33719 if(!isWasmInitialized) {
33720 throw new Error("initializeWasm() must be awaited first!");
33722 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update(this_ptr, val);
33723 // debug statements here
33725 // bool ChannelUpdateInfo_get_enabled(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
33727 export function ChannelUpdateInfo_get_enabled(this_ptr: bigint): boolean {
33728 if(!isWasmInitialized) {
33729 throw new Error("initializeWasm() must be awaited first!");
33731 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_enabled(this_ptr);
33732 return nativeResponseValue;
33734 // void ChannelUpdateInfo_set_enabled(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, bool val);
33736 export function ChannelUpdateInfo_set_enabled(this_ptr: bigint, val: boolean): void {
33737 if(!isWasmInitialized) {
33738 throw new Error("initializeWasm() must be awaited first!");
33740 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_enabled(this_ptr, val);
33741 // debug statements here
33743 // uint16_t ChannelUpdateInfo_get_cltv_expiry_delta(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
33745 export function ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
33746 if(!isWasmInitialized) {
33747 throw new Error("initializeWasm() must be awaited first!");
33749 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr);
33750 return nativeResponseValue;
33752 // void ChannelUpdateInfo_set_cltv_expiry_delta(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint16_t val);
33754 export function ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
33755 if(!isWasmInitialized) {
33756 throw new Error("initializeWasm() must be awaited first!");
33758 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr, val);
33759 // debug statements here
33761 // uint64_t ChannelUpdateInfo_get_htlc_minimum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
33763 export function ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr: bigint): bigint {
33764 if(!isWasmInitialized) {
33765 throw new Error("initializeWasm() must be awaited first!");
33767 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr);
33768 return nativeResponseValue;
33770 // void ChannelUpdateInfo_set_htlc_minimum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
33772 export function ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
33773 if(!isWasmInitialized) {
33774 throw new Error("initializeWasm() must be awaited first!");
33776 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr, val);
33777 // debug statements here
33779 // uint64_t ChannelUpdateInfo_get_htlc_maximum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
33781 export function ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr: bigint): bigint {
33782 if(!isWasmInitialized) {
33783 throw new Error("initializeWasm() must be awaited first!");
33785 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr);
33786 return nativeResponseValue;
33788 // void ChannelUpdateInfo_set_htlc_maximum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
33790 export function ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
33791 if(!isWasmInitialized) {
33792 throw new Error("initializeWasm() must be awaited first!");
33794 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr, val);
33795 // debug statements here
33797 // struct LDKRoutingFees ChannelUpdateInfo_get_fees(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
33799 export function ChannelUpdateInfo_get_fees(this_ptr: bigint): bigint {
33800 if(!isWasmInitialized) {
33801 throw new Error("initializeWasm() must be awaited first!");
33803 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_fees(this_ptr);
33804 return nativeResponseValue;
33806 // void ChannelUpdateInfo_set_fees(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
33808 export function ChannelUpdateInfo_set_fees(this_ptr: bigint, val: bigint): void {
33809 if(!isWasmInitialized) {
33810 throw new Error("initializeWasm() must be awaited first!");
33812 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_fees(this_ptr, val);
33813 // debug statements here
33815 // struct LDKChannelUpdate ChannelUpdateInfo_get_last_update_message(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
33817 export function ChannelUpdateInfo_get_last_update_message(this_ptr: bigint): bigint {
33818 if(!isWasmInitialized) {
33819 throw new Error("initializeWasm() must be awaited first!");
33821 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update_message(this_ptr);
33822 return nativeResponseValue;
33824 // void ChannelUpdateInfo_set_last_update_message(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdate val);
33826 export function ChannelUpdateInfo_set_last_update_message(this_ptr: bigint, val: bigint): void {
33827 if(!isWasmInitialized) {
33828 throw new Error("initializeWasm() must be awaited first!");
33830 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update_message(this_ptr, val);
33831 // debug statements here
33833 // 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);
33835 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 {
33836 if(!isWasmInitialized) {
33837 throw new Error("initializeWasm() must be awaited first!");
33839 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);
33840 return nativeResponseValue;
33842 // uint64_t ChannelUpdateInfo_clone_ptr(LDKChannelUpdateInfo *NONNULL_PTR arg);
33844 export function ChannelUpdateInfo_clone_ptr(arg: bigint): bigint {
33845 if(!isWasmInitialized) {
33846 throw new Error("initializeWasm() must be awaited first!");
33848 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone_ptr(arg);
33849 return nativeResponseValue;
33851 // struct LDKChannelUpdateInfo ChannelUpdateInfo_clone(const struct LDKChannelUpdateInfo *NONNULL_PTR orig);
33853 export function ChannelUpdateInfo_clone(orig: bigint): bigint {
33854 if(!isWasmInitialized) {
33855 throw new Error("initializeWasm() must be awaited first!");
33857 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone(orig);
33858 return nativeResponseValue;
33860 // bool ChannelUpdateInfo_eq(const struct LDKChannelUpdateInfo *NONNULL_PTR a, const struct LDKChannelUpdateInfo *NONNULL_PTR b);
33862 export function ChannelUpdateInfo_eq(a: bigint, b: bigint): boolean {
33863 if(!isWasmInitialized) {
33864 throw new Error("initializeWasm() must be awaited first!");
33866 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_eq(a, b);
33867 return nativeResponseValue;
33869 // struct LDKCVec_u8Z ChannelUpdateInfo_write(const struct LDKChannelUpdateInfo *NONNULL_PTR obj);
33871 export function ChannelUpdateInfo_write(obj: bigint): number {
33872 if(!isWasmInitialized) {
33873 throw new Error("initializeWasm() must be awaited first!");
33875 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_write(obj);
33876 return nativeResponseValue;
33878 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ ChannelUpdateInfo_read(struct LDKu8slice ser);
33880 export function ChannelUpdateInfo_read(ser: number): bigint {
33881 if(!isWasmInitialized) {
33882 throw new Error("initializeWasm() must be awaited first!");
33884 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_read(ser);
33885 return nativeResponseValue;
33887 // void ChannelInfo_free(struct LDKChannelInfo this_obj);
33889 export function ChannelInfo_free(this_obj: bigint): void {
33890 if(!isWasmInitialized) {
33891 throw new Error("initializeWasm() must be awaited first!");
33893 const nativeResponseValue = wasm.TS_ChannelInfo_free(this_obj);
33894 // debug statements here
33896 // struct LDKChannelFeatures ChannelInfo_get_features(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
33898 export function ChannelInfo_get_features(this_ptr: bigint): bigint {
33899 if(!isWasmInitialized) {
33900 throw new Error("initializeWasm() must be awaited first!");
33902 const nativeResponseValue = wasm.TS_ChannelInfo_get_features(this_ptr);
33903 return nativeResponseValue;
33905 // void ChannelInfo_set_features(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
33907 export function ChannelInfo_set_features(this_ptr: bigint, val: bigint): void {
33908 if(!isWasmInitialized) {
33909 throw new Error("initializeWasm() must be awaited first!");
33911 const nativeResponseValue = wasm.TS_ChannelInfo_set_features(this_ptr, val);
33912 // debug statements here
33914 // struct LDKNodeId ChannelInfo_get_node_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
33916 export function ChannelInfo_get_node_one(this_ptr: bigint): bigint {
33917 if(!isWasmInitialized) {
33918 throw new Error("initializeWasm() must be awaited first!");
33920 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_one(this_ptr);
33921 return nativeResponseValue;
33923 // void ChannelInfo_set_node_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
33925 export function ChannelInfo_set_node_one(this_ptr: bigint, val: bigint): void {
33926 if(!isWasmInitialized) {
33927 throw new Error("initializeWasm() must be awaited first!");
33929 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_one(this_ptr, val);
33930 // debug statements here
33932 // struct LDKChannelUpdateInfo ChannelInfo_get_one_to_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
33934 export function ChannelInfo_get_one_to_two(this_ptr: bigint): bigint {
33935 if(!isWasmInitialized) {
33936 throw new Error("initializeWasm() must be awaited first!");
33938 const nativeResponseValue = wasm.TS_ChannelInfo_get_one_to_two(this_ptr);
33939 return nativeResponseValue;
33941 // void ChannelInfo_set_one_to_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
33943 export function ChannelInfo_set_one_to_two(this_ptr: bigint, val: bigint): void {
33944 if(!isWasmInitialized) {
33945 throw new Error("initializeWasm() must be awaited first!");
33947 const nativeResponseValue = wasm.TS_ChannelInfo_set_one_to_two(this_ptr, val);
33948 // debug statements here
33950 // struct LDKNodeId ChannelInfo_get_node_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
33952 export function ChannelInfo_get_node_two(this_ptr: bigint): bigint {
33953 if(!isWasmInitialized) {
33954 throw new Error("initializeWasm() must be awaited first!");
33956 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_two(this_ptr);
33957 return nativeResponseValue;
33959 // void ChannelInfo_set_node_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
33961 export function ChannelInfo_set_node_two(this_ptr: bigint, val: bigint): void {
33962 if(!isWasmInitialized) {
33963 throw new Error("initializeWasm() must be awaited first!");
33965 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_two(this_ptr, val);
33966 // debug statements here
33968 // struct LDKChannelUpdateInfo ChannelInfo_get_two_to_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
33970 export function ChannelInfo_get_two_to_one(this_ptr: bigint): bigint {
33971 if(!isWasmInitialized) {
33972 throw new Error("initializeWasm() must be awaited first!");
33974 const nativeResponseValue = wasm.TS_ChannelInfo_get_two_to_one(this_ptr);
33975 return nativeResponseValue;
33977 // void ChannelInfo_set_two_to_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
33979 export function ChannelInfo_set_two_to_one(this_ptr: bigint, val: bigint): void {
33980 if(!isWasmInitialized) {
33981 throw new Error("initializeWasm() must be awaited first!");
33983 const nativeResponseValue = wasm.TS_ChannelInfo_set_two_to_one(this_ptr, val);
33984 // debug statements here
33986 // struct LDKCOption_u64Z ChannelInfo_get_capacity_sats(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
33988 export function ChannelInfo_get_capacity_sats(this_ptr: bigint): bigint {
33989 if(!isWasmInitialized) {
33990 throw new Error("initializeWasm() must be awaited first!");
33992 const nativeResponseValue = wasm.TS_ChannelInfo_get_capacity_sats(this_ptr);
33993 return nativeResponseValue;
33995 // void ChannelInfo_set_capacity_sats(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
33997 export function ChannelInfo_set_capacity_sats(this_ptr: bigint, val: bigint): void {
33998 if(!isWasmInitialized) {
33999 throw new Error("initializeWasm() must be awaited first!");
34001 const nativeResponseValue = wasm.TS_ChannelInfo_set_capacity_sats(this_ptr, val);
34002 // debug statements here
34004 // struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
34006 export function ChannelInfo_get_announcement_message(this_ptr: bigint): bigint {
34007 if(!isWasmInitialized) {
34008 throw new Error("initializeWasm() must be awaited first!");
34010 const nativeResponseValue = wasm.TS_ChannelInfo_get_announcement_message(this_ptr);
34011 return nativeResponseValue;
34013 // void ChannelInfo_set_announcement_message(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelAnnouncement val);
34015 export function ChannelInfo_set_announcement_message(this_ptr: bigint, val: bigint): void {
34016 if(!isWasmInitialized) {
34017 throw new Error("initializeWasm() must be awaited first!");
34019 const nativeResponseValue = wasm.TS_ChannelInfo_set_announcement_message(this_ptr, val);
34020 // debug statements here
34022 // uint64_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg);
34024 export function ChannelInfo_clone_ptr(arg: bigint): bigint {
34025 if(!isWasmInitialized) {
34026 throw new Error("initializeWasm() must be awaited first!");
34028 const nativeResponseValue = wasm.TS_ChannelInfo_clone_ptr(arg);
34029 return nativeResponseValue;
34031 // struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
34033 export function ChannelInfo_clone(orig: bigint): bigint {
34034 if(!isWasmInitialized) {
34035 throw new Error("initializeWasm() must be awaited first!");
34037 const nativeResponseValue = wasm.TS_ChannelInfo_clone(orig);
34038 return nativeResponseValue;
34040 // bool ChannelInfo_eq(const struct LDKChannelInfo *NONNULL_PTR a, const struct LDKChannelInfo *NONNULL_PTR b);
34042 export function ChannelInfo_eq(a: bigint, b: bigint): boolean {
34043 if(!isWasmInitialized) {
34044 throw new Error("initializeWasm() must be awaited first!");
34046 const nativeResponseValue = wasm.TS_ChannelInfo_eq(a, b);
34047 return nativeResponseValue;
34049 // MUST_USE_RES struct LDKChannelUpdateInfo ChannelInfo_get_directional_info(const struct LDKChannelInfo *NONNULL_PTR this_arg, uint8_t channel_flags);
34051 export function ChannelInfo_get_directional_info(this_arg: bigint, channel_flags: number): bigint {
34052 if(!isWasmInitialized) {
34053 throw new Error("initializeWasm() must be awaited first!");
34055 const nativeResponseValue = wasm.TS_ChannelInfo_get_directional_info(this_arg, channel_flags);
34056 return nativeResponseValue;
34058 // struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
34060 export function ChannelInfo_write(obj: bigint): number {
34061 if(!isWasmInitialized) {
34062 throw new Error("initializeWasm() must be awaited first!");
34064 const nativeResponseValue = wasm.TS_ChannelInfo_write(obj);
34065 return nativeResponseValue;
34067 // struct LDKCResult_ChannelInfoDecodeErrorZ ChannelInfo_read(struct LDKu8slice ser);
34069 export function ChannelInfo_read(ser: number): bigint {
34070 if(!isWasmInitialized) {
34071 throw new Error("initializeWasm() must be awaited first!");
34073 const nativeResponseValue = wasm.TS_ChannelInfo_read(ser);
34074 return nativeResponseValue;
34076 // void DirectedChannelInfo_free(struct LDKDirectedChannelInfo this_obj);
34078 export function DirectedChannelInfo_free(this_obj: bigint): void {
34079 if(!isWasmInitialized) {
34080 throw new Error("initializeWasm() must be awaited first!");
34082 const nativeResponseValue = wasm.TS_DirectedChannelInfo_free(this_obj);
34083 // debug statements here
34085 // uint64_t DirectedChannelInfo_clone_ptr(LDKDirectedChannelInfo *NONNULL_PTR arg);
34087 export function DirectedChannelInfo_clone_ptr(arg: bigint): bigint {
34088 if(!isWasmInitialized) {
34089 throw new Error("initializeWasm() must be awaited first!");
34091 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone_ptr(arg);
34092 return nativeResponseValue;
34094 // struct LDKDirectedChannelInfo DirectedChannelInfo_clone(const struct LDKDirectedChannelInfo *NONNULL_PTR orig);
34096 export function DirectedChannelInfo_clone(orig: bigint): bigint {
34097 if(!isWasmInitialized) {
34098 throw new Error("initializeWasm() must be awaited first!");
34100 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone(orig);
34101 return nativeResponseValue;
34103 // MUST_USE_RES struct LDKChannelInfo DirectedChannelInfo_channel(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
34105 export function DirectedChannelInfo_channel(this_arg: bigint): bigint {
34106 if(!isWasmInitialized) {
34107 throw new Error("initializeWasm() must be awaited first!");
34109 const nativeResponseValue = wasm.TS_DirectedChannelInfo_channel(this_arg);
34110 return nativeResponseValue;
34112 // MUST_USE_RES uint64_t DirectedChannelInfo_htlc_maximum_msat(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
34114 export function DirectedChannelInfo_htlc_maximum_msat(this_arg: bigint): bigint {
34115 if(!isWasmInitialized) {
34116 throw new Error("initializeWasm() must be awaited first!");
34118 const nativeResponseValue = wasm.TS_DirectedChannelInfo_htlc_maximum_msat(this_arg);
34119 return nativeResponseValue;
34121 // MUST_USE_RES struct LDKEffectiveCapacity DirectedChannelInfo_effective_capacity(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
34123 export function DirectedChannelInfo_effective_capacity(this_arg: bigint): bigint {
34124 if(!isWasmInitialized) {
34125 throw new Error("initializeWasm() must be awaited first!");
34127 const nativeResponseValue = wasm.TS_DirectedChannelInfo_effective_capacity(this_arg);
34128 return nativeResponseValue;
34130 // void EffectiveCapacity_free(struct LDKEffectiveCapacity this_ptr);
34132 export function EffectiveCapacity_free(this_ptr: bigint): void {
34133 if(!isWasmInitialized) {
34134 throw new Error("initializeWasm() must be awaited first!");
34136 const nativeResponseValue = wasm.TS_EffectiveCapacity_free(this_ptr);
34137 // debug statements here
34139 // uint64_t EffectiveCapacity_clone_ptr(LDKEffectiveCapacity *NONNULL_PTR arg);
34141 export function EffectiveCapacity_clone_ptr(arg: bigint): bigint {
34142 if(!isWasmInitialized) {
34143 throw new Error("initializeWasm() must be awaited first!");
34145 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone_ptr(arg);
34146 return nativeResponseValue;
34148 // struct LDKEffectiveCapacity EffectiveCapacity_clone(const struct LDKEffectiveCapacity *NONNULL_PTR orig);
34150 export function EffectiveCapacity_clone(orig: bigint): bigint {
34151 if(!isWasmInitialized) {
34152 throw new Error("initializeWasm() must be awaited first!");
34154 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone(orig);
34155 return nativeResponseValue;
34157 // struct LDKEffectiveCapacity EffectiveCapacity_exact_liquidity(uint64_t liquidity_msat);
34159 export function EffectiveCapacity_exact_liquidity(liquidity_msat: bigint): bigint {
34160 if(!isWasmInitialized) {
34161 throw new Error("initializeWasm() must be awaited first!");
34163 const nativeResponseValue = wasm.TS_EffectiveCapacity_exact_liquidity(liquidity_msat);
34164 return nativeResponseValue;
34166 // struct LDKEffectiveCapacity EffectiveCapacity_maximum_htlc(uint64_t amount_msat);
34168 export function EffectiveCapacity_maximum_htlc(amount_msat: bigint): bigint {
34169 if(!isWasmInitialized) {
34170 throw new Error("initializeWasm() must be awaited first!");
34172 const nativeResponseValue = wasm.TS_EffectiveCapacity_maximum_htlc(amount_msat);
34173 return nativeResponseValue;
34175 // struct LDKEffectiveCapacity EffectiveCapacity_total(uint64_t capacity_msat, uint64_t htlc_maximum_msat);
34177 export function EffectiveCapacity_total(capacity_msat: bigint, htlc_maximum_msat: bigint): bigint {
34178 if(!isWasmInitialized) {
34179 throw new Error("initializeWasm() must be awaited first!");
34181 const nativeResponseValue = wasm.TS_EffectiveCapacity_total(capacity_msat, htlc_maximum_msat);
34182 return nativeResponseValue;
34184 // struct LDKEffectiveCapacity EffectiveCapacity_infinite(void);
34186 export function EffectiveCapacity_infinite(): bigint {
34187 if(!isWasmInitialized) {
34188 throw new Error("initializeWasm() must be awaited first!");
34190 const nativeResponseValue = wasm.TS_EffectiveCapacity_infinite();
34191 return nativeResponseValue;
34193 // struct LDKEffectiveCapacity EffectiveCapacity_unknown(void);
34195 export function EffectiveCapacity_unknown(): bigint {
34196 if(!isWasmInitialized) {
34197 throw new Error("initializeWasm() must be awaited first!");
34199 const nativeResponseValue = wasm.TS_EffectiveCapacity_unknown();
34200 return nativeResponseValue;
34202 // MUST_USE_RES uint64_t EffectiveCapacity_as_msat(const struct LDKEffectiveCapacity *NONNULL_PTR this_arg);
34204 export function EffectiveCapacity_as_msat(this_arg: bigint): bigint {
34205 if(!isWasmInitialized) {
34206 throw new Error("initializeWasm() must be awaited first!");
34208 const nativeResponseValue = wasm.TS_EffectiveCapacity_as_msat(this_arg);
34209 return nativeResponseValue;
34211 // void RoutingFees_free(struct LDKRoutingFees this_obj);
34213 export function RoutingFees_free(this_obj: bigint): void {
34214 if(!isWasmInitialized) {
34215 throw new Error("initializeWasm() must be awaited first!");
34217 const nativeResponseValue = wasm.TS_RoutingFees_free(this_obj);
34218 // debug statements here
34220 // uint32_t RoutingFees_get_base_msat(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
34222 export function RoutingFees_get_base_msat(this_ptr: bigint): number {
34223 if(!isWasmInitialized) {
34224 throw new Error("initializeWasm() must be awaited first!");
34226 const nativeResponseValue = wasm.TS_RoutingFees_get_base_msat(this_ptr);
34227 return nativeResponseValue;
34229 // void RoutingFees_set_base_msat(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
34231 export function RoutingFees_set_base_msat(this_ptr: bigint, val: number): void {
34232 if(!isWasmInitialized) {
34233 throw new Error("initializeWasm() must be awaited first!");
34235 const nativeResponseValue = wasm.TS_RoutingFees_set_base_msat(this_ptr, val);
34236 // debug statements here
34238 // uint32_t RoutingFees_get_proportional_millionths(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
34240 export function RoutingFees_get_proportional_millionths(this_ptr: bigint): number {
34241 if(!isWasmInitialized) {
34242 throw new Error("initializeWasm() must be awaited first!");
34244 const nativeResponseValue = wasm.TS_RoutingFees_get_proportional_millionths(this_ptr);
34245 return nativeResponseValue;
34247 // void RoutingFees_set_proportional_millionths(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
34249 export function RoutingFees_set_proportional_millionths(this_ptr: bigint, val: number): void {
34250 if(!isWasmInitialized) {
34251 throw new Error("initializeWasm() must be awaited first!");
34253 const nativeResponseValue = wasm.TS_RoutingFees_set_proportional_millionths(this_ptr, val);
34254 // debug statements here
34256 // MUST_USE_RES struct LDKRoutingFees RoutingFees_new(uint32_t base_msat_arg, uint32_t proportional_millionths_arg);
34258 export function RoutingFees_new(base_msat_arg: number, proportional_millionths_arg: number): bigint {
34259 if(!isWasmInitialized) {
34260 throw new Error("initializeWasm() must be awaited first!");
34262 const nativeResponseValue = wasm.TS_RoutingFees_new(base_msat_arg, proportional_millionths_arg);
34263 return nativeResponseValue;
34265 // bool RoutingFees_eq(const struct LDKRoutingFees *NONNULL_PTR a, const struct LDKRoutingFees *NONNULL_PTR b);
34267 export function RoutingFees_eq(a: bigint, b: bigint): boolean {
34268 if(!isWasmInitialized) {
34269 throw new Error("initializeWasm() must be awaited first!");
34271 const nativeResponseValue = wasm.TS_RoutingFees_eq(a, b);
34272 return nativeResponseValue;
34274 // uint64_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg);
34276 export function RoutingFees_clone_ptr(arg: bigint): bigint {
34277 if(!isWasmInitialized) {
34278 throw new Error("initializeWasm() must be awaited first!");
34280 const nativeResponseValue = wasm.TS_RoutingFees_clone_ptr(arg);
34281 return nativeResponseValue;
34283 // struct LDKRoutingFees RoutingFees_clone(const struct LDKRoutingFees *NONNULL_PTR orig);
34285 export function RoutingFees_clone(orig: bigint): bigint {
34286 if(!isWasmInitialized) {
34287 throw new Error("initializeWasm() must be awaited first!");
34289 const nativeResponseValue = wasm.TS_RoutingFees_clone(orig);
34290 return nativeResponseValue;
34292 // uint64_t RoutingFees_hash(const struct LDKRoutingFees *NONNULL_PTR o);
34294 export function RoutingFees_hash(o: bigint): bigint {
34295 if(!isWasmInitialized) {
34296 throw new Error("initializeWasm() must be awaited first!");
34298 const nativeResponseValue = wasm.TS_RoutingFees_hash(o);
34299 return nativeResponseValue;
34301 // struct LDKCVec_u8Z RoutingFees_write(const struct LDKRoutingFees *NONNULL_PTR obj);
34303 export function RoutingFees_write(obj: bigint): number {
34304 if(!isWasmInitialized) {
34305 throw new Error("initializeWasm() must be awaited first!");
34307 const nativeResponseValue = wasm.TS_RoutingFees_write(obj);
34308 return nativeResponseValue;
34310 // struct LDKCResult_RoutingFeesDecodeErrorZ RoutingFees_read(struct LDKu8slice ser);
34312 export function RoutingFees_read(ser: number): bigint {
34313 if(!isWasmInitialized) {
34314 throw new Error("initializeWasm() must be awaited first!");
34316 const nativeResponseValue = wasm.TS_RoutingFees_read(ser);
34317 return nativeResponseValue;
34319 // void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_obj);
34321 export function NodeAnnouncementInfo_free(this_obj: bigint): void {
34322 if(!isWasmInitialized) {
34323 throw new Error("initializeWasm() must be awaited first!");
34325 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_free(this_obj);
34326 // debug statements here
34328 // struct LDKNodeFeatures NodeAnnouncementInfo_get_features(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
34330 export function NodeAnnouncementInfo_get_features(this_ptr: bigint): bigint {
34331 if(!isWasmInitialized) {
34332 throw new Error("initializeWasm() must be awaited first!");
34334 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_features(this_ptr);
34335 return nativeResponseValue;
34337 // void NodeAnnouncementInfo_set_features(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
34339 export function NodeAnnouncementInfo_set_features(this_ptr: bigint, val: bigint): void {
34340 if(!isWasmInitialized) {
34341 throw new Error("initializeWasm() must be awaited first!");
34343 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_features(this_ptr, val);
34344 // debug statements here
34346 // uint32_t NodeAnnouncementInfo_get_last_update(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
34348 export function NodeAnnouncementInfo_get_last_update(this_ptr: bigint): number {
34349 if(!isWasmInitialized) {
34350 throw new Error("initializeWasm() must be awaited first!");
34352 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_last_update(this_ptr);
34353 return nativeResponseValue;
34355 // void NodeAnnouncementInfo_set_last_update(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, uint32_t val);
34357 export function NodeAnnouncementInfo_set_last_update(this_ptr: bigint, val: number): void {
34358 if(!isWasmInitialized) {
34359 throw new Error("initializeWasm() must be awaited first!");
34361 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_last_update(this_ptr, val);
34362 // debug statements here
34364 // const uint8_t (*NodeAnnouncementInfo_get_rgb(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[3];
34366 export function NodeAnnouncementInfo_get_rgb(this_ptr: bigint): number {
34367 if(!isWasmInitialized) {
34368 throw new Error("initializeWasm() must be awaited first!");
34370 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_rgb(this_ptr);
34371 return nativeResponseValue;
34373 // void NodeAnnouncementInfo_set_rgb(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
34375 export function NodeAnnouncementInfo_set_rgb(this_ptr: bigint, val: number): void {
34376 if(!isWasmInitialized) {
34377 throw new Error("initializeWasm() must be awaited first!");
34379 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_rgb(this_ptr, val);
34380 // debug statements here
34382 // struct LDKNodeAlias NodeAnnouncementInfo_get_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
34384 export function NodeAnnouncementInfo_get_alias(this_ptr: bigint): bigint {
34385 if(!isWasmInitialized) {
34386 throw new Error("initializeWasm() must be awaited first!");
34388 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_alias(this_ptr);
34389 return nativeResponseValue;
34391 // void NodeAnnouncementInfo_set_alias(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAlias val);
34393 export function NodeAnnouncementInfo_set_alias(this_ptr: bigint, val: bigint): void {
34394 if(!isWasmInitialized) {
34395 throw new Error("initializeWasm() must be awaited first!");
34397 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_alias(this_ptr, val);
34398 // debug statements here
34400 // struct LDKCVec_NetAddressZ NodeAnnouncementInfo_get_addresses(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
34402 export function NodeAnnouncementInfo_get_addresses(this_ptr: bigint): number {
34403 if(!isWasmInitialized) {
34404 throw new Error("initializeWasm() must be awaited first!");
34406 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_addresses(this_ptr);
34407 return nativeResponseValue;
34409 // void NodeAnnouncementInfo_set_addresses(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
34411 export function NodeAnnouncementInfo_set_addresses(this_ptr: bigint, val: number): void {
34412 if(!isWasmInitialized) {
34413 throw new Error("initializeWasm() must be awaited first!");
34415 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_addresses(this_ptr, val);
34416 // debug statements here
34418 // struct LDKNodeAnnouncement NodeAnnouncementInfo_get_announcement_message(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
34420 export function NodeAnnouncementInfo_get_announcement_message(this_ptr: bigint): bigint {
34421 if(!isWasmInitialized) {
34422 throw new Error("initializeWasm() must be awaited first!");
34424 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_announcement_message(this_ptr);
34425 return nativeResponseValue;
34427 // void NodeAnnouncementInfo_set_announcement_message(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncement val);
34429 export function NodeAnnouncementInfo_set_announcement_message(this_ptr: bigint, val: bigint): void {
34430 if(!isWasmInitialized) {
34431 throw new Error("initializeWasm() must be awaited first!");
34433 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_announcement_message(this_ptr, val);
34434 // debug statements here
34436 // 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);
34438 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 {
34439 if(!isWasmInitialized) {
34440 throw new Error("initializeWasm() must be awaited first!");
34442 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_new(features_arg, last_update_arg, rgb_arg, alias_arg, addresses_arg, announcement_message_arg);
34443 return nativeResponseValue;
34445 // uint64_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg);
34447 export function NodeAnnouncementInfo_clone_ptr(arg: bigint): bigint {
34448 if(!isWasmInitialized) {
34449 throw new Error("initializeWasm() must be awaited first!");
34451 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone_ptr(arg);
34452 return nativeResponseValue;
34454 // struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
34456 export function NodeAnnouncementInfo_clone(orig: bigint): bigint {
34457 if(!isWasmInitialized) {
34458 throw new Error("initializeWasm() must be awaited first!");
34460 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone(orig);
34461 return nativeResponseValue;
34463 // bool NodeAnnouncementInfo_eq(const struct LDKNodeAnnouncementInfo *NONNULL_PTR a, const struct LDKNodeAnnouncementInfo *NONNULL_PTR b);
34465 export function NodeAnnouncementInfo_eq(a: bigint, b: bigint): boolean {
34466 if(!isWasmInitialized) {
34467 throw new Error("initializeWasm() must be awaited first!");
34469 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_eq(a, b);
34470 return nativeResponseValue;
34472 // struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementInfo *NONNULL_PTR obj);
34474 export function NodeAnnouncementInfo_write(obj: bigint): number {
34475 if(!isWasmInitialized) {
34476 throw new Error("initializeWasm() must be awaited first!");
34478 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_write(obj);
34479 return nativeResponseValue;
34481 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ NodeAnnouncementInfo_read(struct LDKu8slice ser);
34483 export function NodeAnnouncementInfo_read(ser: number): bigint {
34484 if(!isWasmInitialized) {
34485 throw new Error("initializeWasm() must be awaited first!");
34487 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_read(ser);
34488 return nativeResponseValue;
34490 // void NodeAlias_free(struct LDKNodeAlias this_obj);
34492 export function NodeAlias_free(this_obj: bigint): void {
34493 if(!isWasmInitialized) {
34494 throw new Error("initializeWasm() must be awaited first!");
34496 const nativeResponseValue = wasm.TS_NodeAlias_free(this_obj);
34497 // debug statements here
34499 // const uint8_t (*NodeAlias_get_a(const struct LDKNodeAlias *NONNULL_PTR this_ptr))[32];
34501 export function NodeAlias_get_a(this_ptr: bigint): number {
34502 if(!isWasmInitialized) {
34503 throw new Error("initializeWasm() must be awaited first!");
34505 const nativeResponseValue = wasm.TS_NodeAlias_get_a(this_ptr);
34506 return nativeResponseValue;
34508 // void NodeAlias_set_a(struct LDKNodeAlias *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
34510 export function NodeAlias_set_a(this_ptr: bigint, val: number): void {
34511 if(!isWasmInitialized) {
34512 throw new Error("initializeWasm() must be awaited first!");
34514 const nativeResponseValue = wasm.TS_NodeAlias_set_a(this_ptr, val);
34515 // debug statements here
34517 // MUST_USE_RES struct LDKNodeAlias NodeAlias_new(struct LDKThirtyTwoBytes a_arg);
34519 export function NodeAlias_new(a_arg: number): bigint {
34520 if(!isWasmInitialized) {
34521 throw new Error("initializeWasm() must be awaited first!");
34523 const nativeResponseValue = wasm.TS_NodeAlias_new(a_arg);
34524 return nativeResponseValue;
34526 // uint64_t NodeAlias_clone_ptr(LDKNodeAlias *NONNULL_PTR arg);
34528 export function NodeAlias_clone_ptr(arg: bigint): bigint {
34529 if(!isWasmInitialized) {
34530 throw new Error("initializeWasm() must be awaited first!");
34532 const nativeResponseValue = wasm.TS_NodeAlias_clone_ptr(arg);
34533 return nativeResponseValue;
34535 // struct LDKNodeAlias NodeAlias_clone(const struct LDKNodeAlias *NONNULL_PTR orig);
34537 export function NodeAlias_clone(orig: bigint): bigint {
34538 if(!isWasmInitialized) {
34539 throw new Error("initializeWasm() must be awaited first!");
34541 const nativeResponseValue = wasm.TS_NodeAlias_clone(orig);
34542 return nativeResponseValue;
34544 // bool NodeAlias_eq(const struct LDKNodeAlias *NONNULL_PTR a, const struct LDKNodeAlias *NONNULL_PTR b);
34546 export function NodeAlias_eq(a: bigint, b: bigint): boolean {
34547 if(!isWasmInitialized) {
34548 throw new Error("initializeWasm() must be awaited first!");
34550 const nativeResponseValue = wasm.TS_NodeAlias_eq(a, b);
34551 return nativeResponseValue;
34553 // struct LDKCVec_u8Z NodeAlias_write(const struct LDKNodeAlias *NONNULL_PTR obj);
34555 export function NodeAlias_write(obj: bigint): number {
34556 if(!isWasmInitialized) {
34557 throw new Error("initializeWasm() must be awaited first!");
34559 const nativeResponseValue = wasm.TS_NodeAlias_write(obj);
34560 return nativeResponseValue;
34562 // struct LDKCResult_NodeAliasDecodeErrorZ NodeAlias_read(struct LDKu8slice ser);
34564 export function NodeAlias_read(ser: number): bigint {
34565 if(!isWasmInitialized) {
34566 throw new Error("initializeWasm() must be awaited first!");
34568 const nativeResponseValue = wasm.TS_NodeAlias_read(ser);
34569 return nativeResponseValue;
34571 // void NodeInfo_free(struct LDKNodeInfo this_obj);
34573 export function NodeInfo_free(this_obj: bigint): void {
34574 if(!isWasmInitialized) {
34575 throw new Error("initializeWasm() must be awaited first!");
34577 const nativeResponseValue = wasm.TS_NodeInfo_free(this_obj);
34578 // debug statements here
34580 // struct LDKCVec_u64Z NodeInfo_get_channels(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
34582 export function NodeInfo_get_channels(this_ptr: bigint): number {
34583 if(!isWasmInitialized) {
34584 throw new Error("initializeWasm() must be awaited first!");
34586 const nativeResponseValue = wasm.TS_NodeInfo_get_channels(this_ptr);
34587 return nativeResponseValue;
34589 // void NodeInfo_set_channels(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
34591 export function NodeInfo_set_channels(this_ptr: bigint, val: number): void {
34592 if(!isWasmInitialized) {
34593 throw new Error("initializeWasm() must be awaited first!");
34595 const nativeResponseValue = wasm.TS_NodeInfo_set_channels(this_ptr, val);
34596 // debug statements here
34598 // struct LDKNodeAnnouncementInfo NodeInfo_get_announcement_info(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
34600 export function NodeInfo_get_announcement_info(this_ptr: bigint): bigint {
34601 if(!isWasmInitialized) {
34602 throw new Error("initializeWasm() must be awaited first!");
34604 const nativeResponseValue = wasm.TS_NodeInfo_get_announcement_info(this_ptr);
34605 return nativeResponseValue;
34607 // void NodeInfo_set_announcement_info(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncementInfo val);
34609 export function NodeInfo_set_announcement_info(this_ptr: bigint, val: bigint): void {
34610 if(!isWasmInitialized) {
34611 throw new Error("initializeWasm() must be awaited first!");
34613 const nativeResponseValue = wasm.TS_NodeInfo_set_announcement_info(this_ptr, val);
34614 // debug statements here
34616 // MUST_USE_RES struct LDKNodeInfo NodeInfo_new(struct LDKCVec_u64Z channels_arg, struct LDKNodeAnnouncementInfo announcement_info_arg);
34618 export function NodeInfo_new(channels_arg: number, announcement_info_arg: bigint): bigint {
34619 if(!isWasmInitialized) {
34620 throw new Error("initializeWasm() must be awaited first!");
34622 const nativeResponseValue = wasm.TS_NodeInfo_new(channels_arg, announcement_info_arg);
34623 return nativeResponseValue;
34625 // uint64_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg);
34627 export function NodeInfo_clone_ptr(arg: bigint): bigint {
34628 if(!isWasmInitialized) {
34629 throw new Error("initializeWasm() must be awaited first!");
34631 const nativeResponseValue = wasm.TS_NodeInfo_clone_ptr(arg);
34632 return nativeResponseValue;
34634 // struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
34636 export function NodeInfo_clone(orig: bigint): bigint {
34637 if(!isWasmInitialized) {
34638 throw new Error("initializeWasm() must be awaited first!");
34640 const nativeResponseValue = wasm.TS_NodeInfo_clone(orig);
34641 return nativeResponseValue;
34643 // bool NodeInfo_eq(const struct LDKNodeInfo *NONNULL_PTR a, const struct LDKNodeInfo *NONNULL_PTR b);
34645 export function NodeInfo_eq(a: bigint, b: bigint): boolean {
34646 if(!isWasmInitialized) {
34647 throw new Error("initializeWasm() must be awaited first!");
34649 const nativeResponseValue = wasm.TS_NodeInfo_eq(a, b);
34650 return nativeResponseValue;
34652 // struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
34654 export function NodeInfo_write(obj: bigint): number {
34655 if(!isWasmInitialized) {
34656 throw new Error("initializeWasm() must be awaited first!");
34658 const nativeResponseValue = wasm.TS_NodeInfo_write(obj);
34659 return nativeResponseValue;
34661 // struct LDKCResult_NodeInfoDecodeErrorZ NodeInfo_read(struct LDKu8slice ser);
34663 export function NodeInfo_read(ser: number): bigint {
34664 if(!isWasmInitialized) {
34665 throw new Error("initializeWasm() must be awaited first!");
34667 const nativeResponseValue = wasm.TS_NodeInfo_read(ser);
34668 return nativeResponseValue;
34670 // struct LDKCVec_u8Z NetworkGraph_write(const struct LDKNetworkGraph *NONNULL_PTR obj);
34672 export function NetworkGraph_write(obj: bigint): number {
34673 if(!isWasmInitialized) {
34674 throw new Error("initializeWasm() must be awaited first!");
34676 const nativeResponseValue = wasm.TS_NetworkGraph_write(obj);
34677 return nativeResponseValue;
34679 // struct LDKCResult_NetworkGraphDecodeErrorZ NetworkGraph_read(struct LDKu8slice ser, struct LDKLogger arg);
34681 export function NetworkGraph_read(ser: number, arg: bigint): bigint {
34682 if(!isWasmInitialized) {
34683 throw new Error("initializeWasm() must be awaited first!");
34685 const nativeResponseValue = wasm.TS_NetworkGraph_read(ser, arg);
34686 return nativeResponseValue;
34688 // MUST_USE_RES struct LDKNetworkGraph NetworkGraph_new(enum LDKNetwork network, struct LDKLogger logger);
34690 export function NetworkGraph_new(network: Network, logger: bigint): bigint {
34691 if(!isWasmInitialized) {
34692 throw new Error("initializeWasm() must be awaited first!");
34694 const nativeResponseValue = wasm.TS_NetworkGraph_new(network, logger);
34695 return nativeResponseValue;
34697 // MUST_USE_RES struct LDKReadOnlyNetworkGraph NetworkGraph_read_only(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
34699 export function NetworkGraph_read_only(this_arg: bigint): bigint {
34700 if(!isWasmInitialized) {
34701 throw new Error("initializeWasm() must be awaited first!");
34703 const nativeResponseValue = wasm.TS_NetworkGraph_read_only(this_arg);
34704 return nativeResponseValue;
34706 // MUST_USE_RES struct LDKCOption_u32Z NetworkGraph_get_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
34708 export function NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg: bigint): bigint {
34709 if(!isWasmInitialized) {
34710 throw new Error("initializeWasm() must be awaited first!");
34712 const nativeResponseValue = wasm.TS_NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg);
34713 return nativeResponseValue;
34715 // void NetworkGraph_set_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint32_t last_rapid_gossip_sync_timestamp);
34717 export function NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg: bigint, last_rapid_gossip_sync_timestamp: number): void {
34718 if(!isWasmInitialized) {
34719 throw new Error("initializeWasm() must be awaited first!");
34721 const nativeResponseValue = wasm.TS_NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg, last_rapid_gossip_sync_timestamp);
34722 // debug statements here
34724 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
34726 export function NetworkGraph_update_node_from_announcement(this_arg: bigint, msg: bigint): bigint {
34727 if(!isWasmInitialized) {
34728 throw new Error("initializeWasm() must be awaited first!");
34730 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_announcement(this_arg, msg);
34731 return nativeResponseValue;
34733 // 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);
34735 export function NetworkGraph_update_node_from_unsigned_announcement(this_arg: bigint, msg: bigint): bigint {
34736 if(!isWasmInitialized) {
34737 throw new Error("initializeWasm() must be awaited first!");
34739 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_unsigned_announcement(this_arg, msg);
34740 return nativeResponseValue;
34742 // 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_UtxoLookupZ utxo_lookup);
34744 export function NetworkGraph_update_channel_from_announcement(this_arg: bigint, msg: bigint, utxo_lookup: bigint): bigint {
34745 if(!isWasmInitialized) {
34746 throw new Error("initializeWasm() must be awaited first!");
34748 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement(this_arg, msg, utxo_lookup);
34749 return nativeResponseValue;
34751 // 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_UtxoLookupZ utxo_lookup);
34753 export function NetworkGraph_update_channel_from_unsigned_announcement(this_arg: bigint, msg: bigint, utxo_lookup: bigint): bigint {
34754 if(!isWasmInitialized) {
34755 throw new Error("initializeWasm() must be awaited first!");
34757 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_unsigned_announcement(this_arg, msg, utxo_lookup);
34758 return nativeResponseValue;
34760 // 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);
34762 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 {
34763 if(!isWasmInitialized) {
34764 throw new Error("initializeWasm() must be awaited first!");
34766 const nativeResponseValue = wasm.TS_NetworkGraph_add_channel_from_partial_announcement(this_arg, short_channel_id, timestamp, features, node_id_1, node_id_2);
34767 return nativeResponseValue;
34769 // void NetworkGraph_channel_failed(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id, bool is_permanent);
34771 export function NetworkGraph_channel_failed(this_arg: bigint, short_channel_id: bigint, is_permanent: boolean): void {
34772 if(!isWasmInitialized) {
34773 throw new Error("initializeWasm() must be awaited first!");
34775 const nativeResponseValue = wasm.TS_NetworkGraph_channel_failed(this_arg, short_channel_id, is_permanent);
34776 // debug statements here
34778 // void NetworkGraph_node_failed_permanent(const struct LDKNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey node_id);
34780 export function NetworkGraph_node_failed_permanent(this_arg: bigint, node_id: number): void {
34781 if(!isWasmInitialized) {
34782 throw new Error("initializeWasm() must be awaited first!");
34784 const nativeResponseValue = wasm.TS_NetworkGraph_node_failed_permanent(this_arg, node_id);
34785 // debug statements here
34787 // void NetworkGraph_remove_stale_channels_and_tracking_with_time(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t current_time_unix);
34789 export function NetworkGraph_remove_stale_channels_and_tracking_with_time(this_arg: bigint, current_time_unix: bigint): void {
34790 if(!isWasmInitialized) {
34791 throw new Error("initializeWasm() must be awaited first!");
34793 const nativeResponseValue = wasm.TS_NetworkGraph_remove_stale_channels_and_tracking_with_time(this_arg, current_time_unix);
34794 // debug statements here
34796 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
34798 export function NetworkGraph_update_channel(this_arg: bigint, msg: bigint): bigint {
34799 if(!isWasmInitialized) {
34800 throw new Error("initializeWasm() must be awaited first!");
34802 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel(this_arg, msg);
34803 return nativeResponseValue;
34805 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_unsigned(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelUpdate *NONNULL_PTR msg);
34807 export function NetworkGraph_update_channel_unsigned(this_arg: bigint, msg: bigint): bigint {
34808 if(!isWasmInitialized) {
34809 throw new Error("initializeWasm() must be awaited first!");
34811 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_unsigned(this_arg, msg);
34812 return nativeResponseValue;
34814 // MUST_USE_RES struct LDKChannelInfo ReadOnlyNetworkGraph_channel(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id);
34816 export function ReadOnlyNetworkGraph_channel(this_arg: bigint, short_channel_id: bigint): bigint {
34817 if(!isWasmInitialized) {
34818 throw new Error("initializeWasm() must be awaited first!");
34820 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_channel(this_arg, short_channel_id);
34821 return nativeResponseValue;
34823 // MUST_USE_RES struct LDKCVec_u64Z ReadOnlyNetworkGraph_list_channels(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg);
34825 export function ReadOnlyNetworkGraph_list_channels(this_arg: bigint): number {
34826 if(!isWasmInitialized) {
34827 throw new Error("initializeWasm() must be awaited first!");
34829 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_list_channels(this_arg);
34830 return nativeResponseValue;
34832 // MUST_USE_RES struct LDKNodeInfo ReadOnlyNetworkGraph_node(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
34834 export function ReadOnlyNetworkGraph_node(this_arg: bigint, node_id: bigint): bigint {
34835 if(!isWasmInitialized) {
34836 throw new Error("initializeWasm() must be awaited first!");
34838 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_node(this_arg, node_id);
34839 return nativeResponseValue;
34841 // MUST_USE_RES struct LDKCVec_NodeIdZ ReadOnlyNetworkGraph_list_nodes(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg);
34843 export function ReadOnlyNetworkGraph_list_nodes(this_arg: bigint): number {
34844 if(!isWasmInitialized) {
34845 throw new Error("initializeWasm() must be awaited first!");
34847 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_list_nodes(this_arg);
34848 return nativeResponseValue;
34850 // MUST_USE_RES struct LDKCOption_CVec_NetAddressZZ ReadOnlyNetworkGraph_get_addresses(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey pubkey);
34852 export function ReadOnlyNetworkGraph_get_addresses(this_arg: bigint, pubkey: number): bigint {
34853 if(!isWasmInitialized) {
34854 throw new Error("initializeWasm() must be awaited first!");
34856 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_get_addresses(this_arg, pubkey);
34857 return nativeResponseValue;
34859 // void DefaultRouter_free(struct LDKDefaultRouter this_obj);
34861 export function DefaultRouter_free(this_obj: bigint): void {
34862 if(!isWasmInitialized) {
34863 throw new Error("initializeWasm() must be awaited first!");
34865 const nativeResponseValue = wasm.TS_DefaultRouter_free(this_obj);
34866 // debug statements here
34868 // 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);
34870 export function DefaultRouter_new(network_graph: bigint, logger: bigint, random_seed_bytes: number, scorer: bigint): bigint {
34871 if(!isWasmInitialized) {
34872 throw new Error("initializeWasm() must be awaited first!");
34874 const nativeResponseValue = wasm.TS_DefaultRouter_new(network_graph, logger, random_seed_bytes, scorer);
34875 return nativeResponseValue;
34877 // struct LDKRouter DefaultRouter_as_Router(const struct LDKDefaultRouter *NONNULL_PTR this_arg);
34879 export function DefaultRouter_as_Router(this_arg: bigint): bigint {
34880 if(!isWasmInitialized) {
34881 throw new Error("initializeWasm() must be awaited first!");
34883 const nativeResponseValue = wasm.TS_DefaultRouter_as_Router(this_arg);
34884 return nativeResponseValue;
34886 // void Router_free(struct LDKRouter this_ptr);
34888 export function Router_free(this_ptr: bigint): void {
34889 if(!isWasmInitialized) {
34890 throw new Error("initializeWasm() must be awaited first!");
34892 const nativeResponseValue = wasm.TS_Router_free(this_ptr);
34893 // debug statements here
34895 // void ScorerAccountingForInFlightHtlcs_free(struct LDKScorerAccountingForInFlightHtlcs this_obj);
34897 export function ScorerAccountingForInFlightHtlcs_free(this_obj: bigint): void {
34898 if(!isWasmInitialized) {
34899 throw new Error("initializeWasm() must be awaited first!");
34901 const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_free(this_obj);
34902 // debug statements here
34904 // MUST_USE_RES struct LDKScorerAccountingForInFlightHtlcs ScorerAccountingForInFlightHtlcs_new(struct LDKScore scorer, const struct LDKInFlightHtlcs *NONNULL_PTR inflight_htlcs);
34906 export function ScorerAccountingForInFlightHtlcs_new(scorer: bigint, inflight_htlcs: bigint): bigint {
34907 if(!isWasmInitialized) {
34908 throw new Error("initializeWasm() must be awaited first!");
34910 const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_new(scorer, inflight_htlcs);
34911 return nativeResponseValue;
34913 // struct LDKCVec_u8Z ScorerAccountingForInFlightHtlcs_write(const struct LDKScorerAccountingForInFlightHtlcs *NONNULL_PTR obj);
34915 export function ScorerAccountingForInFlightHtlcs_write(obj: bigint): number {
34916 if(!isWasmInitialized) {
34917 throw new Error("initializeWasm() must be awaited first!");
34919 const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_write(obj);
34920 return nativeResponseValue;
34922 // struct LDKScore ScorerAccountingForInFlightHtlcs_as_Score(const struct LDKScorerAccountingForInFlightHtlcs *NONNULL_PTR this_arg);
34924 export function ScorerAccountingForInFlightHtlcs_as_Score(this_arg: bigint): bigint {
34925 if(!isWasmInitialized) {
34926 throw new Error("initializeWasm() must be awaited first!");
34928 const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_as_Score(this_arg);
34929 return nativeResponseValue;
34931 // void InFlightHtlcs_free(struct LDKInFlightHtlcs this_obj);
34933 export function InFlightHtlcs_free(this_obj: bigint): void {
34934 if(!isWasmInitialized) {
34935 throw new Error("initializeWasm() must be awaited first!");
34937 const nativeResponseValue = wasm.TS_InFlightHtlcs_free(this_obj);
34938 // debug statements here
34940 // uint64_t InFlightHtlcs_clone_ptr(LDKInFlightHtlcs *NONNULL_PTR arg);
34942 export function InFlightHtlcs_clone_ptr(arg: bigint): bigint {
34943 if(!isWasmInitialized) {
34944 throw new Error("initializeWasm() must be awaited first!");
34946 const nativeResponseValue = wasm.TS_InFlightHtlcs_clone_ptr(arg);
34947 return nativeResponseValue;
34949 // struct LDKInFlightHtlcs InFlightHtlcs_clone(const struct LDKInFlightHtlcs *NONNULL_PTR orig);
34951 export function InFlightHtlcs_clone(orig: bigint): bigint {
34952 if(!isWasmInitialized) {
34953 throw new Error("initializeWasm() must be awaited first!");
34955 const nativeResponseValue = wasm.TS_InFlightHtlcs_clone(orig);
34956 return nativeResponseValue;
34958 // MUST_USE_RES struct LDKInFlightHtlcs InFlightHtlcs_new(void);
34960 export function InFlightHtlcs_new(): bigint {
34961 if(!isWasmInitialized) {
34962 throw new Error("initializeWasm() must be awaited first!");
34964 const nativeResponseValue = wasm.TS_InFlightHtlcs_new();
34965 return nativeResponseValue;
34967 // 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);
34969 export function InFlightHtlcs_used_liquidity_msat(this_arg: bigint, source: bigint, target: bigint, channel_scid: bigint): bigint {
34970 if(!isWasmInitialized) {
34971 throw new Error("initializeWasm() must be awaited first!");
34973 const nativeResponseValue = wasm.TS_InFlightHtlcs_used_liquidity_msat(this_arg, source, target, channel_scid);
34974 return nativeResponseValue;
34976 // struct LDKCVec_u8Z InFlightHtlcs_write(const struct LDKInFlightHtlcs *NONNULL_PTR obj);
34978 export function InFlightHtlcs_write(obj: bigint): number {
34979 if(!isWasmInitialized) {
34980 throw new Error("initializeWasm() must be awaited first!");
34982 const nativeResponseValue = wasm.TS_InFlightHtlcs_write(obj);
34983 return nativeResponseValue;
34985 // struct LDKCResult_InFlightHtlcsDecodeErrorZ InFlightHtlcs_read(struct LDKu8slice ser);
34987 export function InFlightHtlcs_read(ser: number): bigint {
34988 if(!isWasmInitialized) {
34989 throw new Error("initializeWasm() must be awaited first!");
34991 const nativeResponseValue = wasm.TS_InFlightHtlcs_read(ser);
34992 return nativeResponseValue;
34994 // void RouteHop_free(struct LDKRouteHop this_obj);
34996 export function RouteHop_free(this_obj: bigint): void {
34997 if(!isWasmInitialized) {
34998 throw new Error("initializeWasm() must be awaited first!");
35000 const nativeResponseValue = wasm.TS_RouteHop_free(this_obj);
35001 // debug statements here
35003 // struct LDKPublicKey RouteHop_get_pubkey(const struct LDKRouteHop *NONNULL_PTR this_ptr);
35005 export function RouteHop_get_pubkey(this_ptr: bigint): number {
35006 if(!isWasmInitialized) {
35007 throw new Error("initializeWasm() must be awaited first!");
35009 const nativeResponseValue = wasm.TS_RouteHop_get_pubkey(this_ptr);
35010 return nativeResponseValue;
35012 // void RouteHop_set_pubkey(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
35014 export function RouteHop_set_pubkey(this_ptr: bigint, val: number): void {
35015 if(!isWasmInitialized) {
35016 throw new Error("initializeWasm() must be awaited first!");
35018 const nativeResponseValue = wasm.TS_RouteHop_set_pubkey(this_ptr, val);
35019 // debug statements here
35021 // struct LDKNodeFeatures RouteHop_get_node_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
35023 export function RouteHop_get_node_features(this_ptr: bigint): bigint {
35024 if(!isWasmInitialized) {
35025 throw new Error("initializeWasm() must be awaited first!");
35027 const nativeResponseValue = wasm.TS_RouteHop_get_node_features(this_ptr);
35028 return nativeResponseValue;
35030 // void RouteHop_set_node_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
35032 export function RouteHop_set_node_features(this_ptr: bigint, val: bigint): void {
35033 if(!isWasmInitialized) {
35034 throw new Error("initializeWasm() must be awaited first!");
35036 const nativeResponseValue = wasm.TS_RouteHop_set_node_features(this_ptr, val);
35037 // debug statements here
35039 // uint64_t RouteHop_get_short_channel_id(const struct LDKRouteHop *NONNULL_PTR this_ptr);
35041 export function RouteHop_get_short_channel_id(this_ptr: bigint): bigint {
35042 if(!isWasmInitialized) {
35043 throw new Error("initializeWasm() must be awaited first!");
35045 const nativeResponseValue = wasm.TS_RouteHop_get_short_channel_id(this_ptr);
35046 return nativeResponseValue;
35048 // void RouteHop_set_short_channel_id(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
35050 export function RouteHop_set_short_channel_id(this_ptr: bigint, val: bigint): void {
35051 if(!isWasmInitialized) {
35052 throw new Error("initializeWasm() must be awaited first!");
35054 const nativeResponseValue = wasm.TS_RouteHop_set_short_channel_id(this_ptr, val);
35055 // debug statements here
35057 // struct LDKChannelFeatures RouteHop_get_channel_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
35059 export function RouteHop_get_channel_features(this_ptr: bigint): bigint {
35060 if(!isWasmInitialized) {
35061 throw new Error("initializeWasm() must be awaited first!");
35063 const nativeResponseValue = wasm.TS_RouteHop_get_channel_features(this_ptr);
35064 return nativeResponseValue;
35066 // void RouteHop_set_channel_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
35068 export function RouteHop_set_channel_features(this_ptr: bigint, val: bigint): void {
35069 if(!isWasmInitialized) {
35070 throw new Error("initializeWasm() must be awaited first!");
35072 const nativeResponseValue = wasm.TS_RouteHop_set_channel_features(this_ptr, val);
35073 // debug statements here
35075 // uint64_t RouteHop_get_fee_msat(const struct LDKRouteHop *NONNULL_PTR this_ptr);
35077 export function RouteHop_get_fee_msat(this_ptr: bigint): bigint {
35078 if(!isWasmInitialized) {
35079 throw new Error("initializeWasm() must be awaited first!");
35081 const nativeResponseValue = wasm.TS_RouteHop_get_fee_msat(this_ptr);
35082 return nativeResponseValue;
35084 // void RouteHop_set_fee_msat(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
35086 export function RouteHop_set_fee_msat(this_ptr: bigint, val: bigint): void {
35087 if(!isWasmInitialized) {
35088 throw new Error("initializeWasm() must be awaited first!");
35090 const nativeResponseValue = wasm.TS_RouteHop_set_fee_msat(this_ptr, val);
35091 // debug statements here
35093 // uint32_t RouteHop_get_cltv_expiry_delta(const struct LDKRouteHop *NONNULL_PTR this_ptr);
35095 export function RouteHop_get_cltv_expiry_delta(this_ptr: bigint): number {
35096 if(!isWasmInitialized) {
35097 throw new Error("initializeWasm() must be awaited first!");
35099 const nativeResponseValue = wasm.TS_RouteHop_get_cltv_expiry_delta(this_ptr);
35100 return nativeResponseValue;
35102 // void RouteHop_set_cltv_expiry_delta(struct LDKRouteHop *NONNULL_PTR this_ptr, uint32_t val);
35104 export function RouteHop_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
35105 if(!isWasmInitialized) {
35106 throw new Error("initializeWasm() must be awaited first!");
35108 const nativeResponseValue = wasm.TS_RouteHop_set_cltv_expiry_delta(this_ptr, val);
35109 // debug statements here
35111 // 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);
35113 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 {
35114 if(!isWasmInitialized) {
35115 throw new Error("initializeWasm() must be awaited first!");
35117 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);
35118 return nativeResponseValue;
35120 // uint64_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg);
35122 export function RouteHop_clone_ptr(arg: bigint): bigint {
35123 if(!isWasmInitialized) {
35124 throw new Error("initializeWasm() must be awaited first!");
35126 const nativeResponseValue = wasm.TS_RouteHop_clone_ptr(arg);
35127 return nativeResponseValue;
35129 // struct LDKRouteHop RouteHop_clone(const struct LDKRouteHop *NONNULL_PTR orig);
35131 export function RouteHop_clone(orig: bigint): bigint {
35132 if(!isWasmInitialized) {
35133 throw new Error("initializeWasm() must be awaited first!");
35135 const nativeResponseValue = wasm.TS_RouteHop_clone(orig);
35136 return nativeResponseValue;
35138 // uint64_t RouteHop_hash(const struct LDKRouteHop *NONNULL_PTR o);
35140 export function RouteHop_hash(o: bigint): bigint {
35141 if(!isWasmInitialized) {
35142 throw new Error("initializeWasm() must be awaited first!");
35144 const nativeResponseValue = wasm.TS_RouteHop_hash(o);
35145 return nativeResponseValue;
35147 // bool RouteHop_eq(const struct LDKRouteHop *NONNULL_PTR a, const struct LDKRouteHop *NONNULL_PTR b);
35149 export function RouteHop_eq(a: bigint, b: bigint): boolean {
35150 if(!isWasmInitialized) {
35151 throw new Error("initializeWasm() must be awaited first!");
35153 const nativeResponseValue = wasm.TS_RouteHop_eq(a, b);
35154 return nativeResponseValue;
35156 // struct LDKCVec_u8Z RouteHop_write(const struct LDKRouteHop *NONNULL_PTR obj);
35158 export function RouteHop_write(obj: bigint): number {
35159 if(!isWasmInitialized) {
35160 throw new Error("initializeWasm() must be awaited first!");
35162 const nativeResponseValue = wasm.TS_RouteHop_write(obj);
35163 return nativeResponseValue;
35165 // struct LDKCResult_RouteHopDecodeErrorZ RouteHop_read(struct LDKu8slice ser);
35167 export function RouteHop_read(ser: number): bigint {
35168 if(!isWasmInitialized) {
35169 throw new Error("initializeWasm() must be awaited first!");
35171 const nativeResponseValue = wasm.TS_RouteHop_read(ser);
35172 return nativeResponseValue;
35174 // void Route_free(struct LDKRoute this_obj);
35176 export function Route_free(this_obj: bigint): void {
35177 if(!isWasmInitialized) {
35178 throw new Error("initializeWasm() must be awaited first!");
35180 const nativeResponseValue = wasm.TS_Route_free(this_obj);
35181 // debug statements here
35183 // struct LDKCVec_CVec_RouteHopZZ Route_get_paths(const struct LDKRoute *NONNULL_PTR this_ptr);
35185 export function Route_get_paths(this_ptr: bigint): number {
35186 if(!isWasmInitialized) {
35187 throw new Error("initializeWasm() must be awaited first!");
35189 const nativeResponseValue = wasm.TS_Route_get_paths(this_ptr);
35190 return nativeResponseValue;
35192 // void Route_set_paths(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKCVec_CVec_RouteHopZZ val);
35194 export function Route_set_paths(this_ptr: bigint, val: number): void {
35195 if(!isWasmInitialized) {
35196 throw new Error("initializeWasm() must be awaited first!");
35198 const nativeResponseValue = wasm.TS_Route_set_paths(this_ptr, val);
35199 // debug statements here
35201 // struct LDKPaymentParameters Route_get_payment_params(const struct LDKRoute *NONNULL_PTR this_ptr);
35203 export function Route_get_payment_params(this_ptr: bigint): bigint {
35204 if(!isWasmInitialized) {
35205 throw new Error("initializeWasm() must be awaited first!");
35207 const nativeResponseValue = wasm.TS_Route_get_payment_params(this_ptr);
35208 return nativeResponseValue;
35210 // void Route_set_payment_params(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
35212 export function Route_set_payment_params(this_ptr: bigint, val: bigint): void {
35213 if(!isWasmInitialized) {
35214 throw new Error("initializeWasm() must be awaited first!");
35216 const nativeResponseValue = wasm.TS_Route_set_payment_params(this_ptr, val);
35217 // debug statements here
35219 // MUST_USE_RES struct LDKRoute Route_new(struct LDKCVec_CVec_RouteHopZZ paths_arg, struct LDKPaymentParameters payment_params_arg);
35221 export function Route_new(paths_arg: number, payment_params_arg: bigint): bigint {
35222 if(!isWasmInitialized) {
35223 throw new Error("initializeWasm() must be awaited first!");
35225 const nativeResponseValue = wasm.TS_Route_new(paths_arg, payment_params_arg);
35226 return nativeResponseValue;
35228 // uint64_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg);
35230 export function Route_clone_ptr(arg: bigint): bigint {
35231 if(!isWasmInitialized) {
35232 throw new Error("initializeWasm() must be awaited first!");
35234 const nativeResponseValue = wasm.TS_Route_clone_ptr(arg);
35235 return nativeResponseValue;
35237 // struct LDKRoute Route_clone(const struct LDKRoute *NONNULL_PTR orig);
35239 export function Route_clone(orig: bigint): bigint {
35240 if(!isWasmInitialized) {
35241 throw new Error("initializeWasm() must be awaited first!");
35243 const nativeResponseValue = wasm.TS_Route_clone(orig);
35244 return nativeResponseValue;
35246 // uint64_t Route_hash(const struct LDKRoute *NONNULL_PTR o);
35248 export function Route_hash(o: bigint): bigint {
35249 if(!isWasmInitialized) {
35250 throw new Error("initializeWasm() must be awaited first!");
35252 const nativeResponseValue = wasm.TS_Route_hash(o);
35253 return nativeResponseValue;
35255 // bool Route_eq(const struct LDKRoute *NONNULL_PTR a, const struct LDKRoute *NONNULL_PTR b);
35257 export function Route_eq(a: bigint, b: bigint): boolean {
35258 if(!isWasmInitialized) {
35259 throw new Error("initializeWasm() must be awaited first!");
35261 const nativeResponseValue = wasm.TS_Route_eq(a, b);
35262 return nativeResponseValue;
35264 // MUST_USE_RES uint64_t Route_get_total_fees(const struct LDKRoute *NONNULL_PTR this_arg);
35266 export function Route_get_total_fees(this_arg: bigint): bigint {
35267 if(!isWasmInitialized) {
35268 throw new Error("initializeWasm() must be awaited first!");
35270 const nativeResponseValue = wasm.TS_Route_get_total_fees(this_arg);
35271 return nativeResponseValue;
35273 // MUST_USE_RES uint64_t Route_get_total_amount(const struct LDKRoute *NONNULL_PTR this_arg);
35275 export function Route_get_total_amount(this_arg: bigint): bigint {
35276 if(!isWasmInitialized) {
35277 throw new Error("initializeWasm() must be awaited first!");
35279 const nativeResponseValue = wasm.TS_Route_get_total_amount(this_arg);
35280 return nativeResponseValue;
35282 // struct LDKCVec_u8Z Route_write(const struct LDKRoute *NONNULL_PTR obj);
35284 export function Route_write(obj: bigint): number {
35285 if(!isWasmInitialized) {
35286 throw new Error("initializeWasm() must be awaited first!");
35288 const nativeResponseValue = wasm.TS_Route_write(obj);
35289 return nativeResponseValue;
35291 // struct LDKCResult_RouteDecodeErrorZ Route_read(struct LDKu8slice ser);
35293 export function Route_read(ser: number): bigint {
35294 if(!isWasmInitialized) {
35295 throw new Error("initializeWasm() must be awaited first!");
35297 const nativeResponseValue = wasm.TS_Route_read(ser);
35298 return nativeResponseValue;
35300 // void RouteParameters_free(struct LDKRouteParameters this_obj);
35302 export function RouteParameters_free(this_obj: bigint): void {
35303 if(!isWasmInitialized) {
35304 throw new Error("initializeWasm() must be awaited first!");
35306 const nativeResponseValue = wasm.TS_RouteParameters_free(this_obj);
35307 // debug statements here
35309 // struct LDKPaymentParameters RouteParameters_get_payment_params(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
35311 export function RouteParameters_get_payment_params(this_ptr: bigint): bigint {
35312 if(!isWasmInitialized) {
35313 throw new Error("initializeWasm() must be awaited first!");
35315 const nativeResponseValue = wasm.TS_RouteParameters_get_payment_params(this_ptr);
35316 return nativeResponseValue;
35318 // void RouteParameters_set_payment_params(struct LDKRouteParameters *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
35320 export function RouteParameters_set_payment_params(this_ptr: bigint, val: bigint): void {
35321 if(!isWasmInitialized) {
35322 throw new Error("initializeWasm() must be awaited first!");
35324 const nativeResponseValue = wasm.TS_RouteParameters_set_payment_params(this_ptr, val);
35325 // debug statements here
35327 // uint64_t RouteParameters_get_final_value_msat(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
35329 export function RouteParameters_get_final_value_msat(this_ptr: bigint): bigint {
35330 if(!isWasmInitialized) {
35331 throw new Error("initializeWasm() must be awaited first!");
35333 const nativeResponseValue = wasm.TS_RouteParameters_get_final_value_msat(this_ptr);
35334 return nativeResponseValue;
35336 // void RouteParameters_set_final_value_msat(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint64_t val);
35338 export function RouteParameters_set_final_value_msat(this_ptr: bigint, val: bigint): void {
35339 if(!isWasmInitialized) {
35340 throw new Error("initializeWasm() must be awaited first!");
35342 const nativeResponseValue = wasm.TS_RouteParameters_set_final_value_msat(this_ptr, val);
35343 // debug statements here
35345 // MUST_USE_RES struct LDKRouteParameters RouteParameters_new(struct LDKPaymentParameters payment_params_arg, uint64_t final_value_msat_arg);
35347 export function RouteParameters_new(payment_params_arg: bigint, final_value_msat_arg: bigint): bigint {
35348 if(!isWasmInitialized) {
35349 throw new Error("initializeWasm() must be awaited first!");
35351 const nativeResponseValue = wasm.TS_RouteParameters_new(payment_params_arg, final_value_msat_arg);
35352 return nativeResponseValue;
35354 // uint64_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg);
35356 export function RouteParameters_clone_ptr(arg: bigint): bigint {
35357 if(!isWasmInitialized) {
35358 throw new Error("initializeWasm() must be awaited first!");
35360 const nativeResponseValue = wasm.TS_RouteParameters_clone_ptr(arg);
35361 return nativeResponseValue;
35363 // struct LDKRouteParameters RouteParameters_clone(const struct LDKRouteParameters *NONNULL_PTR orig);
35365 export function RouteParameters_clone(orig: bigint): bigint {
35366 if(!isWasmInitialized) {
35367 throw new Error("initializeWasm() must be awaited first!");
35369 const nativeResponseValue = wasm.TS_RouteParameters_clone(orig);
35370 return nativeResponseValue;
35372 // bool RouteParameters_eq(const struct LDKRouteParameters *NONNULL_PTR a, const struct LDKRouteParameters *NONNULL_PTR b);
35374 export function RouteParameters_eq(a: bigint, b: bigint): boolean {
35375 if(!isWasmInitialized) {
35376 throw new Error("initializeWasm() must be awaited first!");
35378 const nativeResponseValue = wasm.TS_RouteParameters_eq(a, b);
35379 return nativeResponseValue;
35381 // struct LDKCVec_u8Z RouteParameters_write(const struct LDKRouteParameters *NONNULL_PTR obj);
35383 export function RouteParameters_write(obj: bigint): number {
35384 if(!isWasmInitialized) {
35385 throw new Error("initializeWasm() must be awaited first!");
35387 const nativeResponseValue = wasm.TS_RouteParameters_write(obj);
35388 return nativeResponseValue;
35390 // struct LDKCResult_RouteParametersDecodeErrorZ RouteParameters_read(struct LDKu8slice ser);
35392 export function RouteParameters_read(ser: number): bigint {
35393 if(!isWasmInitialized) {
35394 throw new Error("initializeWasm() must be awaited first!");
35396 const nativeResponseValue = wasm.TS_RouteParameters_read(ser);
35397 return nativeResponseValue;
35399 // void PaymentParameters_free(struct LDKPaymentParameters this_obj);
35401 export function PaymentParameters_free(this_obj: bigint): void {
35402 if(!isWasmInitialized) {
35403 throw new Error("initializeWasm() must be awaited first!");
35405 const nativeResponseValue = wasm.TS_PaymentParameters_free(this_obj);
35406 // debug statements here
35408 // struct LDKPublicKey PaymentParameters_get_payee_pubkey(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
35410 export function PaymentParameters_get_payee_pubkey(this_ptr: bigint): number {
35411 if(!isWasmInitialized) {
35412 throw new Error("initializeWasm() must be awaited first!");
35414 const nativeResponseValue = wasm.TS_PaymentParameters_get_payee_pubkey(this_ptr);
35415 return nativeResponseValue;
35417 // void PaymentParameters_set_payee_pubkey(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKPublicKey val);
35419 export function PaymentParameters_set_payee_pubkey(this_ptr: bigint, val: number): void {
35420 if(!isWasmInitialized) {
35421 throw new Error("initializeWasm() must be awaited first!");
35423 const nativeResponseValue = wasm.TS_PaymentParameters_set_payee_pubkey(this_ptr, val);
35424 // debug statements here
35426 // struct LDKInvoiceFeatures PaymentParameters_get_features(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
35428 export function PaymentParameters_get_features(this_ptr: bigint): bigint {
35429 if(!isWasmInitialized) {
35430 throw new Error("initializeWasm() must be awaited first!");
35432 const nativeResponseValue = wasm.TS_PaymentParameters_get_features(this_ptr);
35433 return nativeResponseValue;
35435 // void PaymentParameters_set_features(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKInvoiceFeatures val);
35437 export function PaymentParameters_set_features(this_ptr: bigint, val: bigint): void {
35438 if(!isWasmInitialized) {
35439 throw new Error("initializeWasm() must be awaited first!");
35441 const nativeResponseValue = wasm.TS_PaymentParameters_set_features(this_ptr, val);
35442 // debug statements here
35444 // struct LDKCVec_RouteHintZ PaymentParameters_get_route_hints(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
35446 export function PaymentParameters_get_route_hints(this_ptr: bigint): number {
35447 if(!isWasmInitialized) {
35448 throw new Error("initializeWasm() must be awaited first!");
35450 const nativeResponseValue = wasm.TS_PaymentParameters_get_route_hints(this_ptr);
35451 return nativeResponseValue;
35453 // void PaymentParameters_set_route_hints(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintZ val);
35455 export function PaymentParameters_set_route_hints(this_ptr: bigint, val: number): void {
35456 if(!isWasmInitialized) {
35457 throw new Error("initializeWasm() must be awaited first!");
35459 const nativeResponseValue = wasm.TS_PaymentParameters_set_route_hints(this_ptr, val);
35460 // debug statements here
35462 // struct LDKCOption_u64Z PaymentParameters_get_expiry_time(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
35464 export function PaymentParameters_get_expiry_time(this_ptr: bigint): bigint {
35465 if(!isWasmInitialized) {
35466 throw new Error("initializeWasm() must be awaited first!");
35468 const nativeResponseValue = wasm.TS_PaymentParameters_get_expiry_time(this_ptr);
35469 return nativeResponseValue;
35471 // void PaymentParameters_set_expiry_time(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
35473 export function PaymentParameters_set_expiry_time(this_ptr: bigint, val: bigint): void {
35474 if(!isWasmInitialized) {
35475 throw new Error("initializeWasm() must be awaited first!");
35477 const nativeResponseValue = wasm.TS_PaymentParameters_set_expiry_time(this_ptr, val);
35478 // debug statements here
35480 // uint32_t PaymentParameters_get_max_total_cltv_expiry_delta(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
35482 export function PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr: bigint): number {
35483 if(!isWasmInitialized) {
35484 throw new Error("initializeWasm() must be awaited first!");
35486 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr);
35487 return nativeResponseValue;
35489 // void PaymentParameters_set_max_total_cltv_expiry_delta(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint32_t val);
35491 export function PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr: bigint, val: number): void {
35492 if(!isWasmInitialized) {
35493 throw new Error("initializeWasm() must be awaited first!");
35495 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr, val);
35496 // debug statements here
35498 // uint8_t PaymentParameters_get_max_path_count(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
35500 export function PaymentParameters_get_max_path_count(this_ptr: bigint): number {
35501 if(!isWasmInitialized) {
35502 throw new Error("initializeWasm() must be awaited first!");
35504 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_path_count(this_ptr);
35505 return nativeResponseValue;
35507 // void PaymentParameters_set_max_path_count(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
35509 export function PaymentParameters_set_max_path_count(this_ptr: bigint, val: number): void {
35510 if(!isWasmInitialized) {
35511 throw new Error("initializeWasm() must be awaited first!");
35513 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_path_count(this_ptr, val);
35514 // debug statements here
35516 // uint8_t PaymentParameters_get_max_channel_saturation_power_of_half(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
35518 export function PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr: bigint): number {
35519 if(!isWasmInitialized) {
35520 throw new Error("initializeWasm() must be awaited first!");
35522 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr);
35523 return nativeResponseValue;
35525 // void PaymentParameters_set_max_channel_saturation_power_of_half(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
35527 export function PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr: bigint, val: number): void {
35528 if(!isWasmInitialized) {
35529 throw new Error("initializeWasm() must be awaited first!");
35531 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr, val);
35532 // debug statements here
35534 // struct LDKCVec_u64Z PaymentParameters_get_previously_failed_channels(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
35536 export function PaymentParameters_get_previously_failed_channels(this_ptr: bigint): number {
35537 if(!isWasmInitialized) {
35538 throw new Error("initializeWasm() must be awaited first!");
35540 const nativeResponseValue = wasm.TS_PaymentParameters_get_previously_failed_channels(this_ptr);
35541 return nativeResponseValue;
35543 // void PaymentParameters_set_previously_failed_channels(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
35545 export function PaymentParameters_set_previously_failed_channels(this_ptr: bigint, val: number): void {
35546 if(!isWasmInitialized) {
35547 throw new Error("initializeWasm() must be awaited first!");
35549 const nativeResponseValue = wasm.TS_PaymentParameters_set_previously_failed_channels(this_ptr, val);
35550 // debug statements here
35552 // uint32_t PaymentParameters_get_final_cltv_expiry_delta(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
35554 export function PaymentParameters_get_final_cltv_expiry_delta(this_ptr: bigint): number {
35555 if(!isWasmInitialized) {
35556 throw new Error("initializeWasm() must be awaited first!");
35558 const nativeResponseValue = wasm.TS_PaymentParameters_get_final_cltv_expiry_delta(this_ptr);
35559 return nativeResponseValue;
35561 // void PaymentParameters_set_final_cltv_expiry_delta(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint32_t val);
35563 export function PaymentParameters_set_final_cltv_expiry_delta(this_ptr: bigint, val: number): void {
35564 if(!isWasmInitialized) {
35565 throw new Error("initializeWasm() must be awaited first!");
35567 const nativeResponseValue = wasm.TS_PaymentParameters_set_final_cltv_expiry_delta(this_ptr, val);
35568 // debug statements here
35570 // 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, uint32_t final_cltv_expiry_delta_arg);
35572 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, final_cltv_expiry_delta_arg: number): bigint {
35573 if(!isWasmInitialized) {
35574 throw new Error("initializeWasm() must be awaited first!");
35576 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, final_cltv_expiry_delta_arg);
35577 return nativeResponseValue;
35579 // uint64_t PaymentParameters_clone_ptr(LDKPaymentParameters *NONNULL_PTR arg);
35581 export function PaymentParameters_clone_ptr(arg: bigint): bigint {
35582 if(!isWasmInitialized) {
35583 throw new Error("initializeWasm() must be awaited first!");
35585 const nativeResponseValue = wasm.TS_PaymentParameters_clone_ptr(arg);
35586 return nativeResponseValue;
35588 // struct LDKPaymentParameters PaymentParameters_clone(const struct LDKPaymentParameters *NONNULL_PTR orig);
35590 export function PaymentParameters_clone(orig: bigint): bigint {
35591 if(!isWasmInitialized) {
35592 throw new Error("initializeWasm() must be awaited first!");
35594 const nativeResponseValue = wasm.TS_PaymentParameters_clone(orig);
35595 return nativeResponseValue;
35597 // uint64_t PaymentParameters_hash(const struct LDKPaymentParameters *NONNULL_PTR o);
35599 export function PaymentParameters_hash(o: bigint): bigint {
35600 if(!isWasmInitialized) {
35601 throw new Error("initializeWasm() must be awaited first!");
35603 const nativeResponseValue = wasm.TS_PaymentParameters_hash(o);
35604 return nativeResponseValue;
35606 // bool PaymentParameters_eq(const struct LDKPaymentParameters *NONNULL_PTR a, const struct LDKPaymentParameters *NONNULL_PTR b);
35608 export function PaymentParameters_eq(a: bigint, b: bigint): boolean {
35609 if(!isWasmInitialized) {
35610 throw new Error("initializeWasm() must be awaited first!");
35612 const nativeResponseValue = wasm.TS_PaymentParameters_eq(a, b);
35613 return nativeResponseValue;
35615 // struct LDKCVec_u8Z PaymentParameters_write(const struct LDKPaymentParameters *NONNULL_PTR obj);
35617 export function PaymentParameters_write(obj: bigint): number {
35618 if(!isWasmInitialized) {
35619 throw new Error("initializeWasm() must be awaited first!");
35621 const nativeResponseValue = wasm.TS_PaymentParameters_write(obj);
35622 return nativeResponseValue;
35624 // struct LDKCResult_PaymentParametersDecodeErrorZ PaymentParameters_read(struct LDKu8slice ser, uint32_t arg);
35626 export function PaymentParameters_read(ser: number, arg: number): bigint {
35627 if(!isWasmInitialized) {
35628 throw new Error("initializeWasm() must be awaited first!");
35630 const nativeResponseValue = wasm.TS_PaymentParameters_read(ser, arg);
35631 return nativeResponseValue;
35633 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_from_node_id(struct LDKPublicKey payee_pubkey, uint32_t final_cltv_expiry_delta);
35635 export function PaymentParameters_from_node_id(payee_pubkey: number, final_cltv_expiry_delta: number): bigint {
35636 if(!isWasmInitialized) {
35637 throw new Error("initializeWasm() must be awaited first!");
35639 const nativeResponseValue = wasm.TS_PaymentParameters_from_node_id(payee_pubkey, final_cltv_expiry_delta);
35640 return nativeResponseValue;
35642 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_for_keysend(struct LDKPublicKey payee_pubkey, uint32_t final_cltv_expiry_delta);
35644 export function PaymentParameters_for_keysend(payee_pubkey: number, final_cltv_expiry_delta: number): bigint {
35645 if(!isWasmInitialized) {
35646 throw new Error("initializeWasm() must be awaited first!");
35648 const nativeResponseValue = wasm.TS_PaymentParameters_for_keysend(payee_pubkey, final_cltv_expiry_delta);
35649 return nativeResponseValue;
35651 // void RouteHint_free(struct LDKRouteHint this_obj);
35653 export function RouteHint_free(this_obj: bigint): void {
35654 if(!isWasmInitialized) {
35655 throw new Error("initializeWasm() must be awaited first!");
35657 const nativeResponseValue = wasm.TS_RouteHint_free(this_obj);
35658 // debug statements here
35660 // struct LDKCVec_RouteHintHopZ RouteHint_get_a(const struct LDKRouteHint *NONNULL_PTR this_ptr);
35662 export function RouteHint_get_a(this_ptr: bigint): number {
35663 if(!isWasmInitialized) {
35664 throw new Error("initializeWasm() must be awaited first!");
35666 const nativeResponseValue = wasm.TS_RouteHint_get_a(this_ptr);
35667 return nativeResponseValue;
35669 // void RouteHint_set_a(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintHopZ val);
35671 export function RouteHint_set_a(this_ptr: bigint, val: number): void {
35672 if(!isWasmInitialized) {
35673 throw new Error("initializeWasm() must be awaited first!");
35675 const nativeResponseValue = wasm.TS_RouteHint_set_a(this_ptr, val);
35676 // debug statements here
35678 // MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKCVec_RouteHintHopZ a_arg);
35680 export function RouteHint_new(a_arg: number): bigint {
35681 if(!isWasmInitialized) {
35682 throw new Error("initializeWasm() must be awaited first!");
35684 const nativeResponseValue = wasm.TS_RouteHint_new(a_arg);
35685 return nativeResponseValue;
35687 // uint64_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg);
35689 export function RouteHint_clone_ptr(arg: bigint): bigint {
35690 if(!isWasmInitialized) {
35691 throw new Error("initializeWasm() must be awaited first!");
35693 const nativeResponseValue = wasm.TS_RouteHint_clone_ptr(arg);
35694 return nativeResponseValue;
35696 // struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
35698 export function RouteHint_clone(orig: bigint): bigint {
35699 if(!isWasmInitialized) {
35700 throw new Error("initializeWasm() must be awaited first!");
35702 const nativeResponseValue = wasm.TS_RouteHint_clone(orig);
35703 return nativeResponseValue;
35705 // uint64_t RouteHint_hash(const struct LDKRouteHint *NONNULL_PTR o);
35707 export function RouteHint_hash(o: bigint): bigint {
35708 if(!isWasmInitialized) {
35709 throw new Error("initializeWasm() must be awaited first!");
35711 const nativeResponseValue = wasm.TS_RouteHint_hash(o);
35712 return nativeResponseValue;
35714 // bool RouteHint_eq(const struct LDKRouteHint *NONNULL_PTR a, const struct LDKRouteHint *NONNULL_PTR b);
35716 export function RouteHint_eq(a: bigint, b: bigint): boolean {
35717 if(!isWasmInitialized) {
35718 throw new Error("initializeWasm() must be awaited first!");
35720 const nativeResponseValue = wasm.TS_RouteHint_eq(a, b);
35721 return nativeResponseValue;
35723 // struct LDKCVec_u8Z RouteHint_write(const struct LDKRouteHint *NONNULL_PTR obj);
35725 export function RouteHint_write(obj: bigint): number {
35726 if(!isWasmInitialized) {
35727 throw new Error("initializeWasm() must be awaited first!");
35729 const nativeResponseValue = wasm.TS_RouteHint_write(obj);
35730 return nativeResponseValue;
35732 // struct LDKCResult_RouteHintDecodeErrorZ RouteHint_read(struct LDKu8slice ser);
35734 export function RouteHint_read(ser: number): bigint {
35735 if(!isWasmInitialized) {
35736 throw new Error("initializeWasm() must be awaited first!");
35738 const nativeResponseValue = wasm.TS_RouteHint_read(ser);
35739 return nativeResponseValue;
35741 // void RouteHintHop_free(struct LDKRouteHintHop this_obj);
35743 export function RouteHintHop_free(this_obj: bigint): void {
35744 if(!isWasmInitialized) {
35745 throw new Error("initializeWasm() must be awaited first!");
35747 const nativeResponseValue = wasm.TS_RouteHintHop_free(this_obj);
35748 // debug statements here
35750 // struct LDKPublicKey RouteHintHop_get_src_node_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
35752 export function RouteHintHop_get_src_node_id(this_ptr: bigint): number {
35753 if(!isWasmInitialized) {
35754 throw new Error("initializeWasm() must be awaited first!");
35756 const nativeResponseValue = wasm.TS_RouteHintHop_get_src_node_id(this_ptr);
35757 return nativeResponseValue;
35759 // void RouteHintHop_set_src_node_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
35761 export function RouteHintHop_set_src_node_id(this_ptr: bigint, val: number): void {
35762 if(!isWasmInitialized) {
35763 throw new Error("initializeWasm() must be awaited first!");
35765 const nativeResponseValue = wasm.TS_RouteHintHop_set_src_node_id(this_ptr, val);
35766 // debug statements here
35768 // uint64_t RouteHintHop_get_short_channel_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
35770 export function RouteHintHop_get_short_channel_id(this_ptr: bigint): bigint {
35771 if(!isWasmInitialized) {
35772 throw new Error("initializeWasm() must be awaited first!");
35774 const nativeResponseValue = wasm.TS_RouteHintHop_get_short_channel_id(this_ptr);
35775 return nativeResponseValue;
35777 // void RouteHintHop_set_short_channel_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint64_t val);
35779 export function RouteHintHop_set_short_channel_id(this_ptr: bigint, val: bigint): void {
35780 if(!isWasmInitialized) {
35781 throw new Error("initializeWasm() must be awaited first!");
35783 const nativeResponseValue = wasm.TS_RouteHintHop_set_short_channel_id(this_ptr, val);
35784 // debug statements here
35786 // struct LDKRoutingFees RouteHintHop_get_fees(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
35788 export function RouteHintHop_get_fees(this_ptr: bigint): bigint {
35789 if(!isWasmInitialized) {
35790 throw new Error("initializeWasm() must be awaited first!");
35792 const nativeResponseValue = wasm.TS_RouteHintHop_get_fees(this_ptr);
35793 return nativeResponseValue;
35795 // void RouteHintHop_set_fees(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
35797 export function RouteHintHop_set_fees(this_ptr: bigint, val: bigint): void {
35798 if(!isWasmInitialized) {
35799 throw new Error("initializeWasm() must be awaited first!");
35801 const nativeResponseValue = wasm.TS_RouteHintHop_set_fees(this_ptr, val);
35802 // debug statements here
35804 // uint16_t RouteHintHop_get_cltv_expiry_delta(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
35806 export function RouteHintHop_get_cltv_expiry_delta(this_ptr: bigint): number {
35807 if(!isWasmInitialized) {
35808 throw new Error("initializeWasm() must be awaited first!");
35810 const nativeResponseValue = wasm.TS_RouteHintHop_get_cltv_expiry_delta(this_ptr);
35811 return nativeResponseValue;
35813 // void RouteHintHop_set_cltv_expiry_delta(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint16_t val);
35815 export function RouteHintHop_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
35816 if(!isWasmInitialized) {
35817 throw new Error("initializeWasm() must be awaited first!");
35819 const nativeResponseValue = wasm.TS_RouteHintHop_set_cltv_expiry_delta(this_ptr, val);
35820 // debug statements here
35822 // struct LDKCOption_u64Z RouteHintHop_get_htlc_minimum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
35824 export function RouteHintHop_get_htlc_minimum_msat(this_ptr: bigint): bigint {
35825 if(!isWasmInitialized) {
35826 throw new Error("initializeWasm() must be awaited first!");
35828 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_minimum_msat(this_ptr);
35829 return nativeResponseValue;
35831 // void RouteHintHop_set_htlc_minimum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
35833 export function RouteHintHop_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
35834 if(!isWasmInitialized) {
35835 throw new Error("initializeWasm() must be awaited first!");
35837 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_minimum_msat(this_ptr, val);
35838 // debug statements here
35840 // struct LDKCOption_u64Z RouteHintHop_get_htlc_maximum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
35842 export function RouteHintHop_get_htlc_maximum_msat(this_ptr: bigint): bigint {
35843 if(!isWasmInitialized) {
35844 throw new Error("initializeWasm() must be awaited first!");
35846 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_maximum_msat(this_ptr);
35847 return nativeResponseValue;
35849 // void RouteHintHop_set_htlc_maximum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
35851 export function RouteHintHop_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
35852 if(!isWasmInitialized) {
35853 throw new Error("initializeWasm() must be awaited first!");
35855 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_maximum_msat(this_ptr, val);
35856 // debug statements here
35858 // 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);
35860 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 {
35861 if(!isWasmInitialized) {
35862 throw new Error("initializeWasm() must be awaited first!");
35864 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);
35865 return nativeResponseValue;
35867 // uint64_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg);
35869 export function RouteHintHop_clone_ptr(arg: bigint): bigint {
35870 if(!isWasmInitialized) {
35871 throw new Error("initializeWasm() must be awaited first!");
35873 const nativeResponseValue = wasm.TS_RouteHintHop_clone_ptr(arg);
35874 return nativeResponseValue;
35876 // struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
35878 export function RouteHintHop_clone(orig: bigint): bigint {
35879 if(!isWasmInitialized) {
35880 throw new Error("initializeWasm() must be awaited first!");
35882 const nativeResponseValue = wasm.TS_RouteHintHop_clone(orig);
35883 return nativeResponseValue;
35885 // uint64_t RouteHintHop_hash(const struct LDKRouteHintHop *NONNULL_PTR o);
35887 export function RouteHintHop_hash(o: bigint): bigint {
35888 if(!isWasmInitialized) {
35889 throw new Error("initializeWasm() must be awaited first!");
35891 const nativeResponseValue = wasm.TS_RouteHintHop_hash(o);
35892 return nativeResponseValue;
35894 // bool RouteHintHop_eq(const struct LDKRouteHintHop *NONNULL_PTR a, const struct LDKRouteHintHop *NONNULL_PTR b);
35896 export function RouteHintHop_eq(a: bigint, b: bigint): boolean {
35897 if(!isWasmInitialized) {
35898 throw new Error("initializeWasm() must be awaited first!");
35900 const nativeResponseValue = wasm.TS_RouteHintHop_eq(a, b);
35901 return nativeResponseValue;
35903 // struct LDKCVec_u8Z RouteHintHop_write(const struct LDKRouteHintHop *NONNULL_PTR obj);
35905 export function RouteHintHop_write(obj: bigint): number {
35906 if(!isWasmInitialized) {
35907 throw new Error("initializeWasm() must be awaited first!");
35909 const nativeResponseValue = wasm.TS_RouteHintHop_write(obj);
35910 return nativeResponseValue;
35912 // struct LDKCResult_RouteHintHopDecodeErrorZ RouteHintHop_read(struct LDKu8slice ser);
35914 export function RouteHintHop_read(ser: number): bigint {
35915 if(!isWasmInitialized) {
35916 throw new Error("initializeWasm() must be awaited first!");
35918 const nativeResponseValue = wasm.TS_RouteHintHop_read(ser);
35919 return nativeResponseValue;
35921 // 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]);
35923 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 {
35924 if(!isWasmInitialized) {
35925 throw new Error("initializeWasm() must be awaited first!");
35927 const nativeResponseValue = wasm.TS_find_route(our_node_pubkey, route_params, network_graph, first_hops, logger, scorer, random_seed_bytes);
35928 return nativeResponseValue;
35930 // 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]);
35932 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 {
35933 if(!isWasmInitialized) {
35934 throw new Error("initializeWasm() must be awaited first!");
35936 const nativeResponseValue = wasm.TS_build_route_from_hops(our_node_pubkey, hops, route_params, network_graph, logger, random_seed_bytes);
35937 return nativeResponseValue;
35939 // void Score_free(struct LDKScore this_ptr);
35941 export function Score_free(this_ptr: bigint): void {
35942 if(!isWasmInitialized) {
35943 throw new Error("initializeWasm() must be awaited first!");
35945 const nativeResponseValue = wasm.TS_Score_free(this_ptr);
35946 // debug statements here
35948 // void LockableScore_free(struct LDKLockableScore this_ptr);
35950 export function LockableScore_free(this_ptr: bigint): void {
35951 if(!isWasmInitialized) {
35952 throw new Error("initializeWasm() must be awaited first!");
35954 const nativeResponseValue = wasm.TS_LockableScore_free(this_ptr);
35955 // debug statements here
35957 // void WriteableScore_free(struct LDKWriteableScore this_ptr);
35959 export function WriteableScore_free(this_ptr: bigint): void {
35960 if(!isWasmInitialized) {
35961 throw new Error("initializeWasm() must be awaited first!");
35963 const nativeResponseValue = wasm.TS_WriteableScore_free(this_ptr);
35964 // debug statements here
35966 // void MultiThreadedLockableScore_free(struct LDKMultiThreadedLockableScore this_obj);
35968 export function MultiThreadedLockableScore_free(this_obj: bigint): void {
35969 if(!isWasmInitialized) {
35970 throw new Error("initializeWasm() must be awaited first!");
35972 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_free(this_obj);
35973 // debug statements here
35975 // void MultiThreadedScoreLock_free(struct LDKMultiThreadedScoreLock this_obj);
35977 export function MultiThreadedScoreLock_free(this_obj: bigint): void {
35978 if(!isWasmInitialized) {
35979 throw new Error("initializeWasm() must be awaited first!");
35981 const nativeResponseValue = wasm.TS_MultiThreadedScoreLock_free(this_obj);
35982 // debug statements here
35984 // struct LDKScore MultiThreadedScoreLock_as_Score(const struct LDKMultiThreadedScoreLock *NONNULL_PTR this_arg);
35986 export function MultiThreadedScoreLock_as_Score(this_arg: bigint): bigint {
35987 if(!isWasmInitialized) {
35988 throw new Error("initializeWasm() must be awaited first!");
35990 const nativeResponseValue = wasm.TS_MultiThreadedScoreLock_as_Score(this_arg);
35991 return nativeResponseValue;
35993 // struct LDKCVec_u8Z MultiThreadedScoreLock_write(const struct LDKMultiThreadedScoreLock *NONNULL_PTR obj);
35995 export function MultiThreadedScoreLock_write(obj: bigint): number {
35996 if(!isWasmInitialized) {
35997 throw new Error("initializeWasm() must be awaited first!");
35999 const nativeResponseValue = wasm.TS_MultiThreadedScoreLock_write(obj);
36000 return nativeResponseValue;
36002 // struct LDKLockableScore MultiThreadedLockableScore_as_LockableScore(const struct LDKMultiThreadedLockableScore *NONNULL_PTR this_arg);
36004 export function MultiThreadedLockableScore_as_LockableScore(this_arg: bigint): bigint {
36005 if(!isWasmInitialized) {
36006 throw new Error("initializeWasm() must be awaited first!");
36008 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_as_LockableScore(this_arg);
36009 return nativeResponseValue;
36011 // struct LDKCVec_u8Z MultiThreadedLockableScore_write(const struct LDKMultiThreadedLockableScore *NONNULL_PTR obj);
36013 export function MultiThreadedLockableScore_write(obj: bigint): number {
36014 if(!isWasmInitialized) {
36015 throw new Error("initializeWasm() must be awaited first!");
36017 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_write(obj);
36018 return nativeResponseValue;
36020 // struct LDKWriteableScore MultiThreadedLockableScore_as_WriteableScore(const struct LDKMultiThreadedLockableScore *NONNULL_PTR this_arg);
36022 export function MultiThreadedLockableScore_as_WriteableScore(this_arg: bigint): bigint {
36023 if(!isWasmInitialized) {
36024 throw new Error("initializeWasm() must be awaited first!");
36026 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_as_WriteableScore(this_arg);
36027 return nativeResponseValue;
36029 // MUST_USE_RES struct LDKMultiThreadedLockableScore MultiThreadedLockableScore_new(struct LDKScore score);
36031 export function MultiThreadedLockableScore_new(score: bigint): bigint {
36032 if(!isWasmInitialized) {
36033 throw new Error("initializeWasm() must be awaited first!");
36035 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_new(score);
36036 return nativeResponseValue;
36038 // void ChannelUsage_free(struct LDKChannelUsage this_obj);
36040 export function ChannelUsage_free(this_obj: bigint): void {
36041 if(!isWasmInitialized) {
36042 throw new Error("initializeWasm() must be awaited first!");
36044 const nativeResponseValue = wasm.TS_ChannelUsage_free(this_obj);
36045 // debug statements here
36047 // uint64_t ChannelUsage_get_amount_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
36049 export function ChannelUsage_get_amount_msat(this_ptr: bigint): bigint {
36050 if(!isWasmInitialized) {
36051 throw new Error("initializeWasm() must be awaited first!");
36053 const nativeResponseValue = wasm.TS_ChannelUsage_get_amount_msat(this_ptr);
36054 return nativeResponseValue;
36056 // void ChannelUsage_set_amount_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
36058 export function ChannelUsage_set_amount_msat(this_ptr: bigint, val: bigint): void {
36059 if(!isWasmInitialized) {
36060 throw new Error("initializeWasm() must be awaited first!");
36062 const nativeResponseValue = wasm.TS_ChannelUsage_set_amount_msat(this_ptr, val);
36063 // debug statements here
36065 // uint64_t ChannelUsage_get_inflight_htlc_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
36067 export function ChannelUsage_get_inflight_htlc_msat(this_ptr: bigint): bigint {
36068 if(!isWasmInitialized) {
36069 throw new Error("initializeWasm() must be awaited first!");
36071 const nativeResponseValue = wasm.TS_ChannelUsage_get_inflight_htlc_msat(this_ptr);
36072 return nativeResponseValue;
36074 // void ChannelUsage_set_inflight_htlc_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
36076 export function ChannelUsage_set_inflight_htlc_msat(this_ptr: bigint, val: bigint): void {
36077 if(!isWasmInitialized) {
36078 throw new Error("initializeWasm() must be awaited first!");
36080 const nativeResponseValue = wasm.TS_ChannelUsage_set_inflight_htlc_msat(this_ptr, val);
36081 // debug statements here
36083 // struct LDKEffectiveCapacity ChannelUsage_get_effective_capacity(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
36085 export function ChannelUsage_get_effective_capacity(this_ptr: bigint): bigint {
36086 if(!isWasmInitialized) {
36087 throw new Error("initializeWasm() must be awaited first!");
36089 const nativeResponseValue = wasm.TS_ChannelUsage_get_effective_capacity(this_ptr);
36090 return nativeResponseValue;
36092 // void ChannelUsage_set_effective_capacity(struct LDKChannelUsage *NONNULL_PTR this_ptr, struct LDKEffectiveCapacity val);
36094 export function ChannelUsage_set_effective_capacity(this_ptr: bigint, val: bigint): void {
36095 if(!isWasmInitialized) {
36096 throw new Error("initializeWasm() must be awaited first!");
36098 const nativeResponseValue = wasm.TS_ChannelUsage_set_effective_capacity(this_ptr, val);
36099 // debug statements here
36101 // MUST_USE_RES struct LDKChannelUsage ChannelUsage_new(uint64_t amount_msat_arg, uint64_t inflight_htlc_msat_arg, struct LDKEffectiveCapacity effective_capacity_arg);
36103 export function ChannelUsage_new(amount_msat_arg: bigint, inflight_htlc_msat_arg: bigint, effective_capacity_arg: bigint): bigint {
36104 if(!isWasmInitialized) {
36105 throw new Error("initializeWasm() must be awaited first!");
36107 const nativeResponseValue = wasm.TS_ChannelUsage_new(amount_msat_arg, inflight_htlc_msat_arg, effective_capacity_arg);
36108 return nativeResponseValue;
36110 // uint64_t ChannelUsage_clone_ptr(LDKChannelUsage *NONNULL_PTR arg);
36112 export function ChannelUsage_clone_ptr(arg: bigint): bigint {
36113 if(!isWasmInitialized) {
36114 throw new Error("initializeWasm() must be awaited first!");
36116 const nativeResponseValue = wasm.TS_ChannelUsage_clone_ptr(arg);
36117 return nativeResponseValue;
36119 // struct LDKChannelUsage ChannelUsage_clone(const struct LDKChannelUsage *NONNULL_PTR orig);
36121 export function ChannelUsage_clone(orig: bigint): bigint {
36122 if(!isWasmInitialized) {
36123 throw new Error("initializeWasm() must be awaited first!");
36125 const nativeResponseValue = wasm.TS_ChannelUsage_clone(orig);
36126 return nativeResponseValue;
36128 // void FixedPenaltyScorer_free(struct LDKFixedPenaltyScorer this_obj);
36130 export function FixedPenaltyScorer_free(this_obj: bigint): void {
36131 if(!isWasmInitialized) {
36132 throw new Error("initializeWasm() must be awaited first!");
36134 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_free(this_obj);
36135 // debug statements here
36137 // uint64_t FixedPenaltyScorer_clone_ptr(LDKFixedPenaltyScorer *NONNULL_PTR arg);
36139 export function FixedPenaltyScorer_clone_ptr(arg: bigint): bigint {
36140 if(!isWasmInitialized) {
36141 throw new Error("initializeWasm() must be awaited first!");
36143 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone_ptr(arg);
36144 return nativeResponseValue;
36146 // struct LDKFixedPenaltyScorer FixedPenaltyScorer_clone(const struct LDKFixedPenaltyScorer *NONNULL_PTR orig);
36148 export function FixedPenaltyScorer_clone(orig: bigint): bigint {
36149 if(!isWasmInitialized) {
36150 throw new Error("initializeWasm() must be awaited first!");
36152 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone(orig);
36153 return nativeResponseValue;
36155 // MUST_USE_RES struct LDKFixedPenaltyScorer FixedPenaltyScorer_with_penalty(uint64_t penalty_msat);
36157 export function FixedPenaltyScorer_with_penalty(penalty_msat: bigint): bigint {
36158 if(!isWasmInitialized) {
36159 throw new Error("initializeWasm() must be awaited first!");
36161 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_with_penalty(penalty_msat);
36162 return nativeResponseValue;
36164 // struct LDKScore FixedPenaltyScorer_as_Score(const struct LDKFixedPenaltyScorer *NONNULL_PTR this_arg);
36166 export function FixedPenaltyScorer_as_Score(this_arg: bigint): bigint {
36167 if(!isWasmInitialized) {
36168 throw new Error("initializeWasm() must be awaited first!");
36170 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_as_Score(this_arg);
36171 return nativeResponseValue;
36173 // struct LDKCVec_u8Z FixedPenaltyScorer_write(const struct LDKFixedPenaltyScorer *NONNULL_PTR obj);
36175 export function FixedPenaltyScorer_write(obj: bigint): number {
36176 if(!isWasmInitialized) {
36177 throw new Error("initializeWasm() must be awaited first!");
36179 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_write(obj);
36180 return nativeResponseValue;
36182 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ FixedPenaltyScorer_read(struct LDKu8slice ser, uint64_t arg);
36184 export function FixedPenaltyScorer_read(ser: number, arg: bigint): bigint {
36185 if(!isWasmInitialized) {
36186 throw new Error("initializeWasm() must be awaited first!");
36188 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_read(ser, arg);
36189 return nativeResponseValue;
36191 // void ProbabilisticScorer_free(struct LDKProbabilisticScorer this_obj);
36193 export function ProbabilisticScorer_free(this_obj: bigint): void {
36194 if(!isWasmInitialized) {
36195 throw new Error("initializeWasm() must be awaited first!");
36197 const nativeResponseValue = wasm.TS_ProbabilisticScorer_free(this_obj);
36198 // debug statements here
36200 // void ProbabilisticScoringParameters_free(struct LDKProbabilisticScoringParameters this_obj);
36202 export function ProbabilisticScoringParameters_free(this_obj: bigint): void {
36203 if(!isWasmInitialized) {
36204 throw new Error("initializeWasm() must be awaited first!");
36206 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_free(this_obj);
36207 // debug statements here
36209 // uint64_t ProbabilisticScoringParameters_get_base_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
36211 export function ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr: bigint): bigint {
36212 if(!isWasmInitialized) {
36213 throw new Error("initializeWasm() must be awaited first!");
36215 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr);
36216 return nativeResponseValue;
36218 // void ProbabilisticScoringParameters_set_base_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
36220 export function ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr: bigint, val: bigint): void {
36221 if(!isWasmInitialized) {
36222 throw new Error("initializeWasm() must be awaited first!");
36224 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr, val);
36225 // debug statements here
36227 // uint64_t ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
36229 export function ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
36230 if(!isWasmInitialized) {
36231 throw new Error("initializeWasm() must be awaited first!");
36233 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(this_ptr);
36234 return nativeResponseValue;
36236 // void ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
36238 export function ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
36239 if(!isWasmInitialized) {
36240 throw new Error("initializeWasm() must be awaited first!");
36242 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(this_ptr, val);
36243 // debug statements here
36245 // uint64_t ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
36247 export function ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr: bigint): bigint {
36248 if(!isWasmInitialized) {
36249 throw new Error("initializeWasm() must be awaited first!");
36251 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr);
36252 return nativeResponseValue;
36254 // void ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
36256 export function ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr: bigint, val: bigint): void {
36257 if(!isWasmInitialized) {
36258 throw new Error("initializeWasm() must be awaited first!");
36260 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr, val);
36261 // debug statements here
36263 // uint64_t ProbabilisticScoringParameters_get_liquidity_offset_half_life(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
36265 export function ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr: bigint): bigint {
36266 if(!isWasmInitialized) {
36267 throw new Error("initializeWasm() must be awaited first!");
36269 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr);
36270 return nativeResponseValue;
36272 // void ProbabilisticScoringParameters_set_liquidity_offset_half_life(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
36274 export function ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr: bigint, val: bigint): void {
36275 if(!isWasmInitialized) {
36276 throw new Error("initializeWasm() must be awaited first!");
36278 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr, val);
36279 // debug statements here
36281 // uint64_t ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
36283 export function ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
36284 if(!isWasmInitialized) {
36285 throw new Error("initializeWasm() must be awaited first!");
36287 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr);
36288 return nativeResponseValue;
36290 // void ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
36292 export function ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
36293 if(!isWasmInitialized) {
36294 throw new Error("initializeWasm() must be awaited first!");
36296 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr, val);
36297 // debug statements here
36299 // uint64_t ProbabilisticScoringParameters_get_historical_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
36301 export function ProbabilisticScoringParameters_get_historical_liquidity_penalty_multiplier_msat(this_ptr: bigint): bigint {
36302 if(!isWasmInitialized) {
36303 throw new Error("initializeWasm() must be awaited first!");
36305 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_historical_liquidity_penalty_multiplier_msat(this_ptr);
36306 return nativeResponseValue;
36308 // void ProbabilisticScoringParameters_set_historical_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
36310 export function ProbabilisticScoringParameters_set_historical_liquidity_penalty_multiplier_msat(this_ptr: bigint, val: bigint): void {
36311 if(!isWasmInitialized) {
36312 throw new Error("initializeWasm() must be awaited first!");
36314 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_historical_liquidity_penalty_multiplier_msat(this_ptr, val);
36315 // debug statements here
36317 // uint64_t ProbabilisticScoringParameters_get_historical_liquidity_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
36319 export function ProbabilisticScoringParameters_get_historical_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
36320 if(!isWasmInitialized) {
36321 throw new Error("initializeWasm() must be awaited first!");
36323 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_historical_liquidity_penalty_amount_multiplier_msat(this_ptr);
36324 return nativeResponseValue;
36326 // void ProbabilisticScoringParameters_set_historical_liquidity_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
36328 export function ProbabilisticScoringParameters_set_historical_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
36329 if(!isWasmInitialized) {
36330 throw new Error("initializeWasm() must be awaited first!");
36332 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_historical_liquidity_penalty_amount_multiplier_msat(this_ptr, val);
36333 // debug statements here
36335 // uint64_t ProbabilisticScoringParameters_get_historical_no_updates_half_life(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
36337 export function ProbabilisticScoringParameters_get_historical_no_updates_half_life(this_ptr: bigint): bigint {
36338 if(!isWasmInitialized) {
36339 throw new Error("initializeWasm() must be awaited first!");
36341 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_historical_no_updates_half_life(this_ptr);
36342 return nativeResponseValue;
36344 // void ProbabilisticScoringParameters_set_historical_no_updates_half_life(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
36346 export function ProbabilisticScoringParameters_set_historical_no_updates_half_life(this_ptr: bigint, val: bigint): void {
36347 if(!isWasmInitialized) {
36348 throw new Error("initializeWasm() must be awaited first!");
36350 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_historical_no_updates_half_life(this_ptr, val);
36351 // debug statements here
36353 // uint64_t ProbabilisticScoringParameters_get_anti_probing_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
36355 export function ProbabilisticScoringParameters_get_anti_probing_penalty_msat(this_ptr: bigint): bigint {
36356 if(!isWasmInitialized) {
36357 throw new Error("initializeWasm() must be awaited first!");
36359 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_anti_probing_penalty_msat(this_ptr);
36360 return nativeResponseValue;
36362 // void ProbabilisticScoringParameters_set_anti_probing_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
36364 export function ProbabilisticScoringParameters_set_anti_probing_penalty_msat(this_ptr: bigint, val: bigint): void {
36365 if(!isWasmInitialized) {
36366 throw new Error("initializeWasm() must be awaited first!");
36368 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_anti_probing_penalty_msat(this_ptr, val);
36369 // debug statements here
36371 // uint64_t ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
36373 export function ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(this_ptr: bigint): bigint {
36374 if(!isWasmInitialized) {
36375 throw new Error("initializeWasm() must be awaited first!");
36377 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(this_ptr);
36378 return nativeResponseValue;
36380 // void ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
36382 export function ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(this_ptr: bigint, val: bigint): void {
36383 if(!isWasmInitialized) {
36384 throw new Error("initializeWasm() must be awaited first!");
36386 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(this_ptr, val);
36387 // debug statements here
36389 // uint64_t ProbabilisticScoringParameters_clone_ptr(LDKProbabilisticScoringParameters *NONNULL_PTR arg);
36391 export function ProbabilisticScoringParameters_clone_ptr(arg: bigint): bigint {
36392 if(!isWasmInitialized) {
36393 throw new Error("initializeWasm() must be awaited first!");
36395 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone_ptr(arg);
36396 return nativeResponseValue;
36398 // struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_clone(const struct LDKProbabilisticScoringParameters *NONNULL_PTR orig);
36400 export function ProbabilisticScoringParameters_clone(orig: bigint): bigint {
36401 if(!isWasmInitialized) {
36402 throw new Error("initializeWasm() must be awaited first!");
36404 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone(orig);
36405 return nativeResponseValue;
36407 // MUST_USE_RES struct LDKProbabilisticScorer ProbabilisticScorer_new(struct LDKProbabilisticScoringParameters params, const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger);
36409 export function ProbabilisticScorer_new(params: bigint, network_graph: bigint, logger: bigint): bigint {
36410 if(!isWasmInitialized) {
36411 throw new Error("initializeWasm() must be awaited first!");
36413 const nativeResponseValue = wasm.TS_ProbabilisticScorer_new(params, network_graph, logger);
36414 return nativeResponseValue;
36416 // void ProbabilisticScorer_debug_log_liquidity_stats(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
36418 export function ProbabilisticScorer_debug_log_liquidity_stats(this_arg: bigint): void {
36419 if(!isWasmInitialized) {
36420 throw new Error("initializeWasm() must be awaited first!");
36422 const nativeResponseValue = wasm.TS_ProbabilisticScorer_debug_log_liquidity_stats(this_arg);
36423 // debug statements here
36425 // 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);
36427 export function ProbabilisticScorer_estimated_channel_liquidity_range(this_arg: bigint, scid: bigint, target: bigint): bigint {
36428 if(!isWasmInitialized) {
36429 throw new Error("initializeWasm() must be awaited first!");
36431 const nativeResponseValue = wasm.TS_ProbabilisticScorer_estimated_channel_liquidity_range(this_arg, scid, target);
36432 return nativeResponseValue;
36434 // MUST_USE_RES struct LDKCOption_C2Tuple_EightU16sEightU16sZZ ProbabilisticScorer_historical_estimated_channel_liquidity_probabilities(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg, uint64_t scid, const struct LDKNodeId *NONNULL_PTR target);
36436 export function ProbabilisticScorer_historical_estimated_channel_liquidity_probabilities(this_arg: bigint, scid: bigint, target: bigint): bigint {
36437 if(!isWasmInitialized) {
36438 throw new Error("initializeWasm() must be awaited first!");
36440 const nativeResponseValue = wasm.TS_ProbabilisticScorer_historical_estimated_channel_liquidity_probabilities(this_arg, scid, target);
36441 return nativeResponseValue;
36443 // void ProbabilisticScorer_add_banned(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
36445 export function ProbabilisticScorer_add_banned(this_arg: bigint, node_id: bigint): void {
36446 if(!isWasmInitialized) {
36447 throw new Error("initializeWasm() must be awaited first!");
36449 const nativeResponseValue = wasm.TS_ProbabilisticScorer_add_banned(this_arg, node_id);
36450 // debug statements here
36452 // void ProbabilisticScorer_remove_banned(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
36454 export function ProbabilisticScorer_remove_banned(this_arg: bigint, node_id: bigint): void {
36455 if(!isWasmInitialized) {
36456 throw new Error("initializeWasm() must be awaited first!");
36458 const nativeResponseValue = wasm.TS_ProbabilisticScorer_remove_banned(this_arg, node_id);
36459 // debug statements here
36461 // void ProbabilisticScorer_set_manual_penalty(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id, uint64_t penalty);
36463 export function ProbabilisticScorer_set_manual_penalty(this_arg: bigint, node_id: bigint, penalty: bigint): void {
36464 if(!isWasmInitialized) {
36465 throw new Error("initializeWasm() must be awaited first!");
36467 const nativeResponseValue = wasm.TS_ProbabilisticScorer_set_manual_penalty(this_arg, node_id, penalty);
36468 // debug statements here
36470 // void ProbabilisticScorer_remove_manual_penalty(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
36472 export function ProbabilisticScorer_remove_manual_penalty(this_arg: bigint, node_id: bigint): void {
36473 if(!isWasmInitialized) {
36474 throw new Error("initializeWasm() must be awaited first!");
36476 const nativeResponseValue = wasm.TS_ProbabilisticScorer_remove_manual_penalty(this_arg, node_id);
36477 // debug statements here
36479 // void ProbabilisticScorer_clear_manual_penalties(struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
36481 export function ProbabilisticScorer_clear_manual_penalties(this_arg: bigint): void {
36482 if(!isWasmInitialized) {
36483 throw new Error("initializeWasm() must be awaited first!");
36485 const nativeResponseValue = wasm.TS_ProbabilisticScorer_clear_manual_penalties(this_arg);
36486 // debug statements here
36488 // void ProbabilisticScoringParameters_add_banned_from_list(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_arg, struct LDKCVec_NodeIdZ node_ids);
36490 export function ProbabilisticScoringParameters_add_banned_from_list(this_arg: bigint, node_ids: number): void {
36491 if(!isWasmInitialized) {
36492 throw new Error("initializeWasm() must be awaited first!");
36494 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_add_banned_from_list(this_arg, node_ids);
36495 // debug statements here
36497 // MUST_USE_RES struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_default(void);
36499 export function ProbabilisticScoringParameters_default(): bigint {
36500 if(!isWasmInitialized) {
36501 throw new Error("initializeWasm() must be awaited first!");
36503 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_default();
36504 return nativeResponseValue;
36506 // struct LDKScore ProbabilisticScorer_as_Score(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
36508 export function ProbabilisticScorer_as_Score(this_arg: bigint): bigint {
36509 if(!isWasmInitialized) {
36510 throw new Error("initializeWasm() must be awaited first!");
36512 const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_Score(this_arg);
36513 return nativeResponseValue;
36515 // struct LDKCVec_u8Z ProbabilisticScorer_write(const struct LDKProbabilisticScorer *NONNULL_PTR obj);
36517 export function ProbabilisticScorer_write(obj: bigint): number {
36518 if(!isWasmInitialized) {
36519 throw new Error("initializeWasm() must be awaited first!");
36521 const nativeResponseValue = wasm.TS_ProbabilisticScorer_write(obj);
36522 return nativeResponseValue;
36524 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ ProbabilisticScorer_read(struct LDKu8slice ser, struct LDKProbabilisticScoringParameters arg_a, const struct LDKNetworkGraph *NONNULL_PTR arg_b, struct LDKLogger arg_c);
36526 export function ProbabilisticScorer_read(ser: number, arg_a: bigint, arg_b: bigint, arg_c: bigint): bigint {
36527 if(!isWasmInitialized) {
36528 throw new Error("initializeWasm() must be awaited first!");
36530 const nativeResponseValue = wasm.TS_ProbabilisticScorer_read(ser, arg_a, arg_b, arg_c);
36531 return nativeResponseValue;
36533 // void BlindedPath_free(struct LDKBlindedPath this_obj);
36535 export function BlindedPath_free(this_obj: bigint): void {
36536 if(!isWasmInitialized) {
36537 throw new Error("initializeWasm() must be awaited first!");
36539 const nativeResponseValue = wasm.TS_BlindedPath_free(this_obj);
36540 // debug statements here
36542 // uint64_t BlindedPath_clone_ptr(LDKBlindedPath *NONNULL_PTR arg);
36544 export function BlindedPath_clone_ptr(arg: bigint): bigint {
36545 if(!isWasmInitialized) {
36546 throw new Error("initializeWasm() must be awaited first!");
36548 const nativeResponseValue = wasm.TS_BlindedPath_clone_ptr(arg);
36549 return nativeResponseValue;
36551 // struct LDKBlindedPath BlindedPath_clone(const struct LDKBlindedPath *NONNULL_PTR orig);
36553 export function BlindedPath_clone(orig: bigint): bigint {
36554 if(!isWasmInitialized) {
36555 throw new Error("initializeWasm() must be awaited first!");
36557 const nativeResponseValue = wasm.TS_BlindedPath_clone(orig);
36558 return nativeResponseValue;
36560 // void BlindedHop_free(struct LDKBlindedHop this_obj);
36562 export function BlindedHop_free(this_obj: bigint): void {
36563 if(!isWasmInitialized) {
36564 throw new Error("initializeWasm() must be awaited first!");
36566 const nativeResponseValue = wasm.TS_BlindedHop_free(this_obj);
36567 // debug statements here
36569 // uint64_t BlindedHop_clone_ptr(LDKBlindedHop *NONNULL_PTR arg);
36571 export function BlindedHop_clone_ptr(arg: bigint): bigint {
36572 if(!isWasmInitialized) {
36573 throw new Error("initializeWasm() must be awaited first!");
36575 const nativeResponseValue = wasm.TS_BlindedHop_clone_ptr(arg);
36576 return nativeResponseValue;
36578 // struct LDKBlindedHop BlindedHop_clone(const struct LDKBlindedHop *NONNULL_PTR orig);
36580 export function BlindedHop_clone(orig: bigint): bigint {
36581 if(!isWasmInitialized) {
36582 throw new Error("initializeWasm() must be awaited first!");
36584 const nativeResponseValue = wasm.TS_BlindedHop_clone(orig);
36585 return nativeResponseValue;
36587 // MUST_USE_RES struct LDKCResult_BlindedPathNoneZ BlindedPath_new(struct LDKCVec_PublicKeyZ node_pks, const struct LDKEntropySource *NONNULL_PTR entropy_source);
36589 export function BlindedPath_new(node_pks: number, entropy_source: bigint): bigint {
36590 if(!isWasmInitialized) {
36591 throw new Error("initializeWasm() must be awaited first!");
36593 const nativeResponseValue = wasm.TS_BlindedPath_new(node_pks, entropy_source);
36594 return nativeResponseValue;
36596 // struct LDKCVec_u8Z BlindedPath_write(const struct LDKBlindedPath *NONNULL_PTR obj);
36598 export function BlindedPath_write(obj: bigint): number {
36599 if(!isWasmInitialized) {
36600 throw new Error("initializeWasm() must be awaited first!");
36602 const nativeResponseValue = wasm.TS_BlindedPath_write(obj);
36603 return nativeResponseValue;
36605 // struct LDKCResult_BlindedPathDecodeErrorZ BlindedPath_read(struct LDKu8slice ser);
36607 export function BlindedPath_read(ser: number): bigint {
36608 if(!isWasmInitialized) {
36609 throw new Error("initializeWasm() must be awaited first!");
36611 const nativeResponseValue = wasm.TS_BlindedPath_read(ser);
36612 return nativeResponseValue;
36614 // struct LDKCVec_u8Z BlindedHop_write(const struct LDKBlindedHop *NONNULL_PTR obj);
36616 export function BlindedHop_write(obj: bigint): number {
36617 if(!isWasmInitialized) {
36618 throw new Error("initializeWasm() must be awaited first!");
36620 const nativeResponseValue = wasm.TS_BlindedHop_write(obj);
36621 return nativeResponseValue;
36623 // struct LDKCResult_BlindedHopDecodeErrorZ BlindedHop_read(struct LDKu8slice ser);
36625 export function BlindedHop_read(ser: number): bigint {
36626 if(!isWasmInitialized) {
36627 throw new Error("initializeWasm() must be awaited first!");
36629 const nativeResponseValue = wasm.TS_BlindedHop_read(ser);
36630 return nativeResponseValue;
36632 // void OnionMessenger_free(struct LDKOnionMessenger this_obj);
36634 export function OnionMessenger_free(this_obj: bigint): void {
36635 if(!isWasmInitialized) {
36636 throw new Error("initializeWasm() must be awaited first!");
36638 const nativeResponseValue = wasm.TS_OnionMessenger_free(this_obj);
36639 // debug statements here
36641 // void Destination_free(struct LDKDestination this_ptr);
36643 export function Destination_free(this_ptr: bigint): void {
36644 if(!isWasmInitialized) {
36645 throw new Error("initializeWasm() must be awaited first!");
36647 const nativeResponseValue = wasm.TS_Destination_free(this_ptr);
36648 // debug statements here
36650 // uint64_t Destination_clone_ptr(LDKDestination *NONNULL_PTR arg);
36652 export function Destination_clone_ptr(arg: bigint): bigint {
36653 if(!isWasmInitialized) {
36654 throw new Error("initializeWasm() must be awaited first!");
36656 const nativeResponseValue = wasm.TS_Destination_clone_ptr(arg);
36657 return nativeResponseValue;
36659 // struct LDKDestination Destination_clone(const struct LDKDestination *NONNULL_PTR orig);
36661 export function Destination_clone(orig: bigint): bigint {
36662 if(!isWasmInitialized) {
36663 throw new Error("initializeWasm() must be awaited first!");
36665 const nativeResponseValue = wasm.TS_Destination_clone(orig);
36666 return nativeResponseValue;
36668 // struct LDKDestination Destination_node(struct LDKPublicKey a);
36670 export function Destination_node(a: number): bigint {
36671 if(!isWasmInitialized) {
36672 throw new Error("initializeWasm() must be awaited first!");
36674 const nativeResponseValue = wasm.TS_Destination_node(a);
36675 return nativeResponseValue;
36677 // struct LDKDestination Destination_blinded_path(struct LDKBlindedPath a);
36679 export function Destination_blinded_path(a: bigint): bigint {
36680 if(!isWasmInitialized) {
36681 throw new Error("initializeWasm() must be awaited first!");
36683 const nativeResponseValue = wasm.TS_Destination_blinded_path(a);
36684 return nativeResponseValue;
36686 // void SendError_free(struct LDKSendError this_ptr);
36688 export function SendError_free(this_ptr: bigint): void {
36689 if(!isWasmInitialized) {
36690 throw new Error("initializeWasm() must be awaited first!");
36692 const nativeResponseValue = wasm.TS_SendError_free(this_ptr);
36693 // debug statements here
36695 // uint64_t SendError_clone_ptr(LDKSendError *NONNULL_PTR arg);
36697 export function SendError_clone_ptr(arg: bigint): bigint {
36698 if(!isWasmInitialized) {
36699 throw new Error("initializeWasm() must be awaited first!");
36701 const nativeResponseValue = wasm.TS_SendError_clone_ptr(arg);
36702 return nativeResponseValue;
36704 // struct LDKSendError SendError_clone(const struct LDKSendError *NONNULL_PTR orig);
36706 export function SendError_clone(orig: bigint): bigint {
36707 if(!isWasmInitialized) {
36708 throw new Error("initializeWasm() must be awaited first!");
36710 const nativeResponseValue = wasm.TS_SendError_clone(orig);
36711 return nativeResponseValue;
36713 // struct LDKSendError SendError_secp256k1(enum LDKSecp256k1Error a);
36715 export function SendError_secp256k1(a: Secp256k1Error): bigint {
36716 if(!isWasmInitialized) {
36717 throw new Error("initializeWasm() must be awaited first!");
36719 const nativeResponseValue = wasm.TS_SendError_secp256k1(a);
36720 return nativeResponseValue;
36722 // struct LDKSendError SendError_too_big_packet(void);
36724 export function SendError_too_big_packet(): bigint {
36725 if(!isWasmInitialized) {
36726 throw new Error("initializeWasm() must be awaited first!");
36728 const nativeResponseValue = wasm.TS_SendError_too_big_packet();
36729 return nativeResponseValue;
36731 // struct LDKSendError SendError_too_few_blinded_hops(void);
36733 export function SendError_too_few_blinded_hops(): bigint {
36734 if(!isWasmInitialized) {
36735 throw new Error("initializeWasm() must be awaited first!");
36737 const nativeResponseValue = wasm.TS_SendError_too_few_blinded_hops();
36738 return nativeResponseValue;
36740 // struct LDKSendError SendError_invalid_first_hop(void);
36742 export function SendError_invalid_first_hop(): bigint {
36743 if(!isWasmInitialized) {
36744 throw new Error("initializeWasm() must be awaited first!");
36746 const nativeResponseValue = wasm.TS_SendError_invalid_first_hop();
36747 return nativeResponseValue;
36749 // struct LDKSendError SendError_invalid_message(void);
36751 export function SendError_invalid_message(): bigint {
36752 if(!isWasmInitialized) {
36753 throw new Error("initializeWasm() must be awaited first!");
36755 const nativeResponseValue = wasm.TS_SendError_invalid_message();
36756 return nativeResponseValue;
36758 // struct LDKSendError SendError_buffer_full(void);
36760 export function SendError_buffer_full(): bigint {
36761 if(!isWasmInitialized) {
36762 throw new Error("initializeWasm() must be awaited first!");
36764 const nativeResponseValue = wasm.TS_SendError_buffer_full();
36765 return nativeResponseValue;
36767 // struct LDKSendError SendError_get_node_id_failed(void);
36769 export function SendError_get_node_id_failed(): bigint {
36770 if(!isWasmInitialized) {
36771 throw new Error("initializeWasm() must be awaited first!");
36773 const nativeResponseValue = wasm.TS_SendError_get_node_id_failed();
36774 return nativeResponseValue;
36776 // struct LDKSendError SendError_blinded_path_advance_failed(void);
36778 export function SendError_blinded_path_advance_failed(): bigint {
36779 if(!isWasmInitialized) {
36780 throw new Error("initializeWasm() must be awaited first!");
36782 const nativeResponseValue = wasm.TS_SendError_blinded_path_advance_failed();
36783 return nativeResponseValue;
36785 // bool SendError_eq(const struct LDKSendError *NONNULL_PTR a, const struct LDKSendError *NONNULL_PTR b);
36787 export function SendError_eq(a: bigint, b: bigint): boolean {
36788 if(!isWasmInitialized) {
36789 throw new Error("initializeWasm() must be awaited first!");
36791 const nativeResponseValue = wasm.TS_SendError_eq(a, b);
36792 return nativeResponseValue;
36794 // void CustomOnionMessageHandler_free(struct LDKCustomOnionMessageHandler this_ptr);
36796 export function CustomOnionMessageHandler_free(this_ptr: bigint): void {
36797 if(!isWasmInitialized) {
36798 throw new Error("initializeWasm() must be awaited first!");
36800 const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_free(this_ptr);
36801 // debug statements here
36803 // MUST_USE_RES struct LDKOnionMessenger OnionMessenger_new(struct LDKEntropySource entropy_source, struct LDKNodeSigner node_signer, struct LDKLogger logger, struct LDKCustomOnionMessageHandler custom_handler);
36805 export function OnionMessenger_new(entropy_source: bigint, node_signer: bigint, logger: bigint, custom_handler: bigint): bigint {
36806 if(!isWasmInitialized) {
36807 throw new Error("initializeWasm() must be awaited first!");
36809 const nativeResponseValue = wasm.TS_OnionMessenger_new(entropy_source, node_signer, logger, custom_handler);
36810 return nativeResponseValue;
36812 // MUST_USE_RES struct LDKCResult_NoneSendErrorZ OnionMessenger_send_onion_message(const struct LDKOnionMessenger *NONNULL_PTR this_arg, struct LDKCVec_PublicKeyZ intermediate_nodes, struct LDKDestination destination, struct LDKOnionMessageContents message, struct LDKBlindedPath reply_path);
36814 export function OnionMessenger_send_onion_message(this_arg: bigint, intermediate_nodes: number, destination: bigint, message: bigint, reply_path: bigint): bigint {
36815 if(!isWasmInitialized) {
36816 throw new Error("initializeWasm() must be awaited first!");
36818 const nativeResponseValue = wasm.TS_OnionMessenger_send_onion_message(this_arg, intermediate_nodes, destination, message, reply_path);
36819 return nativeResponseValue;
36821 // struct LDKOnionMessageHandler OnionMessenger_as_OnionMessageHandler(const struct LDKOnionMessenger *NONNULL_PTR this_arg);
36823 export function OnionMessenger_as_OnionMessageHandler(this_arg: bigint): bigint {
36824 if(!isWasmInitialized) {
36825 throw new Error("initializeWasm() must be awaited first!");
36827 const nativeResponseValue = wasm.TS_OnionMessenger_as_OnionMessageHandler(this_arg);
36828 return nativeResponseValue;
36830 // struct LDKOnionMessageProvider OnionMessenger_as_OnionMessageProvider(const struct LDKOnionMessenger *NONNULL_PTR this_arg);
36832 export function OnionMessenger_as_OnionMessageProvider(this_arg: bigint): bigint {
36833 if(!isWasmInitialized) {
36834 throw new Error("initializeWasm() must be awaited first!");
36836 const nativeResponseValue = wasm.TS_OnionMessenger_as_OnionMessageProvider(this_arg);
36837 return nativeResponseValue;
36839 // void OnionMessageContents_free(struct LDKOnionMessageContents this_ptr);
36841 export function OnionMessageContents_free(this_ptr: bigint): void {
36842 if(!isWasmInitialized) {
36843 throw new Error("initializeWasm() must be awaited first!");
36845 const nativeResponseValue = wasm.TS_OnionMessageContents_free(this_ptr);
36846 // debug statements here
36848 // uint64_t OnionMessageContents_clone_ptr(LDKOnionMessageContents *NONNULL_PTR arg);
36850 export function OnionMessageContents_clone_ptr(arg: bigint): bigint {
36851 if(!isWasmInitialized) {
36852 throw new Error("initializeWasm() must be awaited first!");
36854 const nativeResponseValue = wasm.TS_OnionMessageContents_clone_ptr(arg);
36855 return nativeResponseValue;
36857 // struct LDKOnionMessageContents OnionMessageContents_clone(const struct LDKOnionMessageContents *NONNULL_PTR orig);
36859 export function OnionMessageContents_clone(orig: bigint): bigint {
36860 if(!isWasmInitialized) {
36861 throw new Error("initializeWasm() must be awaited first!");
36863 const nativeResponseValue = wasm.TS_OnionMessageContents_clone(orig);
36864 return nativeResponseValue;
36866 // struct LDKOnionMessageContents OnionMessageContents_custom(struct LDKCustomOnionMessageContents a);
36868 export function OnionMessageContents_custom(a: bigint): bigint {
36869 if(!isWasmInitialized) {
36870 throw new Error("initializeWasm() must be awaited first!");
36872 const nativeResponseValue = wasm.TS_OnionMessageContents_custom(a);
36873 return nativeResponseValue;
36875 // uint64_t CustomOnionMessageContents_clone_ptr(LDKCustomOnionMessageContents *NONNULL_PTR arg);
36877 export function CustomOnionMessageContents_clone_ptr(arg: bigint): bigint {
36878 if(!isWasmInitialized) {
36879 throw new Error("initializeWasm() must be awaited first!");
36881 const nativeResponseValue = wasm.TS_CustomOnionMessageContents_clone_ptr(arg);
36882 return nativeResponseValue;
36884 // struct LDKCustomOnionMessageContents CustomOnionMessageContents_clone(const struct LDKCustomOnionMessageContents *NONNULL_PTR orig);
36886 export function CustomOnionMessageContents_clone(orig: bigint): bigint {
36887 if(!isWasmInitialized) {
36888 throw new Error("initializeWasm() must be awaited first!");
36890 const nativeResponseValue = wasm.TS_CustomOnionMessageContents_clone(orig);
36891 return nativeResponseValue;
36893 // void CustomOnionMessageContents_free(struct LDKCustomOnionMessageContents this_ptr);
36895 export function CustomOnionMessageContents_free(this_ptr: bigint): void {
36896 if(!isWasmInitialized) {
36897 throw new Error("initializeWasm() must be awaited first!");
36899 const nativeResponseValue = wasm.TS_CustomOnionMessageContents_free(this_ptr);
36900 // debug statements here
36902 // void GossipSync_free(struct LDKGossipSync this_ptr);
36904 export function GossipSync_free(this_ptr: bigint): void {
36905 if(!isWasmInitialized) {
36906 throw new Error("initializeWasm() must be awaited first!");
36908 const nativeResponseValue = wasm.TS_GossipSync_free(this_ptr);
36909 // debug statements here
36911 // struct LDKGossipSync GossipSync_p2_p(const struct LDKP2PGossipSync *NONNULL_PTR a);
36913 export function GossipSync_p2_p(a: bigint): bigint {
36914 if(!isWasmInitialized) {
36915 throw new Error("initializeWasm() must be awaited first!");
36917 const nativeResponseValue = wasm.TS_GossipSync_p2_p(a);
36918 return nativeResponseValue;
36920 // struct LDKGossipSync GossipSync_rapid(const struct LDKRapidGossipSync *NONNULL_PTR a);
36922 export function GossipSync_rapid(a: bigint): bigint {
36923 if(!isWasmInitialized) {
36924 throw new Error("initializeWasm() must be awaited first!");
36926 const nativeResponseValue = wasm.TS_GossipSync_rapid(a);
36927 return nativeResponseValue;
36929 // struct LDKGossipSync GossipSync_none(void);
36931 export function GossipSync_none(): bigint {
36932 if(!isWasmInitialized) {
36933 throw new Error("initializeWasm() must be awaited first!");
36935 const nativeResponseValue = wasm.TS_GossipSync_none();
36936 return nativeResponseValue;
36938 // void RapidGossipSync_free(struct LDKRapidGossipSync this_obj);
36940 export function RapidGossipSync_free(this_obj: bigint): void {
36941 if(!isWasmInitialized) {
36942 throw new Error("initializeWasm() must be awaited first!");
36944 const nativeResponseValue = wasm.TS_RapidGossipSync_free(this_obj);
36945 // debug statements here
36947 // MUST_USE_RES struct LDKRapidGossipSync RapidGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger);
36949 export function RapidGossipSync_new(network_graph: bigint, logger: bigint): bigint {
36950 if(!isWasmInitialized) {
36951 throw new Error("initializeWasm() must be awaited first!");
36953 const nativeResponseValue = wasm.TS_RapidGossipSync_new(network_graph, logger);
36954 return nativeResponseValue;
36956 // MUST_USE_RES struct LDKCResult_u32GraphSyncErrorZ RapidGossipSync_update_network_graph(const struct LDKRapidGossipSync *NONNULL_PTR this_arg, struct LDKu8slice update_data);
36958 export function RapidGossipSync_update_network_graph(this_arg: bigint, update_data: number): bigint {
36959 if(!isWasmInitialized) {
36960 throw new Error("initializeWasm() must be awaited first!");
36962 const nativeResponseValue = wasm.TS_RapidGossipSync_update_network_graph(this_arg, update_data);
36963 return nativeResponseValue;
36965 // MUST_USE_RES struct LDKCResult_u32GraphSyncErrorZ RapidGossipSync_update_network_graph_no_std(const struct LDKRapidGossipSync *NONNULL_PTR this_arg, struct LDKu8slice update_data, struct LDKCOption_u64Z current_time_unix);
36967 export function RapidGossipSync_update_network_graph_no_std(this_arg: bigint, update_data: number, current_time_unix: bigint): bigint {
36968 if(!isWasmInitialized) {
36969 throw new Error("initializeWasm() must be awaited first!");
36971 const nativeResponseValue = wasm.TS_RapidGossipSync_update_network_graph_no_std(this_arg, update_data, current_time_unix);
36972 return nativeResponseValue;
36974 // MUST_USE_RES bool RapidGossipSync_is_initial_sync_complete(const struct LDKRapidGossipSync *NONNULL_PTR this_arg);
36976 export function RapidGossipSync_is_initial_sync_complete(this_arg: bigint): boolean {
36977 if(!isWasmInitialized) {
36978 throw new Error("initializeWasm() must be awaited first!");
36980 const nativeResponseValue = wasm.TS_RapidGossipSync_is_initial_sync_complete(this_arg);
36981 return nativeResponseValue;
36983 // void GraphSyncError_free(struct LDKGraphSyncError this_ptr);
36985 export function GraphSyncError_free(this_ptr: bigint): void {
36986 if(!isWasmInitialized) {
36987 throw new Error("initializeWasm() must be awaited first!");
36989 const nativeResponseValue = wasm.TS_GraphSyncError_free(this_ptr);
36990 // debug statements here
36992 // uint64_t GraphSyncError_clone_ptr(LDKGraphSyncError *NONNULL_PTR arg);
36994 export function GraphSyncError_clone_ptr(arg: bigint): bigint {
36995 if(!isWasmInitialized) {
36996 throw new Error("initializeWasm() must be awaited first!");
36998 const nativeResponseValue = wasm.TS_GraphSyncError_clone_ptr(arg);
36999 return nativeResponseValue;
37001 // struct LDKGraphSyncError GraphSyncError_clone(const struct LDKGraphSyncError *NONNULL_PTR orig);
37003 export function GraphSyncError_clone(orig: bigint): bigint {
37004 if(!isWasmInitialized) {
37005 throw new Error("initializeWasm() must be awaited first!");
37007 const nativeResponseValue = wasm.TS_GraphSyncError_clone(orig);
37008 return nativeResponseValue;
37010 // struct LDKGraphSyncError GraphSyncError_decode_error(struct LDKDecodeError a);
37012 export function GraphSyncError_decode_error(a: bigint): bigint {
37013 if(!isWasmInitialized) {
37014 throw new Error("initializeWasm() must be awaited first!");
37016 const nativeResponseValue = wasm.TS_GraphSyncError_decode_error(a);
37017 return nativeResponseValue;
37019 // struct LDKGraphSyncError GraphSyncError_lightning_error(struct LDKLightningError a);
37021 export function GraphSyncError_lightning_error(a: bigint): bigint {
37022 if(!isWasmInitialized) {
37023 throw new Error("initializeWasm() must be awaited first!");
37025 const nativeResponseValue = wasm.TS_GraphSyncError_lightning_error(a);
37026 return nativeResponseValue;
37028 // void ParseError_free(struct LDKParseError this_ptr);
37030 export function ParseError_free(this_ptr: bigint): void {
37031 if(!isWasmInitialized) {
37032 throw new Error("initializeWasm() must be awaited first!");
37034 const nativeResponseValue = wasm.TS_ParseError_free(this_ptr);
37035 // debug statements here
37037 // uint64_t ParseError_clone_ptr(LDKParseError *NONNULL_PTR arg);
37039 export function ParseError_clone_ptr(arg: bigint): bigint {
37040 if(!isWasmInitialized) {
37041 throw new Error("initializeWasm() must be awaited first!");
37043 const nativeResponseValue = wasm.TS_ParseError_clone_ptr(arg);
37044 return nativeResponseValue;
37046 // struct LDKParseError ParseError_clone(const struct LDKParseError *NONNULL_PTR orig);
37048 export function ParseError_clone(orig: bigint): bigint {
37049 if(!isWasmInitialized) {
37050 throw new Error("initializeWasm() must be awaited first!");
37052 const nativeResponseValue = wasm.TS_ParseError_clone(orig);
37053 return nativeResponseValue;
37055 // struct LDKParseError ParseError_bech32_error(struct LDKBech32Error a);
37057 export function ParseError_bech32_error(a: bigint): bigint {
37058 if(!isWasmInitialized) {
37059 throw new Error("initializeWasm() must be awaited first!");
37061 const nativeResponseValue = wasm.TS_ParseError_bech32_error(a);
37062 return nativeResponseValue;
37064 // struct LDKParseError ParseError_parse_amount_error(struct LDKError a);
37066 export function ParseError_parse_amount_error(a: number): bigint {
37067 if(!isWasmInitialized) {
37068 throw new Error("initializeWasm() must be awaited first!");
37070 const nativeResponseValue = wasm.TS_ParseError_parse_amount_error(a);
37071 return nativeResponseValue;
37073 // struct LDKParseError ParseError_malformed_signature(enum LDKSecp256k1Error a);
37075 export function ParseError_malformed_signature(a: Secp256k1Error): bigint {
37076 if(!isWasmInitialized) {
37077 throw new Error("initializeWasm() must be awaited first!");
37079 const nativeResponseValue = wasm.TS_ParseError_malformed_signature(a);
37080 return nativeResponseValue;
37082 // struct LDKParseError ParseError_bad_prefix(void);
37084 export function ParseError_bad_prefix(): bigint {
37085 if(!isWasmInitialized) {
37086 throw new Error("initializeWasm() must be awaited first!");
37088 const nativeResponseValue = wasm.TS_ParseError_bad_prefix();
37089 return nativeResponseValue;
37091 // struct LDKParseError ParseError_unknown_currency(void);
37093 export function ParseError_unknown_currency(): bigint {
37094 if(!isWasmInitialized) {
37095 throw new Error("initializeWasm() must be awaited first!");
37097 const nativeResponseValue = wasm.TS_ParseError_unknown_currency();
37098 return nativeResponseValue;
37100 // struct LDKParseError ParseError_unknown_si_prefix(void);
37102 export function ParseError_unknown_si_prefix(): bigint {
37103 if(!isWasmInitialized) {
37104 throw new Error("initializeWasm() must be awaited first!");
37106 const nativeResponseValue = wasm.TS_ParseError_unknown_si_prefix();
37107 return nativeResponseValue;
37109 // struct LDKParseError ParseError_malformed_hrp(void);
37111 export function ParseError_malformed_hrp(): bigint {
37112 if(!isWasmInitialized) {
37113 throw new Error("initializeWasm() must be awaited first!");
37115 const nativeResponseValue = wasm.TS_ParseError_malformed_hrp();
37116 return nativeResponseValue;
37118 // struct LDKParseError ParseError_too_short_data_part(void);
37120 export function ParseError_too_short_data_part(): bigint {
37121 if(!isWasmInitialized) {
37122 throw new Error("initializeWasm() must be awaited first!");
37124 const nativeResponseValue = wasm.TS_ParseError_too_short_data_part();
37125 return nativeResponseValue;
37127 // struct LDKParseError ParseError_unexpected_end_of_tagged_fields(void);
37129 export function ParseError_unexpected_end_of_tagged_fields(): bigint {
37130 if(!isWasmInitialized) {
37131 throw new Error("initializeWasm() must be awaited first!");
37133 const nativeResponseValue = wasm.TS_ParseError_unexpected_end_of_tagged_fields();
37134 return nativeResponseValue;
37136 // struct LDKParseError ParseError_description_decode_error(struct LDKError a);
37138 export function ParseError_description_decode_error(a: number): bigint {
37139 if(!isWasmInitialized) {
37140 throw new Error("initializeWasm() must be awaited first!");
37142 const nativeResponseValue = wasm.TS_ParseError_description_decode_error(a);
37143 return nativeResponseValue;
37145 // struct LDKParseError ParseError_padding_error(void);
37147 export function ParseError_padding_error(): bigint {
37148 if(!isWasmInitialized) {
37149 throw new Error("initializeWasm() must be awaited first!");
37151 const nativeResponseValue = wasm.TS_ParseError_padding_error();
37152 return nativeResponseValue;
37154 // struct LDKParseError ParseError_integer_overflow_error(void);
37156 export function ParseError_integer_overflow_error(): bigint {
37157 if(!isWasmInitialized) {
37158 throw new Error("initializeWasm() must be awaited first!");
37160 const nativeResponseValue = wasm.TS_ParseError_integer_overflow_error();
37161 return nativeResponseValue;
37163 // struct LDKParseError ParseError_invalid_seg_wit_program_length(void);
37165 export function ParseError_invalid_seg_wit_program_length(): bigint {
37166 if(!isWasmInitialized) {
37167 throw new Error("initializeWasm() must be awaited first!");
37169 const nativeResponseValue = wasm.TS_ParseError_invalid_seg_wit_program_length();
37170 return nativeResponseValue;
37172 // struct LDKParseError ParseError_invalid_pub_key_hash_length(void);
37174 export function ParseError_invalid_pub_key_hash_length(): bigint {
37175 if(!isWasmInitialized) {
37176 throw new Error("initializeWasm() must be awaited first!");
37178 const nativeResponseValue = wasm.TS_ParseError_invalid_pub_key_hash_length();
37179 return nativeResponseValue;
37181 // struct LDKParseError ParseError_invalid_script_hash_length(void);
37183 export function ParseError_invalid_script_hash_length(): bigint {
37184 if(!isWasmInitialized) {
37185 throw new Error("initializeWasm() must be awaited first!");
37187 const nativeResponseValue = wasm.TS_ParseError_invalid_script_hash_length();
37188 return nativeResponseValue;
37190 // struct LDKParseError ParseError_invalid_recovery_id(void);
37192 export function ParseError_invalid_recovery_id(): bigint {
37193 if(!isWasmInitialized) {
37194 throw new Error("initializeWasm() must be awaited first!");
37196 const nativeResponseValue = wasm.TS_ParseError_invalid_recovery_id();
37197 return nativeResponseValue;
37199 // struct LDKParseError ParseError_invalid_slice_length(struct LDKStr a);
37201 export function ParseError_invalid_slice_length(a: number): bigint {
37202 if(!isWasmInitialized) {
37203 throw new Error("initializeWasm() must be awaited first!");
37205 const nativeResponseValue = wasm.TS_ParseError_invalid_slice_length(a);
37206 return nativeResponseValue;
37208 // struct LDKParseError ParseError_skip(void);
37210 export function ParseError_skip(): bigint {
37211 if(!isWasmInitialized) {
37212 throw new Error("initializeWasm() must be awaited first!");
37214 const nativeResponseValue = wasm.TS_ParseError_skip();
37215 return nativeResponseValue;
37217 // bool ParseError_eq(const struct LDKParseError *NONNULL_PTR a, const struct LDKParseError *NONNULL_PTR b);
37219 export function ParseError_eq(a: bigint, b: bigint): boolean {
37220 if(!isWasmInitialized) {
37221 throw new Error("initializeWasm() must be awaited first!");
37223 const nativeResponseValue = wasm.TS_ParseError_eq(a, b);
37224 return nativeResponseValue;
37226 // void ParseOrSemanticError_free(struct LDKParseOrSemanticError this_ptr);
37228 export function ParseOrSemanticError_free(this_ptr: bigint): void {
37229 if(!isWasmInitialized) {
37230 throw new Error("initializeWasm() must be awaited first!");
37232 const nativeResponseValue = wasm.TS_ParseOrSemanticError_free(this_ptr);
37233 // debug statements here
37235 // uint64_t ParseOrSemanticError_clone_ptr(LDKParseOrSemanticError *NONNULL_PTR arg);
37237 export function ParseOrSemanticError_clone_ptr(arg: bigint): bigint {
37238 if(!isWasmInitialized) {
37239 throw new Error("initializeWasm() must be awaited first!");
37241 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone_ptr(arg);
37242 return nativeResponseValue;
37244 // struct LDKParseOrSemanticError ParseOrSemanticError_clone(const struct LDKParseOrSemanticError *NONNULL_PTR orig);
37246 export function ParseOrSemanticError_clone(orig: bigint): bigint {
37247 if(!isWasmInitialized) {
37248 throw new Error("initializeWasm() must be awaited first!");
37250 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone(orig);
37251 return nativeResponseValue;
37253 // struct LDKParseOrSemanticError ParseOrSemanticError_parse_error(struct LDKParseError a);
37255 export function ParseOrSemanticError_parse_error(a: bigint): bigint {
37256 if(!isWasmInitialized) {
37257 throw new Error("initializeWasm() must be awaited first!");
37259 const nativeResponseValue = wasm.TS_ParseOrSemanticError_parse_error(a);
37260 return nativeResponseValue;
37262 // struct LDKParseOrSemanticError ParseOrSemanticError_semantic_error(enum LDKSemanticError a);
37264 export function ParseOrSemanticError_semantic_error(a: SemanticError): bigint {
37265 if(!isWasmInitialized) {
37266 throw new Error("initializeWasm() must be awaited first!");
37268 const nativeResponseValue = wasm.TS_ParseOrSemanticError_semantic_error(a);
37269 return nativeResponseValue;
37271 // bool ParseOrSemanticError_eq(const struct LDKParseOrSemanticError *NONNULL_PTR a, const struct LDKParseOrSemanticError *NONNULL_PTR b);
37273 export function ParseOrSemanticError_eq(a: bigint, b: bigint): boolean {
37274 if(!isWasmInitialized) {
37275 throw new Error("initializeWasm() must be awaited first!");
37277 const nativeResponseValue = wasm.TS_ParseOrSemanticError_eq(a, b);
37278 return nativeResponseValue;
37280 // void Invoice_free(struct LDKInvoice this_obj);
37282 export function Invoice_free(this_obj: bigint): void {
37283 if(!isWasmInitialized) {
37284 throw new Error("initializeWasm() must be awaited first!");
37286 const nativeResponseValue = wasm.TS_Invoice_free(this_obj);
37287 // debug statements here
37289 // bool Invoice_eq(const struct LDKInvoice *NONNULL_PTR a, const struct LDKInvoice *NONNULL_PTR b);
37291 export function Invoice_eq(a: bigint, b: bigint): boolean {
37292 if(!isWasmInitialized) {
37293 throw new Error("initializeWasm() must be awaited first!");
37295 const nativeResponseValue = wasm.TS_Invoice_eq(a, b);
37296 return nativeResponseValue;
37298 // uint64_t Invoice_clone_ptr(LDKInvoice *NONNULL_PTR arg);
37300 export function Invoice_clone_ptr(arg: bigint): bigint {
37301 if(!isWasmInitialized) {
37302 throw new Error("initializeWasm() must be awaited first!");
37304 const nativeResponseValue = wasm.TS_Invoice_clone_ptr(arg);
37305 return nativeResponseValue;
37307 // struct LDKInvoice Invoice_clone(const struct LDKInvoice *NONNULL_PTR orig);
37309 export function Invoice_clone(orig: bigint): bigint {
37310 if(!isWasmInitialized) {
37311 throw new Error("initializeWasm() must be awaited first!");
37313 const nativeResponseValue = wasm.TS_Invoice_clone(orig);
37314 return nativeResponseValue;
37316 // uint64_t Invoice_hash(const struct LDKInvoice *NONNULL_PTR o);
37318 export function Invoice_hash(o: bigint): bigint {
37319 if(!isWasmInitialized) {
37320 throw new Error("initializeWasm() must be awaited first!");
37322 const nativeResponseValue = wasm.TS_Invoice_hash(o);
37323 return nativeResponseValue;
37325 // void SignedRawInvoice_free(struct LDKSignedRawInvoice this_obj);
37327 export function SignedRawInvoice_free(this_obj: bigint): void {
37328 if(!isWasmInitialized) {
37329 throw new Error("initializeWasm() must be awaited first!");
37331 const nativeResponseValue = wasm.TS_SignedRawInvoice_free(this_obj);
37332 // debug statements here
37334 // bool SignedRawInvoice_eq(const struct LDKSignedRawInvoice *NONNULL_PTR a, const struct LDKSignedRawInvoice *NONNULL_PTR b);
37336 export function SignedRawInvoice_eq(a: bigint, b: bigint): boolean {
37337 if(!isWasmInitialized) {
37338 throw new Error("initializeWasm() must be awaited first!");
37340 const nativeResponseValue = wasm.TS_SignedRawInvoice_eq(a, b);
37341 return nativeResponseValue;
37343 // uint64_t SignedRawInvoice_clone_ptr(LDKSignedRawInvoice *NONNULL_PTR arg);
37345 export function SignedRawInvoice_clone_ptr(arg: bigint): bigint {
37346 if(!isWasmInitialized) {
37347 throw new Error("initializeWasm() must be awaited first!");
37349 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone_ptr(arg);
37350 return nativeResponseValue;
37352 // struct LDKSignedRawInvoice SignedRawInvoice_clone(const struct LDKSignedRawInvoice *NONNULL_PTR orig);
37354 export function SignedRawInvoice_clone(orig: bigint): bigint {
37355 if(!isWasmInitialized) {
37356 throw new Error("initializeWasm() must be awaited first!");
37358 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone(orig);
37359 return nativeResponseValue;
37361 // uint64_t SignedRawInvoice_hash(const struct LDKSignedRawInvoice *NONNULL_PTR o);
37363 export function SignedRawInvoice_hash(o: bigint): bigint {
37364 if(!isWasmInitialized) {
37365 throw new Error("initializeWasm() must be awaited first!");
37367 const nativeResponseValue = wasm.TS_SignedRawInvoice_hash(o);
37368 return nativeResponseValue;
37370 // void RawInvoice_free(struct LDKRawInvoice this_obj);
37372 export function RawInvoice_free(this_obj: bigint): void {
37373 if(!isWasmInitialized) {
37374 throw new Error("initializeWasm() must be awaited first!");
37376 const nativeResponseValue = wasm.TS_RawInvoice_free(this_obj);
37377 // debug statements here
37379 // struct LDKRawDataPart RawInvoice_get_data(const struct LDKRawInvoice *NONNULL_PTR this_ptr);
37381 export function RawInvoice_get_data(this_ptr: bigint): bigint {
37382 if(!isWasmInitialized) {
37383 throw new Error("initializeWasm() must be awaited first!");
37385 const nativeResponseValue = wasm.TS_RawInvoice_get_data(this_ptr);
37386 return nativeResponseValue;
37388 // void RawInvoice_set_data(struct LDKRawInvoice *NONNULL_PTR this_ptr, struct LDKRawDataPart val);
37390 export function RawInvoice_set_data(this_ptr: bigint, val: bigint): void {
37391 if(!isWasmInitialized) {
37392 throw new Error("initializeWasm() must be awaited first!");
37394 const nativeResponseValue = wasm.TS_RawInvoice_set_data(this_ptr, val);
37395 // debug statements here
37397 // bool RawInvoice_eq(const struct LDKRawInvoice *NONNULL_PTR a, const struct LDKRawInvoice *NONNULL_PTR b);
37399 export function RawInvoice_eq(a: bigint, b: bigint): boolean {
37400 if(!isWasmInitialized) {
37401 throw new Error("initializeWasm() must be awaited first!");
37403 const nativeResponseValue = wasm.TS_RawInvoice_eq(a, b);
37404 return nativeResponseValue;
37406 // uint64_t RawInvoice_clone_ptr(LDKRawInvoice *NONNULL_PTR arg);
37408 export function RawInvoice_clone_ptr(arg: bigint): bigint {
37409 if(!isWasmInitialized) {
37410 throw new Error("initializeWasm() must be awaited first!");
37412 const nativeResponseValue = wasm.TS_RawInvoice_clone_ptr(arg);
37413 return nativeResponseValue;
37415 // struct LDKRawInvoice RawInvoice_clone(const struct LDKRawInvoice *NONNULL_PTR orig);
37417 export function RawInvoice_clone(orig: bigint): bigint {
37418 if(!isWasmInitialized) {
37419 throw new Error("initializeWasm() must be awaited first!");
37421 const nativeResponseValue = wasm.TS_RawInvoice_clone(orig);
37422 return nativeResponseValue;
37424 // uint64_t RawInvoice_hash(const struct LDKRawInvoice *NONNULL_PTR o);
37426 export function RawInvoice_hash(o: bigint): bigint {
37427 if(!isWasmInitialized) {
37428 throw new Error("initializeWasm() must be awaited first!");
37430 const nativeResponseValue = wasm.TS_RawInvoice_hash(o);
37431 return nativeResponseValue;
37433 // void RawDataPart_free(struct LDKRawDataPart this_obj);
37435 export function RawDataPart_free(this_obj: bigint): void {
37436 if(!isWasmInitialized) {
37437 throw new Error("initializeWasm() must be awaited first!");
37439 const nativeResponseValue = wasm.TS_RawDataPart_free(this_obj);
37440 // debug statements here
37442 // struct LDKPositiveTimestamp RawDataPart_get_timestamp(const struct LDKRawDataPart *NONNULL_PTR this_ptr);
37444 export function RawDataPart_get_timestamp(this_ptr: bigint): bigint {
37445 if(!isWasmInitialized) {
37446 throw new Error("initializeWasm() must be awaited first!");
37448 const nativeResponseValue = wasm.TS_RawDataPart_get_timestamp(this_ptr);
37449 return nativeResponseValue;
37451 // void RawDataPart_set_timestamp(struct LDKRawDataPart *NONNULL_PTR this_ptr, struct LDKPositiveTimestamp val);
37453 export function RawDataPart_set_timestamp(this_ptr: bigint, val: bigint): void {
37454 if(!isWasmInitialized) {
37455 throw new Error("initializeWasm() must be awaited first!");
37457 const nativeResponseValue = wasm.TS_RawDataPart_set_timestamp(this_ptr, val);
37458 // debug statements here
37460 // bool RawDataPart_eq(const struct LDKRawDataPart *NONNULL_PTR a, const struct LDKRawDataPart *NONNULL_PTR b);
37462 export function RawDataPart_eq(a: bigint, b: bigint): boolean {
37463 if(!isWasmInitialized) {
37464 throw new Error("initializeWasm() must be awaited first!");
37466 const nativeResponseValue = wasm.TS_RawDataPart_eq(a, b);
37467 return nativeResponseValue;
37469 // uint64_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg);
37471 export function RawDataPart_clone_ptr(arg: bigint): bigint {
37472 if(!isWasmInitialized) {
37473 throw new Error("initializeWasm() must be awaited first!");
37475 const nativeResponseValue = wasm.TS_RawDataPart_clone_ptr(arg);
37476 return nativeResponseValue;
37478 // struct LDKRawDataPart RawDataPart_clone(const struct LDKRawDataPart *NONNULL_PTR orig);
37480 export function RawDataPart_clone(orig: bigint): bigint {
37481 if(!isWasmInitialized) {
37482 throw new Error("initializeWasm() must be awaited first!");
37484 const nativeResponseValue = wasm.TS_RawDataPart_clone(orig);
37485 return nativeResponseValue;
37487 // uint64_t RawDataPart_hash(const struct LDKRawDataPart *NONNULL_PTR o);
37489 export function RawDataPart_hash(o: bigint): bigint {
37490 if(!isWasmInitialized) {
37491 throw new Error("initializeWasm() must be awaited first!");
37493 const nativeResponseValue = wasm.TS_RawDataPart_hash(o);
37494 return nativeResponseValue;
37496 // void PositiveTimestamp_free(struct LDKPositiveTimestamp this_obj);
37498 export function PositiveTimestamp_free(this_obj: bigint): void {
37499 if(!isWasmInitialized) {
37500 throw new Error("initializeWasm() must be awaited first!");
37502 const nativeResponseValue = wasm.TS_PositiveTimestamp_free(this_obj);
37503 // debug statements here
37505 // bool PositiveTimestamp_eq(const struct LDKPositiveTimestamp *NONNULL_PTR a, const struct LDKPositiveTimestamp *NONNULL_PTR b);
37507 export function PositiveTimestamp_eq(a: bigint, b: bigint): boolean {
37508 if(!isWasmInitialized) {
37509 throw new Error("initializeWasm() must be awaited first!");
37511 const nativeResponseValue = wasm.TS_PositiveTimestamp_eq(a, b);
37512 return nativeResponseValue;
37514 // uint64_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg);
37516 export function PositiveTimestamp_clone_ptr(arg: bigint): bigint {
37517 if(!isWasmInitialized) {
37518 throw new Error("initializeWasm() must be awaited first!");
37520 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone_ptr(arg);
37521 return nativeResponseValue;
37523 // struct LDKPositiveTimestamp PositiveTimestamp_clone(const struct LDKPositiveTimestamp *NONNULL_PTR orig);
37525 export function PositiveTimestamp_clone(orig: bigint): bigint {
37526 if(!isWasmInitialized) {
37527 throw new Error("initializeWasm() must be awaited first!");
37529 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone(orig);
37530 return nativeResponseValue;
37532 // uint64_t PositiveTimestamp_hash(const struct LDKPositiveTimestamp *NONNULL_PTR o);
37534 export function PositiveTimestamp_hash(o: bigint): bigint {
37535 if(!isWasmInitialized) {
37536 throw new Error("initializeWasm() must be awaited first!");
37538 const nativeResponseValue = wasm.TS_PositiveTimestamp_hash(o);
37539 return nativeResponseValue;
37541 // enum LDKSiPrefix SiPrefix_clone(const enum LDKSiPrefix *NONNULL_PTR orig);
37543 export function SiPrefix_clone(orig: bigint): SiPrefix {
37544 if(!isWasmInitialized) {
37545 throw new Error("initializeWasm() must be awaited first!");
37547 const nativeResponseValue = wasm.TS_SiPrefix_clone(orig);
37548 return nativeResponseValue;
37550 // enum LDKSiPrefix SiPrefix_milli(void);
37552 export function SiPrefix_milli(): SiPrefix {
37553 if(!isWasmInitialized) {
37554 throw new Error("initializeWasm() must be awaited first!");
37556 const nativeResponseValue = wasm.TS_SiPrefix_milli();
37557 return nativeResponseValue;
37559 // enum LDKSiPrefix SiPrefix_micro(void);
37561 export function SiPrefix_micro(): SiPrefix {
37562 if(!isWasmInitialized) {
37563 throw new Error("initializeWasm() must be awaited first!");
37565 const nativeResponseValue = wasm.TS_SiPrefix_micro();
37566 return nativeResponseValue;
37568 // enum LDKSiPrefix SiPrefix_nano(void);
37570 export function SiPrefix_nano(): SiPrefix {
37571 if(!isWasmInitialized) {
37572 throw new Error("initializeWasm() must be awaited first!");
37574 const nativeResponseValue = wasm.TS_SiPrefix_nano();
37575 return nativeResponseValue;
37577 // enum LDKSiPrefix SiPrefix_pico(void);
37579 export function SiPrefix_pico(): SiPrefix {
37580 if(!isWasmInitialized) {
37581 throw new Error("initializeWasm() must be awaited first!");
37583 const nativeResponseValue = wasm.TS_SiPrefix_pico();
37584 return nativeResponseValue;
37586 // bool SiPrefix_eq(const enum LDKSiPrefix *NONNULL_PTR a, const enum LDKSiPrefix *NONNULL_PTR b);
37588 export function SiPrefix_eq(a: bigint, b: bigint): boolean {
37589 if(!isWasmInitialized) {
37590 throw new Error("initializeWasm() must be awaited first!");
37592 const nativeResponseValue = wasm.TS_SiPrefix_eq(a, b);
37593 return nativeResponseValue;
37595 // uint64_t SiPrefix_hash(const enum LDKSiPrefix *NONNULL_PTR o);
37597 export function SiPrefix_hash(o: bigint): bigint {
37598 if(!isWasmInitialized) {
37599 throw new Error("initializeWasm() must be awaited first!");
37601 const nativeResponseValue = wasm.TS_SiPrefix_hash(o);
37602 return nativeResponseValue;
37604 // MUST_USE_RES uint64_t SiPrefix_multiplier(const enum LDKSiPrefix *NONNULL_PTR this_arg);
37606 export function SiPrefix_multiplier(this_arg: bigint): bigint {
37607 if(!isWasmInitialized) {
37608 throw new Error("initializeWasm() must be awaited first!");
37610 const nativeResponseValue = wasm.TS_SiPrefix_multiplier(this_arg);
37611 return nativeResponseValue;
37613 // enum LDKCurrency Currency_clone(const enum LDKCurrency *NONNULL_PTR orig);
37615 export function Currency_clone(orig: bigint): Currency {
37616 if(!isWasmInitialized) {
37617 throw new Error("initializeWasm() must be awaited first!");
37619 const nativeResponseValue = wasm.TS_Currency_clone(orig);
37620 return nativeResponseValue;
37622 // enum LDKCurrency Currency_bitcoin(void);
37624 export function Currency_bitcoin(): Currency {
37625 if(!isWasmInitialized) {
37626 throw new Error("initializeWasm() must be awaited first!");
37628 const nativeResponseValue = wasm.TS_Currency_bitcoin();
37629 return nativeResponseValue;
37631 // enum LDKCurrency Currency_bitcoin_testnet(void);
37633 export function Currency_bitcoin_testnet(): Currency {
37634 if(!isWasmInitialized) {
37635 throw new Error("initializeWasm() must be awaited first!");
37637 const nativeResponseValue = wasm.TS_Currency_bitcoin_testnet();
37638 return nativeResponseValue;
37640 // enum LDKCurrency Currency_regtest(void);
37642 export function Currency_regtest(): Currency {
37643 if(!isWasmInitialized) {
37644 throw new Error("initializeWasm() must be awaited first!");
37646 const nativeResponseValue = wasm.TS_Currency_regtest();
37647 return nativeResponseValue;
37649 // enum LDKCurrency Currency_simnet(void);
37651 export function Currency_simnet(): Currency {
37652 if(!isWasmInitialized) {
37653 throw new Error("initializeWasm() must be awaited first!");
37655 const nativeResponseValue = wasm.TS_Currency_simnet();
37656 return nativeResponseValue;
37658 // enum LDKCurrency Currency_signet(void);
37660 export function Currency_signet(): Currency {
37661 if(!isWasmInitialized) {
37662 throw new Error("initializeWasm() must be awaited first!");
37664 const nativeResponseValue = wasm.TS_Currency_signet();
37665 return nativeResponseValue;
37667 // uint64_t Currency_hash(const enum LDKCurrency *NONNULL_PTR o);
37669 export function Currency_hash(o: bigint): bigint {
37670 if(!isWasmInitialized) {
37671 throw new Error("initializeWasm() must be awaited first!");
37673 const nativeResponseValue = wasm.TS_Currency_hash(o);
37674 return nativeResponseValue;
37676 // bool Currency_eq(const enum LDKCurrency *NONNULL_PTR a, const enum LDKCurrency *NONNULL_PTR b);
37678 export function Currency_eq(a: bigint, b: bigint): boolean {
37679 if(!isWasmInitialized) {
37680 throw new Error("initializeWasm() must be awaited first!");
37682 const nativeResponseValue = wasm.TS_Currency_eq(a, b);
37683 return nativeResponseValue;
37685 // void Sha256_free(struct LDKSha256 this_obj);
37687 export function Sha256_free(this_obj: bigint): void {
37688 if(!isWasmInitialized) {
37689 throw new Error("initializeWasm() must be awaited first!");
37691 const nativeResponseValue = wasm.TS_Sha256_free(this_obj);
37692 // debug statements here
37694 // uint64_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg);
37696 export function Sha256_clone_ptr(arg: bigint): bigint {
37697 if(!isWasmInitialized) {
37698 throw new Error("initializeWasm() must be awaited first!");
37700 const nativeResponseValue = wasm.TS_Sha256_clone_ptr(arg);
37701 return nativeResponseValue;
37703 // struct LDKSha256 Sha256_clone(const struct LDKSha256 *NONNULL_PTR orig);
37705 export function Sha256_clone(orig: bigint): bigint {
37706 if(!isWasmInitialized) {
37707 throw new Error("initializeWasm() must be awaited first!");
37709 const nativeResponseValue = wasm.TS_Sha256_clone(orig);
37710 return nativeResponseValue;
37712 // uint64_t Sha256_hash(const struct LDKSha256 *NONNULL_PTR o);
37714 export function Sha256_hash(o: bigint): bigint {
37715 if(!isWasmInitialized) {
37716 throw new Error("initializeWasm() must be awaited first!");
37718 const nativeResponseValue = wasm.TS_Sha256_hash(o);
37719 return nativeResponseValue;
37721 // bool Sha256_eq(const struct LDKSha256 *NONNULL_PTR a, const struct LDKSha256 *NONNULL_PTR b);
37723 export function Sha256_eq(a: bigint, b: bigint): boolean {
37724 if(!isWasmInitialized) {
37725 throw new Error("initializeWasm() must be awaited first!");
37727 const nativeResponseValue = wasm.TS_Sha256_eq(a, b);
37728 return nativeResponseValue;
37730 // void Description_free(struct LDKDescription this_obj);
37732 export function Description_free(this_obj: bigint): void {
37733 if(!isWasmInitialized) {
37734 throw new Error("initializeWasm() must be awaited first!");
37736 const nativeResponseValue = wasm.TS_Description_free(this_obj);
37737 // debug statements here
37739 // uint64_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg);
37741 export function Description_clone_ptr(arg: bigint): bigint {
37742 if(!isWasmInitialized) {
37743 throw new Error("initializeWasm() must be awaited first!");
37745 const nativeResponseValue = wasm.TS_Description_clone_ptr(arg);
37746 return nativeResponseValue;
37748 // struct LDKDescription Description_clone(const struct LDKDescription *NONNULL_PTR orig);
37750 export function Description_clone(orig: bigint): bigint {
37751 if(!isWasmInitialized) {
37752 throw new Error("initializeWasm() must be awaited first!");
37754 const nativeResponseValue = wasm.TS_Description_clone(orig);
37755 return nativeResponseValue;
37757 // uint64_t Description_hash(const struct LDKDescription *NONNULL_PTR o);
37759 export function Description_hash(o: bigint): bigint {
37760 if(!isWasmInitialized) {
37761 throw new Error("initializeWasm() must be awaited first!");
37763 const nativeResponseValue = wasm.TS_Description_hash(o);
37764 return nativeResponseValue;
37766 // bool Description_eq(const struct LDKDescription *NONNULL_PTR a, const struct LDKDescription *NONNULL_PTR b);
37768 export function Description_eq(a: bigint, b: bigint): boolean {
37769 if(!isWasmInitialized) {
37770 throw new Error("initializeWasm() must be awaited first!");
37772 const nativeResponseValue = wasm.TS_Description_eq(a, b);
37773 return nativeResponseValue;
37775 // void PayeePubKey_free(struct LDKPayeePubKey this_obj);
37777 export function PayeePubKey_free(this_obj: bigint): void {
37778 if(!isWasmInitialized) {
37779 throw new Error("initializeWasm() must be awaited first!");
37781 const nativeResponseValue = wasm.TS_PayeePubKey_free(this_obj);
37782 // debug statements here
37784 // struct LDKPublicKey PayeePubKey_get_a(const struct LDKPayeePubKey *NONNULL_PTR this_ptr);
37786 export function PayeePubKey_get_a(this_ptr: bigint): number {
37787 if(!isWasmInitialized) {
37788 throw new Error("initializeWasm() must be awaited first!");
37790 const nativeResponseValue = wasm.TS_PayeePubKey_get_a(this_ptr);
37791 return nativeResponseValue;
37793 // void PayeePubKey_set_a(struct LDKPayeePubKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
37795 export function PayeePubKey_set_a(this_ptr: bigint, val: number): void {
37796 if(!isWasmInitialized) {
37797 throw new Error("initializeWasm() must be awaited first!");
37799 const nativeResponseValue = wasm.TS_PayeePubKey_set_a(this_ptr, val);
37800 // debug statements here
37802 // MUST_USE_RES struct LDKPayeePubKey PayeePubKey_new(struct LDKPublicKey a_arg);
37804 export function PayeePubKey_new(a_arg: number): bigint {
37805 if(!isWasmInitialized) {
37806 throw new Error("initializeWasm() must be awaited first!");
37808 const nativeResponseValue = wasm.TS_PayeePubKey_new(a_arg);
37809 return nativeResponseValue;
37811 // uint64_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg);
37813 export function PayeePubKey_clone_ptr(arg: bigint): bigint {
37814 if(!isWasmInitialized) {
37815 throw new Error("initializeWasm() must be awaited first!");
37817 const nativeResponseValue = wasm.TS_PayeePubKey_clone_ptr(arg);
37818 return nativeResponseValue;
37820 // struct LDKPayeePubKey PayeePubKey_clone(const struct LDKPayeePubKey *NONNULL_PTR orig);
37822 export function PayeePubKey_clone(orig: bigint): bigint {
37823 if(!isWasmInitialized) {
37824 throw new Error("initializeWasm() must be awaited first!");
37826 const nativeResponseValue = wasm.TS_PayeePubKey_clone(orig);
37827 return nativeResponseValue;
37829 // uint64_t PayeePubKey_hash(const struct LDKPayeePubKey *NONNULL_PTR o);
37831 export function PayeePubKey_hash(o: bigint): bigint {
37832 if(!isWasmInitialized) {
37833 throw new Error("initializeWasm() must be awaited first!");
37835 const nativeResponseValue = wasm.TS_PayeePubKey_hash(o);
37836 return nativeResponseValue;
37838 // bool PayeePubKey_eq(const struct LDKPayeePubKey *NONNULL_PTR a, const struct LDKPayeePubKey *NONNULL_PTR b);
37840 export function PayeePubKey_eq(a: bigint, b: bigint): boolean {
37841 if(!isWasmInitialized) {
37842 throw new Error("initializeWasm() must be awaited first!");
37844 const nativeResponseValue = wasm.TS_PayeePubKey_eq(a, b);
37845 return nativeResponseValue;
37847 // void ExpiryTime_free(struct LDKExpiryTime this_obj);
37849 export function ExpiryTime_free(this_obj: bigint): void {
37850 if(!isWasmInitialized) {
37851 throw new Error("initializeWasm() must be awaited first!");
37853 const nativeResponseValue = wasm.TS_ExpiryTime_free(this_obj);
37854 // debug statements here
37856 // uint64_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg);
37858 export function ExpiryTime_clone_ptr(arg: bigint): bigint {
37859 if(!isWasmInitialized) {
37860 throw new Error("initializeWasm() must be awaited first!");
37862 const nativeResponseValue = wasm.TS_ExpiryTime_clone_ptr(arg);
37863 return nativeResponseValue;
37865 // struct LDKExpiryTime ExpiryTime_clone(const struct LDKExpiryTime *NONNULL_PTR orig);
37867 export function ExpiryTime_clone(orig: bigint): bigint {
37868 if(!isWasmInitialized) {
37869 throw new Error("initializeWasm() must be awaited first!");
37871 const nativeResponseValue = wasm.TS_ExpiryTime_clone(orig);
37872 return nativeResponseValue;
37874 // uint64_t ExpiryTime_hash(const struct LDKExpiryTime *NONNULL_PTR o);
37876 export function ExpiryTime_hash(o: bigint): bigint {
37877 if(!isWasmInitialized) {
37878 throw new Error("initializeWasm() must be awaited first!");
37880 const nativeResponseValue = wasm.TS_ExpiryTime_hash(o);
37881 return nativeResponseValue;
37883 // bool ExpiryTime_eq(const struct LDKExpiryTime *NONNULL_PTR a, const struct LDKExpiryTime *NONNULL_PTR b);
37885 export function ExpiryTime_eq(a: bigint, b: bigint): boolean {
37886 if(!isWasmInitialized) {
37887 throw new Error("initializeWasm() must be awaited first!");
37889 const nativeResponseValue = wasm.TS_ExpiryTime_eq(a, b);
37890 return nativeResponseValue;
37892 // void MinFinalCltvExpiryDelta_free(struct LDKMinFinalCltvExpiryDelta this_obj);
37894 export function MinFinalCltvExpiryDelta_free(this_obj: bigint): void {
37895 if(!isWasmInitialized) {
37896 throw new Error("initializeWasm() must be awaited first!");
37898 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_free(this_obj);
37899 // debug statements here
37901 // uint64_t MinFinalCltvExpiryDelta_get_a(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR this_ptr);
37903 export function MinFinalCltvExpiryDelta_get_a(this_ptr: bigint): bigint {
37904 if(!isWasmInitialized) {
37905 throw new Error("initializeWasm() must be awaited first!");
37907 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_get_a(this_ptr);
37908 return nativeResponseValue;
37910 // void MinFinalCltvExpiryDelta_set_a(struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR this_ptr, uint64_t val);
37912 export function MinFinalCltvExpiryDelta_set_a(this_ptr: bigint, val: bigint): void {
37913 if(!isWasmInitialized) {
37914 throw new Error("initializeWasm() must be awaited first!");
37916 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_set_a(this_ptr, val);
37917 // debug statements here
37919 // MUST_USE_RES struct LDKMinFinalCltvExpiryDelta MinFinalCltvExpiryDelta_new(uint64_t a_arg);
37921 export function MinFinalCltvExpiryDelta_new(a_arg: bigint): bigint {
37922 if(!isWasmInitialized) {
37923 throw new Error("initializeWasm() must be awaited first!");
37925 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_new(a_arg);
37926 return nativeResponseValue;
37928 // uint64_t MinFinalCltvExpiryDelta_clone_ptr(LDKMinFinalCltvExpiryDelta *NONNULL_PTR arg);
37930 export function MinFinalCltvExpiryDelta_clone_ptr(arg: bigint): bigint {
37931 if(!isWasmInitialized) {
37932 throw new Error("initializeWasm() must be awaited first!");
37934 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_clone_ptr(arg);
37935 return nativeResponseValue;
37937 // struct LDKMinFinalCltvExpiryDelta MinFinalCltvExpiryDelta_clone(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR orig);
37939 export function MinFinalCltvExpiryDelta_clone(orig: bigint): bigint {
37940 if(!isWasmInitialized) {
37941 throw new Error("initializeWasm() must be awaited first!");
37943 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_clone(orig);
37944 return nativeResponseValue;
37946 // uint64_t MinFinalCltvExpiryDelta_hash(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR o);
37948 export function MinFinalCltvExpiryDelta_hash(o: bigint): bigint {
37949 if(!isWasmInitialized) {
37950 throw new Error("initializeWasm() must be awaited first!");
37952 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_hash(o);
37953 return nativeResponseValue;
37955 // bool MinFinalCltvExpiryDelta_eq(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR a, const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR b);
37957 export function MinFinalCltvExpiryDelta_eq(a: bigint, b: bigint): boolean {
37958 if(!isWasmInitialized) {
37959 throw new Error("initializeWasm() must be awaited first!");
37961 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_eq(a, b);
37962 return nativeResponseValue;
37964 // void Fallback_free(struct LDKFallback this_ptr);
37966 export function Fallback_free(this_ptr: bigint): void {
37967 if(!isWasmInitialized) {
37968 throw new Error("initializeWasm() must be awaited first!");
37970 const nativeResponseValue = wasm.TS_Fallback_free(this_ptr);
37971 // debug statements here
37973 // uint64_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg);
37975 export function Fallback_clone_ptr(arg: bigint): bigint {
37976 if(!isWasmInitialized) {
37977 throw new Error("initializeWasm() must be awaited first!");
37979 const nativeResponseValue = wasm.TS_Fallback_clone_ptr(arg);
37980 return nativeResponseValue;
37982 // struct LDKFallback Fallback_clone(const struct LDKFallback *NONNULL_PTR orig);
37984 export function Fallback_clone(orig: bigint): bigint {
37985 if(!isWasmInitialized) {
37986 throw new Error("initializeWasm() must be awaited first!");
37988 const nativeResponseValue = wasm.TS_Fallback_clone(orig);
37989 return nativeResponseValue;
37991 // struct LDKFallback Fallback_seg_wit_program(struct LDKU5 version, struct LDKCVec_u8Z program);
37993 export function Fallback_seg_wit_program(version: number, program: number): bigint {
37994 if(!isWasmInitialized) {
37995 throw new Error("initializeWasm() must be awaited first!");
37997 const nativeResponseValue = wasm.TS_Fallback_seg_wit_program(version, program);
37998 return nativeResponseValue;
38000 // struct LDKFallback Fallback_pub_key_hash(struct LDKTwentyBytes a);
38002 export function Fallback_pub_key_hash(a: number): bigint {
38003 if(!isWasmInitialized) {
38004 throw new Error("initializeWasm() must be awaited first!");
38006 const nativeResponseValue = wasm.TS_Fallback_pub_key_hash(a);
38007 return nativeResponseValue;
38009 // struct LDKFallback Fallback_script_hash(struct LDKTwentyBytes a);
38011 export function Fallback_script_hash(a: number): bigint {
38012 if(!isWasmInitialized) {
38013 throw new Error("initializeWasm() must be awaited first!");
38015 const nativeResponseValue = wasm.TS_Fallback_script_hash(a);
38016 return nativeResponseValue;
38018 // uint64_t Fallback_hash(const struct LDKFallback *NONNULL_PTR o);
38020 export function Fallback_hash(o: bigint): bigint {
38021 if(!isWasmInitialized) {
38022 throw new Error("initializeWasm() must be awaited first!");
38024 const nativeResponseValue = wasm.TS_Fallback_hash(o);
38025 return nativeResponseValue;
38027 // bool Fallback_eq(const struct LDKFallback *NONNULL_PTR a, const struct LDKFallback *NONNULL_PTR b);
38029 export function Fallback_eq(a: bigint, b: bigint): boolean {
38030 if(!isWasmInitialized) {
38031 throw new Error("initializeWasm() must be awaited first!");
38033 const nativeResponseValue = wasm.TS_Fallback_eq(a, b);
38034 return nativeResponseValue;
38036 // void InvoiceSignature_free(struct LDKInvoiceSignature this_obj);
38038 export function InvoiceSignature_free(this_obj: bigint): void {
38039 if(!isWasmInitialized) {
38040 throw new Error("initializeWasm() must be awaited first!");
38042 const nativeResponseValue = wasm.TS_InvoiceSignature_free(this_obj);
38043 // debug statements here
38045 // uint64_t InvoiceSignature_clone_ptr(LDKInvoiceSignature *NONNULL_PTR arg);
38047 export function InvoiceSignature_clone_ptr(arg: bigint): bigint {
38048 if(!isWasmInitialized) {
38049 throw new Error("initializeWasm() must be awaited first!");
38051 const nativeResponseValue = wasm.TS_InvoiceSignature_clone_ptr(arg);
38052 return nativeResponseValue;
38054 // struct LDKInvoiceSignature InvoiceSignature_clone(const struct LDKInvoiceSignature *NONNULL_PTR orig);
38056 export function InvoiceSignature_clone(orig: bigint): bigint {
38057 if(!isWasmInitialized) {
38058 throw new Error("initializeWasm() must be awaited first!");
38060 const nativeResponseValue = wasm.TS_InvoiceSignature_clone(orig);
38061 return nativeResponseValue;
38063 // uint64_t InvoiceSignature_hash(const struct LDKInvoiceSignature *NONNULL_PTR o);
38065 export function InvoiceSignature_hash(o: bigint): bigint {
38066 if(!isWasmInitialized) {
38067 throw new Error("initializeWasm() must be awaited first!");
38069 const nativeResponseValue = wasm.TS_InvoiceSignature_hash(o);
38070 return nativeResponseValue;
38072 // bool InvoiceSignature_eq(const struct LDKInvoiceSignature *NONNULL_PTR a, const struct LDKInvoiceSignature *NONNULL_PTR b);
38074 export function InvoiceSignature_eq(a: bigint, b: bigint): boolean {
38075 if(!isWasmInitialized) {
38076 throw new Error("initializeWasm() must be awaited first!");
38078 const nativeResponseValue = wasm.TS_InvoiceSignature_eq(a, b);
38079 return nativeResponseValue;
38081 // void PrivateRoute_free(struct LDKPrivateRoute this_obj);
38083 export function PrivateRoute_free(this_obj: bigint): void {
38084 if(!isWasmInitialized) {
38085 throw new Error("initializeWasm() must be awaited first!");
38087 const nativeResponseValue = wasm.TS_PrivateRoute_free(this_obj);
38088 // debug statements here
38090 // uint64_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg);
38092 export function PrivateRoute_clone_ptr(arg: bigint): bigint {
38093 if(!isWasmInitialized) {
38094 throw new Error("initializeWasm() must be awaited first!");
38096 const nativeResponseValue = wasm.TS_PrivateRoute_clone_ptr(arg);
38097 return nativeResponseValue;
38099 // struct LDKPrivateRoute PrivateRoute_clone(const struct LDKPrivateRoute *NONNULL_PTR orig);
38101 export function PrivateRoute_clone(orig: bigint): bigint {
38102 if(!isWasmInitialized) {
38103 throw new Error("initializeWasm() must be awaited first!");
38105 const nativeResponseValue = wasm.TS_PrivateRoute_clone(orig);
38106 return nativeResponseValue;
38108 // uint64_t PrivateRoute_hash(const struct LDKPrivateRoute *NONNULL_PTR o);
38110 export function PrivateRoute_hash(o: bigint): bigint {
38111 if(!isWasmInitialized) {
38112 throw new Error("initializeWasm() must be awaited first!");
38114 const nativeResponseValue = wasm.TS_PrivateRoute_hash(o);
38115 return nativeResponseValue;
38117 // bool PrivateRoute_eq(const struct LDKPrivateRoute *NONNULL_PTR a, const struct LDKPrivateRoute *NONNULL_PTR b);
38119 export function PrivateRoute_eq(a: bigint, b: bigint): boolean {
38120 if(!isWasmInitialized) {
38121 throw new Error("initializeWasm() must be awaited first!");
38123 const nativeResponseValue = wasm.TS_PrivateRoute_eq(a, b);
38124 return nativeResponseValue;
38126 // MUST_USE_RES struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ SignedRawInvoice_into_parts(struct LDKSignedRawInvoice this_arg);
38128 export function SignedRawInvoice_into_parts(this_arg: bigint): bigint {
38129 if(!isWasmInitialized) {
38130 throw new Error("initializeWasm() must be awaited first!");
38132 const nativeResponseValue = wasm.TS_SignedRawInvoice_into_parts(this_arg);
38133 return nativeResponseValue;
38135 // MUST_USE_RES struct LDKRawInvoice SignedRawInvoice_raw_invoice(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
38137 export function SignedRawInvoice_raw_invoice(this_arg: bigint): bigint {
38138 if(!isWasmInitialized) {
38139 throw new Error("initializeWasm() must be awaited first!");
38141 const nativeResponseValue = wasm.TS_SignedRawInvoice_raw_invoice(this_arg);
38142 return nativeResponseValue;
38144 // MUST_USE_RES const uint8_t (*SignedRawInvoice_signable_hash(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg))[32];
38146 export function SignedRawInvoice_signable_hash(this_arg: bigint): number {
38147 if(!isWasmInitialized) {
38148 throw new Error("initializeWasm() must be awaited first!");
38150 const nativeResponseValue = wasm.TS_SignedRawInvoice_signable_hash(this_arg);
38151 return nativeResponseValue;
38153 // MUST_USE_RES struct LDKInvoiceSignature SignedRawInvoice_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
38155 export function SignedRawInvoice_signature(this_arg: bigint): bigint {
38156 if(!isWasmInitialized) {
38157 throw new Error("initializeWasm() must be awaited first!");
38159 const nativeResponseValue = wasm.TS_SignedRawInvoice_signature(this_arg);
38160 return nativeResponseValue;
38162 // MUST_USE_RES struct LDKCResult_PayeePubKeyErrorZ SignedRawInvoice_recover_payee_pub_key(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
38164 export function SignedRawInvoice_recover_payee_pub_key(this_arg: bigint): bigint {
38165 if(!isWasmInitialized) {
38166 throw new Error("initializeWasm() must be awaited first!");
38168 const nativeResponseValue = wasm.TS_SignedRawInvoice_recover_payee_pub_key(this_arg);
38169 return nativeResponseValue;
38171 // MUST_USE_RES bool SignedRawInvoice_check_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
38173 export function SignedRawInvoice_check_signature(this_arg: bigint): boolean {
38174 if(!isWasmInitialized) {
38175 throw new Error("initializeWasm() must be awaited first!");
38177 const nativeResponseValue = wasm.TS_SignedRawInvoice_check_signature(this_arg);
38178 return nativeResponseValue;
38180 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_signable_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
38182 export function RawInvoice_signable_hash(this_arg: bigint): number {
38183 if(!isWasmInitialized) {
38184 throw new Error("initializeWasm() must be awaited first!");
38186 const nativeResponseValue = wasm.TS_RawInvoice_signable_hash(this_arg);
38187 return nativeResponseValue;
38189 // MUST_USE_RES struct LDKSha256 RawInvoice_payment_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
38191 export function RawInvoice_payment_hash(this_arg: bigint): bigint {
38192 if(!isWasmInitialized) {
38193 throw new Error("initializeWasm() must be awaited first!");
38195 const nativeResponseValue = wasm.TS_RawInvoice_payment_hash(this_arg);
38196 return nativeResponseValue;
38198 // MUST_USE_RES struct LDKDescription RawInvoice_description(const struct LDKRawInvoice *NONNULL_PTR this_arg);
38200 export function RawInvoice_description(this_arg: bigint): bigint {
38201 if(!isWasmInitialized) {
38202 throw new Error("initializeWasm() must be awaited first!");
38204 const nativeResponseValue = wasm.TS_RawInvoice_description(this_arg);
38205 return nativeResponseValue;
38207 // MUST_USE_RES struct LDKPayeePubKey RawInvoice_payee_pub_key(const struct LDKRawInvoice *NONNULL_PTR this_arg);
38209 export function RawInvoice_payee_pub_key(this_arg: bigint): bigint {
38210 if(!isWasmInitialized) {
38211 throw new Error("initializeWasm() must be awaited first!");
38213 const nativeResponseValue = wasm.TS_RawInvoice_payee_pub_key(this_arg);
38214 return nativeResponseValue;
38216 // MUST_USE_RES struct LDKSha256 RawInvoice_description_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
38218 export function RawInvoice_description_hash(this_arg: bigint): bigint {
38219 if(!isWasmInitialized) {
38220 throw new Error("initializeWasm() must be awaited first!");
38222 const nativeResponseValue = wasm.TS_RawInvoice_description_hash(this_arg);
38223 return nativeResponseValue;
38225 // MUST_USE_RES struct LDKExpiryTime RawInvoice_expiry_time(const struct LDKRawInvoice *NONNULL_PTR this_arg);
38227 export function RawInvoice_expiry_time(this_arg: bigint): bigint {
38228 if(!isWasmInitialized) {
38229 throw new Error("initializeWasm() must be awaited first!");
38231 const nativeResponseValue = wasm.TS_RawInvoice_expiry_time(this_arg);
38232 return nativeResponseValue;
38234 // MUST_USE_RES struct LDKMinFinalCltvExpiryDelta RawInvoice_min_final_cltv_expiry_delta(const struct LDKRawInvoice *NONNULL_PTR this_arg);
38236 export function RawInvoice_min_final_cltv_expiry_delta(this_arg: bigint): bigint {
38237 if(!isWasmInitialized) {
38238 throw new Error("initializeWasm() must be awaited first!");
38240 const nativeResponseValue = wasm.TS_RawInvoice_min_final_cltv_expiry_delta(this_arg);
38241 return nativeResponseValue;
38243 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_payment_secret(const struct LDKRawInvoice *NONNULL_PTR this_arg);
38245 export function RawInvoice_payment_secret(this_arg: bigint): number {
38246 if(!isWasmInitialized) {
38247 throw new Error("initializeWasm() must be awaited first!");
38249 const nativeResponseValue = wasm.TS_RawInvoice_payment_secret(this_arg);
38250 return nativeResponseValue;
38252 // MUST_USE_RES struct LDKInvoiceFeatures RawInvoice_features(const struct LDKRawInvoice *NONNULL_PTR this_arg);
38254 export function RawInvoice_features(this_arg: bigint): bigint {
38255 if(!isWasmInitialized) {
38256 throw new Error("initializeWasm() must be awaited first!");
38258 const nativeResponseValue = wasm.TS_RawInvoice_features(this_arg);
38259 return nativeResponseValue;
38261 // MUST_USE_RES struct LDKCVec_PrivateRouteZ RawInvoice_private_routes(const struct LDKRawInvoice *NONNULL_PTR this_arg);
38263 export function RawInvoice_private_routes(this_arg: bigint): number {
38264 if(!isWasmInitialized) {
38265 throw new Error("initializeWasm() must be awaited first!");
38267 const nativeResponseValue = wasm.TS_RawInvoice_private_routes(this_arg);
38268 return nativeResponseValue;
38270 // MUST_USE_RES struct LDKCOption_u64Z RawInvoice_amount_pico_btc(const struct LDKRawInvoice *NONNULL_PTR this_arg);
38272 export function RawInvoice_amount_pico_btc(this_arg: bigint): bigint {
38273 if(!isWasmInitialized) {
38274 throw new Error("initializeWasm() must be awaited first!");
38276 const nativeResponseValue = wasm.TS_RawInvoice_amount_pico_btc(this_arg);
38277 return nativeResponseValue;
38279 // MUST_USE_RES enum LDKCurrency RawInvoice_currency(const struct LDKRawInvoice *NONNULL_PTR this_arg);
38281 export function RawInvoice_currency(this_arg: bigint): Currency {
38282 if(!isWasmInitialized) {
38283 throw new Error("initializeWasm() must be awaited first!");
38285 const nativeResponseValue = wasm.TS_RawInvoice_currency(this_arg);
38286 return nativeResponseValue;
38288 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_unix_timestamp(uint64_t unix_seconds);
38290 export function PositiveTimestamp_from_unix_timestamp(unix_seconds: bigint): bigint {
38291 if(!isWasmInitialized) {
38292 throw new Error("initializeWasm() must be awaited first!");
38294 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_unix_timestamp(unix_seconds);
38295 return nativeResponseValue;
38297 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_duration_since_epoch(uint64_t duration);
38299 export function PositiveTimestamp_from_duration_since_epoch(duration: bigint): bigint {
38300 if(!isWasmInitialized) {
38301 throw new Error("initializeWasm() must be awaited first!");
38303 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_duration_since_epoch(duration);
38304 return nativeResponseValue;
38306 // MUST_USE_RES uint64_t PositiveTimestamp_as_unix_timestamp(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
38308 export function PositiveTimestamp_as_unix_timestamp(this_arg: bigint): bigint {
38309 if(!isWasmInitialized) {
38310 throw new Error("initializeWasm() must be awaited first!");
38312 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_unix_timestamp(this_arg);
38313 return nativeResponseValue;
38315 // MUST_USE_RES uint64_t PositiveTimestamp_as_duration_since_epoch(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
38317 export function PositiveTimestamp_as_duration_since_epoch(this_arg: bigint): bigint {
38318 if(!isWasmInitialized) {
38319 throw new Error("initializeWasm() must be awaited first!");
38321 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_duration_since_epoch(this_arg);
38322 return nativeResponseValue;
38324 // MUST_USE_RES struct LDKSignedRawInvoice Invoice_into_signed_raw(struct LDKInvoice this_arg);
38326 export function Invoice_into_signed_raw(this_arg: bigint): bigint {
38327 if(!isWasmInitialized) {
38328 throw new Error("initializeWasm() must be awaited first!");
38330 const nativeResponseValue = wasm.TS_Invoice_into_signed_raw(this_arg);
38331 return nativeResponseValue;
38333 // MUST_USE_RES struct LDKCResult_NoneSemanticErrorZ Invoice_check_signature(const struct LDKInvoice *NONNULL_PTR this_arg);
38335 export function Invoice_check_signature(this_arg: bigint): bigint {
38336 if(!isWasmInitialized) {
38337 throw new Error("initializeWasm() must be awaited first!");
38339 const nativeResponseValue = wasm.TS_Invoice_check_signature(this_arg);
38340 return nativeResponseValue;
38342 // MUST_USE_RES struct LDKCResult_InvoiceSemanticErrorZ Invoice_from_signed(struct LDKSignedRawInvoice signed_invoice);
38344 export function Invoice_from_signed(signed_invoice: bigint): bigint {
38345 if(!isWasmInitialized) {
38346 throw new Error("initializeWasm() must be awaited first!");
38348 const nativeResponseValue = wasm.TS_Invoice_from_signed(signed_invoice);
38349 return nativeResponseValue;
38351 // MUST_USE_RES uint64_t Invoice_duration_since_epoch(const struct LDKInvoice *NONNULL_PTR this_arg);
38353 export function Invoice_duration_since_epoch(this_arg: bigint): bigint {
38354 if(!isWasmInitialized) {
38355 throw new Error("initializeWasm() must be awaited first!");
38357 const nativeResponseValue = wasm.TS_Invoice_duration_since_epoch(this_arg);
38358 return nativeResponseValue;
38360 // MUST_USE_RES const uint8_t (*Invoice_payment_hash(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
38362 export function Invoice_payment_hash(this_arg: bigint): number {
38363 if(!isWasmInitialized) {
38364 throw new Error("initializeWasm() must be awaited first!");
38366 const nativeResponseValue = wasm.TS_Invoice_payment_hash(this_arg);
38367 return nativeResponseValue;
38369 // MUST_USE_RES struct LDKPublicKey Invoice_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
38371 export function Invoice_payee_pub_key(this_arg: bigint): number {
38372 if(!isWasmInitialized) {
38373 throw new Error("initializeWasm() must be awaited first!");
38375 const nativeResponseValue = wasm.TS_Invoice_payee_pub_key(this_arg);
38376 return nativeResponseValue;
38378 // MUST_USE_RES const uint8_t (*Invoice_payment_secret(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
38380 export function Invoice_payment_secret(this_arg: bigint): number {
38381 if(!isWasmInitialized) {
38382 throw new Error("initializeWasm() must be awaited first!");
38384 const nativeResponseValue = wasm.TS_Invoice_payment_secret(this_arg);
38385 return nativeResponseValue;
38387 // MUST_USE_RES struct LDKInvoiceFeatures Invoice_features(const struct LDKInvoice *NONNULL_PTR this_arg);
38389 export function Invoice_features(this_arg: bigint): bigint {
38390 if(!isWasmInitialized) {
38391 throw new Error("initializeWasm() must be awaited first!");
38393 const nativeResponseValue = wasm.TS_Invoice_features(this_arg);
38394 return nativeResponseValue;
38396 // MUST_USE_RES struct LDKPublicKey Invoice_recover_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
38398 export function Invoice_recover_payee_pub_key(this_arg: bigint): number {
38399 if(!isWasmInitialized) {
38400 throw new Error("initializeWasm() must be awaited first!");
38402 const nativeResponseValue = wasm.TS_Invoice_recover_payee_pub_key(this_arg);
38403 return nativeResponseValue;
38405 // MUST_USE_RES uint64_t Invoice_expiry_time(const struct LDKInvoice *NONNULL_PTR this_arg);
38407 export function Invoice_expiry_time(this_arg: bigint): bigint {
38408 if(!isWasmInitialized) {
38409 throw new Error("initializeWasm() must be awaited first!");
38411 const nativeResponseValue = wasm.TS_Invoice_expiry_time(this_arg);
38412 return nativeResponseValue;
38414 // MUST_USE_RES bool Invoice_would_expire(const struct LDKInvoice *NONNULL_PTR this_arg, uint64_t at_time);
38416 export function Invoice_would_expire(this_arg: bigint, at_time: bigint): boolean {
38417 if(!isWasmInitialized) {
38418 throw new Error("initializeWasm() must be awaited first!");
38420 const nativeResponseValue = wasm.TS_Invoice_would_expire(this_arg, at_time);
38421 return nativeResponseValue;
38423 // MUST_USE_RES uint64_t Invoice_min_final_cltv_expiry_delta(const struct LDKInvoice *NONNULL_PTR this_arg);
38425 export function Invoice_min_final_cltv_expiry_delta(this_arg: bigint): bigint {
38426 if(!isWasmInitialized) {
38427 throw new Error("initializeWasm() must be awaited first!");
38429 const nativeResponseValue = wasm.TS_Invoice_min_final_cltv_expiry_delta(this_arg);
38430 return nativeResponseValue;
38432 // MUST_USE_RES struct LDKCVec_PrivateRouteZ Invoice_private_routes(const struct LDKInvoice *NONNULL_PTR this_arg);
38434 export function Invoice_private_routes(this_arg: bigint): number {
38435 if(!isWasmInitialized) {
38436 throw new Error("initializeWasm() must be awaited first!");
38438 const nativeResponseValue = wasm.TS_Invoice_private_routes(this_arg);
38439 return nativeResponseValue;
38441 // MUST_USE_RES struct LDKCVec_RouteHintZ Invoice_route_hints(const struct LDKInvoice *NONNULL_PTR this_arg);
38443 export function Invoice_route_hints(this_arg: bigint): number {
38444 if(!isWasmInitialized) {
38445 throw new Error("initializeWasm() must be awaited first!");
38447 const nativeResponseValue = wasm.TS_Invoice_route_hints(this_arg);
38448 return nativeResponseValue;
38450 // MUST_USE_RES enum LDKCurrency Invoice_currency(const struct LDKInvoice *NONNULL_PTR this_arg);
38452 export function Invoice_currency(this_arg: bigint): Currency {
38453 if(!isWasmInitialized) {
38454 throw new Error("initializeWasm() must be awaited first!");
38456 const nativeResponseValue = wasm.TS_Invoice_currency(this_arg);
38457 return nativeResponseValue;
38459 // MUST_USE_RES struct LDKCOption_u64Z Invoice_amount_milli_satoshis(const struct LDKInvoice *NONNULL_PTR this_arg);
38461 export function Invoice_amount_milli_satoshis(this_arg: bigint): bigint {
38462 if(!isWasmInitialized) {
38463 throw new Error("initializeWasm() must be awaited first!");
38465 const nativeResponseValue = wasm.TS_Invoice_amount_milli_satoshis(this_arg);
38466 return nativeResponseValue;
38468 // MUST_USE_RES struct LDKCResult_DescriptionCreationErrorZ Description_new(struct LDKStr description);
38470 export function Description_new(description: number): bigint {
38471 if(!isWasmInitialized) {
38472 throw new Error("initializeWasm() must be awaited first!");
38474 const nativeResponseValue = wasm.TS_Description_new(description);
38475 return nativeResponseValue;
38477 // MUST_USE_RES struct LDKStr Description_into_inner(struct LDKDescription this_arg);
38479 export function Description_into_inner(this_arg: bigint): number {
38480 if(!isWasmInitialized) {
38481 throw new Error("initializeWasm() must be awaited first!");
38483 const nativeResponseValue = wasm.TS_Description_into_inner(this_arg);
38484 return nativeResponseValue;
38486 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_seconds(uint64_t seconds);
38488 export function ExpiryTime_from_seconds(seconds: bigint): bigint {
38489 if(!isWasmInitialized) {
38490 throw new Error("initializeWasm() must be awaited first!");
38492 const nativeResponseValue = wasm.TS_ExpiryTime_from_seconds(seconds);
38493 return nativeResponseValue;
38495 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_duration(uint64_t duration);
38497 export function ExpiryTime_from_duration(duration: bigint): bigint {
38498 if(!isWasmInitialized) {
38499 throw new Error("initializeWasm() must be awaited first!");
38501 const nativeResponseValue = wasm.TS_ExpiryTime_from_duration(duration);
38502 return nativeResponseValue;
38504 // MUST_USE_RES uint64_t ExpiryTime_as_seconds(const struct LDKExpiryTime *NONNULL_PTR this_arg);
38506 export function ExpiryTime_as_seconds(this_arg: bigint): bigint {
38507 if(!isWasmInitialized) {
38508 throw new Error("initializeWasm() must be awaited first!");
38510 const nativeResponseValue = wasm.TS_ExpiryTime_as_seconds(this_arg);
38511 return nativeResponseValue;
38513 // MUST_USE_RES uint64_t ExpiryTime_as_duration(const struct LDKExpiryTime *NONNULL_PTR this_arg);
38515 export function ExpiryTime_as_duration(this_arg: bigint): bigint {
38516 if(!isWasmInitialized) {
38517 throw new Error("initializeWasm() must be awaited first!");
38519 const nativeResponseValue = wasm.TS_ExpiryTime_as_duration(this_arg);
38520 return nativeResponseValue;
38522 // MUST_USE_RES struct LDKCResult_PrivateRouteCreationErrorZ PrivateRoute_new(struct LDKRouteHint hops);
38524 export function PrivateRoute_new(hops: bigint): bigint {
38525 if(!isWasmInitialized) {
38526 throw new Error("initializeWasm() must be awaited first!");
38528 const nativeResponseValue = wasm.TS_PrivateRoute_new(hops);
38529 return nativeResponseValue;
38531 // MUST_USE_RES struct LDKRouteHint PrivateRoute_into_inner(struct LDKPrivateRoute this_arg);
38533 export function PrivateRoute_into_inner(this_arg: bigint): bigint {
38534 if(!isWasmInitialized) {
38535 throw new Error("initializeWasm() must be awaited first!");
38537 const nativeResponseValue = wasm.TS_PrivateRoute_into_inner(this_arg);
38538 return nativeResponseValue;
38540 // enum LDKCreationError CreationError_clone(const enum LDKCreationError *NONNULL_PTR orig);
38542 export function CreationError_clone(orig: bigint): CreationError {
38543 if(!isWasmInitialized) {
38544 throw new Error("initializeWasm() must be awaited first!");
38546 const nativeResponseValue = wasm.TS_CreationError_clone(orig);
38547 return nativeResponseValue;
38549 // enum LDKCreationError CreationError_description_too_long(void);
38551 export function CreationError_description_too_long(): CreationError {
38552 if(!isWasmInitialized) {
38553 throw new Error("initializeWasm() must be awaited first!");
38555 const nativeResponseValue = wasm.TS_CreationError_description_too_long();
38556 return nativeResponseValue;
38558 // enum LDKCreationError CreationError_route_too_long(void);
38560 export function CreationError_route_too_long(): CreationError {
38561 if(!isWasmInitialized) {
38562 throw new Error("initializeWasm() must be awaited first!");
38564 const nativeResponseValue = wasm.TS_CreationError_route_too_long();
38565 return nativeResponseValue;
38567 // enum LDKCreationError CreationError_timestamp_out_of_bounds(void);
38569 export function CreationError_timestamp_out_of_bounds(): CreationError {
38570 if(!isWasmInitialized) {
38571 throw new Error("initializeWasm() must be awaited first!");
38573 const nativeResponseValue = wasm.TS_CreationError_timestamp_out_of_bounds();
38574 return nativeResponseValue;
38576 // enum LDKCreationError CreationError_invalid_amount(void);
38578 export function CreationError_invalid_amount(): CreationError {
38579 if(!isWasmInitialized) {
38580 throw new Error("initializeWasm() must be awaited first!");
38582 const nativeResponseValue = wasm.TS_CreationError_invalid_amount();
38583 return nativeResponseValue;
38585 // enum LDKCreationError CreationError_missing_route_hints(void);
38587 export function CreationError_missing_route_hints(): CreationError {
38588 if(!isWasmInitialized) {
38589 throw new Error("initializeWasm() must be awaited first!");
38591 const nativeResponseValue = wasm.TS_CreationError_missing_route_hints();
38592 return nativeResponseValue;
38594 // enum LDKCreationError CreationError_min_final_cltv_expiry_delta_too_short(void);
38596 export function CreationError_min_final_cltv_expiry_delta_too_short(): CreationError {
38597 if(!isWasmInitialized) {
38598 throw new Error("initializeWasm() must be awaited first!");
38600 const nativeResponseValue = wasm.TS_CreationError_min_final_cltv_expiry_delta_too_short();
38601 return nativeResponseValue;
38603 // bool CreationError_eq(const enum LDKCreationError *NONNULL_PTR a, const enum LDKCreationError *NONNULL_PTR b);
38605 export function CreationError_eq(a: bigint, b: bigint): boolean {
38606 if(!isWasmInitialized) {
38607 throw new Error("initializeWasm() must be awaited first!");
38609 const nativeResponseValue = wasm.TS_CreationError_eq(a, b);
38610 return nativeResponseValue;
38612 // struct LDKStr CreationError_to_str(const enum LDKCreationError *NONNULL_PTR o);
38614 export function CreationError_to_str(o: bigint): number {
38615 if(!isWasmInitialized) {
38616 throw new Error("initializeWasm() must be awaited first!");
38618 const nativeResponseValue = wasm.TS_CreationError_to_str(o);
38619 return nativeResponseValue;
38621 // enum LDKSemanticError SemanticError_clone(const enum LDKSemanticError *NONNULL_PTR orig);
38623 export function SemanticError_clone(orig: bigint): SemanticError {
38624 if(!isWasmInitialized) {
38625 throw new Error("initializeWasm() must be awaited first!");
38627 const nativeResponseValue = wasm.TS_SemanticError_clone(orig);
38628 return nativeResponseValue;
38630 // enum LDKSemanticError SemanticError_no_payment_hash(void);
38632 export function SemanticError_no_payment_hash(): SemanticError {
38633 if(!isWasmInitialized) {
38634 throw new Error("initializeWasm() must be awaited first!");
38636 const nativeResponseValue = wasm.TS_SemanticError_no_payment_hash();
38637 return nativeResponseValue;
38639 // enum LDKSemanticError SemanticError_multiple_payment_hashes(void);
38641 export function SemanticError_multiple_payment_hashes(): SemanticError {
38642 if(!isWasmInitialized) {
38643 throw new Error("initializeWasm() must be awaited first!");
38645 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_hashes();
38646 return nativeResponseValue;
38648 // enum LDKSemanticError SemanticError_no_description(void);
38650 export function SemanticError_no_description(): SemanticError {
38651 if(!isWasmInitialized) {
38652 throw new Error("initializeWasm() must be awaited first!");
38654 const nativeResponseValue = wasm.TS_SemanticError_no_description();
38655 return nativeResponseValue;
38657 // enum LDKSemanticError SemanticError_multiple_descriptions(void);
38659 export function SemanticError_multiple_descriptions(): SemanticError {
38660 if(!isWasmInitialized) {
38661 throw new Error("initializeWasm() must be awaited first!");
38663 const nativeResponseValue = wasm.TS_SemanticError_multiple_descriptions();
38664 return nativeResponseValue;
38666 // enum LDKSemanticError SemanticError_no_payment_secret(void);
38668 export function SemanticError_no_payment_secret(): SemanticError {
38669 if(!isWasmInitialized) {
38670 throw new Error("initializeWasm() must be awaited first!");
38672 const nativeResponseValue = wasm.TS_SemanticError_no_payment_secret();
38673 return nativeResponseValue;
38675 // enum LDKSemanticError SemanticError_multiple_payment_secrets(void);
38677 export function SemanticError_multiple_payment_secrets(): SemanticError {
38678 if(!isWasmInitialized) {
38679 throw new Error("initializeWasm() must be awaited first!");
38681 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_secrets();
38682 return nativeResponseValue;
38684 // enum LDKSemanticError SemanticError_invalid_features(void);
38686 export function SemanticError_invalid_features(): SemanticError {
38687 if(!isWasmInitialized) {
38688 throw new Error("initializeWasm() must be awaited first!");
38690 const nativeResponseValue = wasm.TS_SemanticError_invalid_features();
38691 return nativeResponseValue;
38693 // enum LDKSemanticError SemanticError_invalid_recovery_id(void);
38695 export function SemanticError_invalid_recovery_id(): SemanticError {
38696 if(!isWasmInitialized) {
38697 throw new Error("initializeWasm() must be awaited first!");
38699 const nativeResponseValue = wasm.TS_SemanticError_invalid_recovery_id();
38700 return nativeResponseValue;
38702 // enum LDKSemanticError SemanticError_invalid_signature(void);
38704 export function SemanticError_invalid_signature(): SemanticError {
38705 if(!isWasmInitialized) {
38706 throw new Error("initializeWasm() must be awaited first!");
38708 const nativeResponseValue = wasm.TS_SemanticError_invalid_signature();
38709 return nativeResponseValue;
38711 // enum LDKSemanticError SemanticError_imprecise_amount(void);
38713 export function SemanticError_imprecise_amount(): SemanticError {
38714 if(!isWasmInitialized) {
38715 throw new Error("initializeWasm() must be awaited first!");
38717 const nativeResponseValue = wasm.TS_SemanticError_imprecise_amount();
38718 return nativeResponseValue;
38720 // bool SemanticError_eq(const enum LDKSemanticError *NONNULL_PTR a, const enum LDKSemanticError *NONNULL_PTR b);
38722 export function SemanticError_eq(a: bigint, b: bigint): boolean {
38723 if(!isWasmInitialized) {
38724 throw new Error("initializeWasm() must be awaited first!");
38726 const nativeResponseValue = wasm.TS_SemanticError_eq(a, b);
38727 return nativeResponseValue;
38729 // struct LDKStr SemanticError_to_str(const enum LDKSemanticError *NONNULL_PTR o);
38731 export function SemanticError_to_str(o: bigint): number {
38732 if(!isWasmInitialized) {
38733 throw new Error("initializeWasm() must be awaited first!");
38735 const nativeResponseValue = wasm.TS_SemanticError_to_str(o);
38736 return nativeResponseValue;
38738 // void SignOrCreationError_free(struct LDKSignOrCreationError this_ptr);
38740 export function SignOrCreationError_free(this_ptr: bigint): void {
38741 if(!isWasmInitialized) {
38742 throw new Error("initializeWasm() must be awaited first!");
38744 const nativeResponseValue = wasm.TS_SignOrCreationError_free(this_ptr);
38745 // debug statements here
38747 // uint64_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg);
38749 export function SignOrCreationError_clone_ptr(arg: bigint): bigint {
38750 if(!isWasmInitialized) {
38751 throw new Error("initializeWasm() must be awaited first!");
38753 const nativeResponseValue = wasm.TS_SignOrCreationError_clone_ptr(arg);
38754 return nativeResponseValue;
38756 // struct LDKSignOrCreationError SignOrCreationError_clone(const struct LDKSignOrCreationError *NONNULL_PTR orig);
38758 export function SignOrCreationError_clone(orig: bigint): bigint {
38759 if(!isWasmInitialized) {
38760 throw new Error("initializeWasm() must be awaited first!");
38762 const nativeResponseValue = wasm.TS_SignOrCreationError_clone(orig);
38763 return nativeResponseValue;
38765 // struct LDKSignOrCreationError SignOrCreationError_sign_error(void);
38767 export function SignOrCreationError_sign_error(): bigint {
38768 if(!isWasmInitialized) {
38769 throw new Error("initializeWasm() must be awaited first!");
38771 const nativeResponseValue = wasm.TS_SignOrCreationError_sign_error();
38772 return nativeResponseValue;
38774 // struct LDKSignOrCreationError SignOrCreationError_creation_error(enum LDKCreationError a);
38776 export function SignOrCreationError_creation_error(a: CreationError): bigint {
38777 if(!isWasmInitialized) {
38778 throw new Error("initializeWasm() must be awaited first!");
38780 const nativeResponseValue = wasm.TS_SignOrCreationError_creation_error(a);
38781 return nativeResponseValue;
38783 // bool SignOrCreationError_eq(const struct LDKSignOrCreationError *NONNULL_PTR a, const struct LDKSignOrCreationError *NONNULL_PTR b);
38785 export function SignOrCreationError_eq(a: bigint, b: bigint): boolean {
38786 if(!isWasmInitialized) {
38787 throw new Error("initializeWasm() must be awaited first!");
38789 const nativeResponseValue = wasm.TS_SignOrCreationError_eq(a, b);
38790 return nativeResponseValue;
38792 // struct LDKStr SignOrCreationError_to_str(const struct LDKSignOrCreationError *NONNULL_PTR o);
38794 export function SignOrCreationError_to_str(o: bigint): number {
38795 if(!isWasmInitialized) {
38796 throw new Error("initializeWasm() must be awaited first!");
38798 const nativeResponseValue = wasm.TS_SignOrCreationError_to_str(o);
38799 return nativeResponseValue;
38801 // struct LDKCResult_PaymentIdPaymentErrorZ pay_invoice(const struct LDKInvoice *NONNULL_PTR invoice, struct LDKRetry retry_strategy, const struct LDKChannelManager *NONNULL_PTR channelmanager);
38803 export function pay_invoice(invoice: bigint, retry_strategy: bigint, channelmanager: bigint): bigint {
38804 if(!isWasmInitialized) {
38805 throw new Error("initializeWasm() must be awaited first!");
38807 const nativeResponseValue = wasm.TS_pay_invoice(invoice, retry_strategy, channelmanager);
38808 return nativeResponseValue;
38810 // struct LDKCResult_NonePaymentErrorZ pay_invoice_with_id(const struct LDKInvoice *NONNULL_PTR invoice, struct LDKThirtyTwoBytes payment_id, struct LDKRetry retry_strategy, const struct LDKChannelManager *NONNULL_PTR channelmanager);
38812 export function pay_invoice_with_id(invoice: bigint, payment_id: number, retry_strategy: bigint, channelmanager: bigint): bigint {
38813 if(!isWasmInitialized) {
38814 throw new Error("initializeWasm() must be awaited first!");
38816 const nativeResponseValue = wasm.TS_pay_invoice_with_id(invoice, payment_id, retry_strategy, channelmanager);
38817 return nativeResponseValue;
38819 // struct LDKCResult_PaymentIdPaymentErrorZ pay_zero_value_invoice(const struct LDKInvoice *NONNULL_PTR invoice, uint64_t amount_msats, struct LDKRetry retry_strategy, const struct LDKChannelManager *NONNULL_PTR channelmanager);
38821 export function pay_zero_value_invoice(invoice: bigint, amount_msats: bigint, retry_strategy: bigint, channelmanager: bigint): bigint {
38822 if(!isWasmInitialized) {
38823 throw new Error("initializeWasm() must be awaited first!");
38825 const nativeResponseValue = wasm.TS_pay_zero_value_invoice(invoice, amount_msats, retry_strategy, channelmanager);
38826 return nativeResponseValue;
38828 // struct LDKCResult_NonePaymentErrorZ pay_zero_value_invoice_with_id(const struct LDKInvoice *NONNULL_PTR invoice, uint64_t amount_msats, struct LDKThirtyTwoBytes payment_id, struct LDKRetry retry_strategy, const struct LDKChannelManager *NONNULL_PTR channelmanager);
38830 export function pay_zero_value_invoice_with_id(invoice: bigint, amount_msats: bigint, payment_id: number, retry_strategy: bigint, channelmanager: bigint): bigint {
38831 if(!isWasmInitialized) {
38832 throw new Error("initializeWasm() must be awaited first!");
38834 const nativeResponseValue = wasm.TS_pay_zero_value_invoice_with_id(invoice, amount_msats, payment_id, retry_strategy, channelmanager);
38835 return nativeResponseValue;
38837 // void PaymentError_free(struct LDKPaymentError this_ptr);
38839 export function PaymentError_free(this_ptr: bigint): void {
38840 if(!isWasmInitialized) {
38841 throw new Error("initializeWasm() must be awaited first!");
38843 const nativeResponseValue = wasm.TS_PaymentError_free(this_ptr);
38844 // debug statements here
38846 // uint64_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg);
38848 export function PaymentError_clone_ptr(arg: bigint): bigint {
38849 if(!isWasmInitialized) {
38850 throw new Error("initializeWasm() must be awaited first!");
38852 const nativeResponseValue = wasm.TS_PaymentError_clone_ptr(arg);
38853 return nativeResponseValue;
38855 // struct LDKPaymentError PaymentError_clone(const struct LDKPaymentError *NONNULL_PTR orig);
38857 export function PaymentError_clone(orig: bigint): bigint {
38858 if(!isWasmInitialized) {
38859 throw new Error("initializeWasm() must be awaited first!");
38861 const nativeResponseValue = wasm.TS_PaymentError_clone(orig);
38862 return nativeResponseValue;
38864 // struct LDKPaymentError PaymentError_invoice(struct LDKStr a);
38866 export function PaymentError_invoice(a: number): bigint {
38867 if(!isWasmInitialized) {
38868 throw new Error("initializeWasm() must be awaited first!");
38870 const nativeResponseValue = wasm.TS_PaymentError_invoice(a);
38871 return nativeResponseValue;
38873 // struct LDKPaymentError PaymentError_sending(enum LDKRetryableSendFailure a);
38875 export function PaymentError_sending(a: RetryableSendFailure): bigint {
38876 if(!isWasmInitialized) {
38877 throw new Error("initializeWasm() must be awaited first!");
38879 const nativeResponseValue = wasm.TS_PaymentError_sending(a);
38880 return nativeResponseValue;
38882 // struct LDKCResult_InvoiceSignOrCreationErrorZ create_phantom_invoice(struct LDKCOption_u64Z amt_msat, struct LDKThirtyTwoBytes payment_hash, struct LDKStr description, uint32_t invoice_expiry_delta_secs, struct LDKCVec_PhantomRouteHintsZ phantom_route_hints, struct LDKEntropySource entropy_source, struct LDKNodeSigner node_signer, struct LDKLogger logger, enum LDKCurrency network, struct LDKCOption_u16Z min_final_cltv_expiry_delta, uint64_t duration_since_epoch);
38884 export function create_phantom_invoice(amt_msat: bigint, payment_hash: number, description: number, invoice_expiry_delta_secs: number, phantom_route_hints: number, entropy_source: bigint, node_signer: bigint, logger: bigint, network: Currency, min_final_cltv_expiry_delta: bigint, duration_since_epoch: bigint): bigint {
38885 if(!isWasmInitialized) {
38886 throw new Error("initializeWasm() must be awaited first!");
38888 const nativeResponseValue = wasm.TS_create_phantom_invoice(amt_msat, payment_hash, description, invoice_expiry_delta_secs, phantom_route_hints, entropy_source, node_signer, logger, network, min_final_cltv_expiry_delta, duration_since_epoch);
38889 return nativeResponseValue;
38891 // struct LDKCResult_InvoiceSignOrCreationErrorZ create_phantom_invoice_with_description_hash(struct LDKCOption_u64Z amt_msat, struct LDKThirtyTwoBytes payment_hash, uint32_t invoice_expiry_delta_secs, struct LDKSha256 description_hash, struct LDKCVec_PhantomRouteHintsZ phantom_route_hints, struct LDKEntropySource entropy_source, struct LDKNodeSigner node_signer, struct LDKLogger logger, enum LDKCurrency network, struct LDKCOption_u16Z min_final_cltv_expiry_delta, uint64_t duration_since_epoch);
38893 export function create_phantom_invoice_with_description_hash(amt_msat: bigint, payment_hash: number, invoice_expiry_delta_secs: number, description_hash: bigint, phantom_route_hints: number, entropy_source: bigint, node_signer: bigint, logger: bigint, network: Currency, min_final_cltv_expiry_delta: bigint, duration_since_epoch: bigint): bigint {
38894 if(!isWasmInitialized) {
38895 throw new Error("initializeWasm() must be awaited first!");
38897 const nativeResponseValue = wasm.TS_create_phantom_invoice_with_description_hash(amt_msat, payment_hash, invoice_expiry_delta_secs, description_hash, phantom_route_hints, entropy_source, node_signer, logger, network, min_final_cltv_expiry_delta, duration_since_epoch);
38898 return nativeResponseValue;
38900 // struct LDKCResult_InvoiceSignOrCreationErrorZ create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(const struct LDKChannelManager *NONNULL_PTR channelmanager, struct LDKNodeSigner node_signer, 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, struct LDKCOption_u16Z min_final_cltv_expiry_delta);
38902 export function create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(channelmanager: bigint, node_signer: bigint, logger: bigint, network: Currency, amt_msat: bigint, description_hash: bigint, duration_since_epoch: bigint, invoice_expiry_delta_secs: number, min_final_cltv_expiry_delta: bigint): bigint {
38903 if(!isWasmInitialized) {
38904 throw new Error("initializeWasm() must be awaited first!");
38906 const nativeResponseValue = wasm.TS_create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(channelmanager, node_signer, logger, network, amt_msat, description_hash, duration_since_epoch, invoice_expiry_delta_secs, min_final_cltv_expiry_delta);
38907 return nativeResponseValue;
38909 // struct LDKCResult_InvoiceSignOrCreationErrorZ create_invoice_from_channelmanager_and_duration_since_epoch(const struct LDKChannelManager *NONNULL_PTR channelmanager, struct LDKNodeSigner node_signer, 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, struct LDKCOption_u16Z min_final_cltv_expiry_delta);
38911 export function create_invoice_from_channelmanager_and_duration_since_epoch(channelmanager: bigint, node_signer: bigint, logger: bigint, network: Currency, amt_msat: bigint, description: number, duration_since_epoch: bigint, invoice_expiry_delta_secs: number, min_final_cltv_expiry_delta: bigint): bigint {
38912 if(!isWasmInitialized) {
38913 throw new Error("initializeWasm() must be awaited first!");
38915 const nativeResponseValue = wasm.TS_create_invoice_from_channelmanager_and_duration_since_epoch(channelmanager, node_signer, logger, network, amt_msat, description, duration_since_epoch, invoice_expiry_delta_secs, min_final_cltv_expiry_delta);
38916 return nativeResponseValue;
38918 // struct LDKCResult_InvoiceSignOrCreationErrorZ create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash(const struct LDKChannelManager *NONNULL_PTR channelmanager, struct LDKNodeSigner node_signer, 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, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u16Z min_final_cltv_expiry_delta);
38920 export function create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash(channelmanager: bigint, node_signer: bigint, logger: bigint, network: Currency, amt_msat: bigint, description: number, duration_since_epoch: bigint, invoice_expiry_delta_secs: number, payment_hash: number, min_final_cltv_expiry_delta: bigint): bigint {
38921 if(!isWasmInitialized) {
38922 throw new Error("initializeWasm() must be awaited first!");
38924 const nativeResponseValue = wasm.TS_create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash(channelmanager, node_signer, logger, network, amt_msat, description, duration_since_epoch, invoice_expiry_delta_secs, payment_hash, min_final_cltv_expiry_delta);
38925 return nativeResponseValue;
38927 // struct LDKCResult_SiPrefixParseErrorZ SiPrefix_from_str(struct LDKStr s);
38929 export function SiPrefix_from_str(s: number): bigint {
38930 if(!isWasmInitialized) {
38931 throw new Error("initializeWasm() must be awaited first!");
38933 const nativeResponseValue = wasm.TS_SiPrefix_from_str(s);
38934 return nativeResponseValue;
38936 // struct LDKCResult_InvoiceParseOrSemanticErrorZ Invoice_from_str(struct LDKStr s);
38938 export function Invoice_from_str(s: number): bigint {
38939 if(!isWasmInitialized) {
38940 throw new Error("initializeWasm() must be awaited first!");
38942 const nativeResponseValue = wasm.TS_Invoice_from_str(s);
38943 return nativeResponseValue;
38945 // struct LDKCResult_SignedRawInvoiceParseErrorZ SignedRawInvoice_from_str(struct LDKStr s);
38947 export function SignedRawInvoice_from_str(s: number): bigint {
38948 if(!isWasmInitialized) {
38949 throw new Error("initializeWasm() must be awaited first!");
38951 const nativeResponseValue = wasm.TS_SignedRawInvoice_from_str(s);
38952 return nativeResponseValue;
38954 // struct LDKStr ParseError_to_str(const struct LDKParseError *NONNULL_PTR o);
38956 export function ParseError_to_str(o: bigint): number {
38957 if(!isWasmInitialized) {
38958 throw new Error("initializeWasm() must be awaited first!");
38960 const nativeResponseValue = wasm.TS_ParseError_to_str(o);
38961 return nativeResponseValue;
38963 // struct LDKStr ParseOrSemanticError_to_str(const struct LDKParseOrSemanticError *NONNULL_PTR o);
38965 export function ParseOrSemanticError_to_str(o: bigint): number {
38966 if(!isWasmInitialized) {
38967 throw new Error("initializeWasm() must be awaited first!");
38969 const nativeResponseValue = wasm.TS_ParseOrSemanticError_to_str(o);
38970 return nativeResponseValue;
38972 // struct LDKStr Invoice_to_str(const struct LDKInvoice *NONNULL_PTR o);
38974 export function Invoice_to_str(o: bigint): number {
38975 if(!isWasmInitialized) {
38976 throw new Error("initializeWasm() must be awaited first!");
38978 const nativeResponseValue = wasm.TS_Invoice_to_str(o);
38979 return nativeResponseValue;
38981 // struct LDKStr SignedRawInvoice_to_str(const struct LDKSignedRawInvoice *NONNULL_PTR o);
38983 export function SignedRawInvoice_to_str(o: bigint): number {
38984 if(!isWasmInitialized) {
38985 throw new Error("initializeWasm() must be awaited first!");
38987 const nativeResponseValue = wasm.TS_SignedRawInvoice_to_str(o);
38988 return nativeResponseValue;
38990 // struct LDKStr Currency_to_str(const enum LDKCurrency *NONNULL_PTR o);
38992 export function Currency_to_str(o: bigint): number {
38993 if(!isWasmInitialized) {
38994 throw new Error("initializeWasm() must be awaited first!");
38996 const nativeResponseValue = wasm.TS_Currency_to_str(o);
38997 return nativeResponseValue;
38999 // struct LDKStr SiPrefix_to_str(const enum LDKSiPrefix *NONNULL_PTR o);
39001 export function SiPrefix_to_str(o: bigint): number {
39002 if(!isWasmInitialized) {
39003 throw new Error("initializeWasm() must be awaited first!");
39005 const nativeResponseValue = wasm.TS_SiPrefix_to_str(o);
39006 return nativeResponseValue;
39010 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) {
39011 const weak: WeakRef<object>|undefined = js_objs[obj_ptr];
39012 if (weak == null || weak == undefined) {
39013 console.error("Got function call on unknown/free'd JS object!");
39014 throw new Error("Got function call on unknown/free'd JS object!");
39016 const obj = weak.deref();
39017 if (obj == null || obj == undefined) {
39018 console.error("Got function call on GC'd JS object!");
39019 throw new Error("Got function call on GC'd JS object!");
39023 case 0: fn = Object.getOwnPropertyDescriptor(obj, "log"); break;
39024 case 1: fn = Object.getOwnPropertyDescriptor(obj, "get_utxo"); break;
39025 case 2: fn = Object.getOwnPropertyDescriptor(obj, "get_per_commitment_point"); break;
39026 case 3: fn = Object.getOwnPropertyDescriptor(obj, "release_commitment_secret"); break;
39027 case 4: fn = Object.getOwnPropertyDescriptor(obj, "validate_holder_commitment"); break;
39028 case 5: fn = Object.getOwnPropertyDescriptor(obj, "channel_keys_id"); break;
39029 case 6: fn = Object.getOwnPropertyDescriptor(obj, "provide_channel_parameters"); break;
39030 case 7: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_commitment"); break;
39031 case 8: fn = Object.getOwnPropertyDescriptor(obj, "validate_counterparty_revocation"); break;
39032 case 9: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_commitment_and_htlcs"); break;
39033 case 10: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_output"); break;
39034 case 11: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_htlc"); break;
39035 case 12: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_htlc_transaction"); break;
39036 case 13: fn = Object.getOwnPropertyDescriptor(obj, "sign_closing_transaction"); break;
39037 case 14: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_anchor_input"); break;
39038 case 15: fn = Object.getOwnPropertyDescriptor(obj, "sign_channel_announcement_with_funding_key"); break;
39039 case 16: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
39040 case 17: fn = Object.getOwnPropertyDescriptor(obj, "watch_channel"); break;
39041 case 18: fn = Object.getOwnPropertyDescriptor(obj, "update_channel"); break;
39042 case 19: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_monitor_events"); break;
39043 case 20: fn = Object.getOwnPropertyDescriptor(obj, "broadcast_transaction"); break;
39044 case 21: fn = Object.getOwnPropertyDescriptor(obj, "get_secure_random_bytes"); break;
39045 case 22: fn = Object.getOwnPropertyDescriptor(obj, "get_inbound_payment_key_material"); break;
39046 case 23: fn = Object.getOwnPropertyDescriptor(obj, "get_node_id"); break;
39047 case 24: fn = Object.getOwnPropertyDescriptor(obj, "ecdh"); break;
39048 case 25: fn = Object.getOwnPropertyDescriptor(obj, "sign_invoice"); break;
39049 case 26: fn = Object.getOwnPropertyDescriptor(obj, "sign_gossip_message"); break;
39050 case 27: fn = Object.getOwnPropertyDescriptor(obj, "generate_channel_keys_id"); break;
39051 case 28: fn = Object.getOwnPropertyDescriptor(obj, "derive_channel_signer"); break;
39052 case 29: fn = Object.getOwnPropertyDescriptor(obj, "read_chan_signer"); break;
39053 case 30: fn = Object.getOwnPropertyDescriptor(obj, "get_destination_script"); break;
39054 case 31: fn = Object.getOwnPropertyDescriptor(obj, "get_shutdown_scriptpubkey"); break;
39055 case 32: fn = Object.getOwnPropertyDescriptor(obj, "get_est_sat_per_1000_weight"); break;
39056 case 33: fn = Object.getOwnPropertyDescriptor(obj, "find_route"); break;
39057 case 34: fn = Object.getOwnPropertyDescriptor(obj, "find_route_with_id"); break;
39058 case 35: fn = Object.getOwnPropertyDescriptor(obj, "type_id"); break;
39059 case 36: fn = Object.getOwnPropertyDescriptor(obj, "debug_str"); break;
39060 case 37: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
39061 case 38: fn = Object.getOwnPropertyDescriptor(obj, "tlv_type"); break;
39062 case 39: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
39063 case 40: fn = Object.getOwnPropertyDescriptor(obj, "register_tx"); break;
39064 case 41: fn = Object.getOwnPropertyDescriptor(obj, "register_output"); break;
39065 case 42: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg_events"); break;
39066 case 43: fn = Object.getOwnPropertyDescriptor(obj, "next_onion_message_for_peer"); break;
39067 case 44: fn = Object.getOwnPropertyDescriptor(obj, "handle_event"); break;
39068 case 45: fn = Object.getOwnPropertyDescriptor(obj, "process_pending_events"); break;
39069 case 46: fn = Object.getOwnPropertyDescriptor(obj, "channel_penalty_msat"); break;
39070 case 47: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_failed"); break;
39071 case 48: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_successful"); break;
39072 case 49: fn = Object.getOwnPropertyDescriptor(obj, "probe_failed"); break;
39073 case 50: fn = Object.getOwnPropertyDescriptor(obj, "probe_successful"); break;
39074 case 51: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
39075 case 52: fn = Object.getOwnPropertyDescriptor(obj, "lock"); break;
39076 case 53: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
39077 case 54: fn = Object.getOwnPropertyDescriptor(obj, "persist_manager"); break;
39078 case 55: fn = Object.getOwnPropertyDescriptor(obj, "persist_graph"); break;
39079 case 56: fn = Object.getOwnPropertyDescriptor(obj, "persist_scorer"); break;
39080 case 57: fn = Object.getOwnPropertyDescriptor(obj, "call"); break;
39081 case 58: fn = Object.getOwnPropertyDescriptor(obj, "filtered_block_connected"); break;
39082 case 59: fn = Object.getOwnPropertyDescriptor(obj, "block_connected"); break;
39083 case 60: fn = Object.getOwnPropertyDescriptor(obj, "block_disconnected"); break;
39084 case 61: fn = Object.getOwnPropertyDescriptor(obj, "transactions_confirmed"); break;
39085 case 62: fn = Object.getOwnPropertyDescriptor(obj, "transaction_unconfirmed"); break;
39086 case 63: fn = Object.getOwnPropertyDescriptor(obj, "best_block_updated"); break;
39087 case 64: fn = Object.getOwnPropertyDescriptor(obj, "get_relevant_txids"); break;
39088 case 65: fn = Object.getOwnPropertyDescriptor(obj, "persist_new_channel"); break;
39089 case 66: fn = Object.getOwnPropertyDescriptor(obj, "update_persisted_channel"); break;
39090 case 67: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel"); break;
39091 case 68: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel"); break;
39092 case 69: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_created"); break;
39093 case 70: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_signed"); break;
39094 case 71: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_ready"); break;
39095 case 72: fn = Object.getOwnPropertyDescriptor(obj, "handle_shutdown"); break;
39096 case 73: fn = Object.getOwnPropertyDescriptor(obj, "handle_closing_signed"); break;
39097 case 74: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_add_htlc"); break;
39098 case 75: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fulfill_htlc"); break;
39099 case 76: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_htlc"); break;
39100 case 77: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_malformed_htlc"); break;
39101 case 78: fn = Object.getOwnPropertyDescriptor(obj, "handle_commitment_signed"); break;
39102 case 79: fn = Object.getOwnPropertyDescriptor(obj, "handle_revoke_and_ack"); break;
39103 case 80: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fee"); break;
39104 case 81: fn = Object.getOwnPropertyDescriptor(obj, "handle_announcement_signatures"); break;
39105 case 82: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
39106 case 83: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
39107 case 84: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_reestablish"); break;
39108 case 85: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
39109 case 86: fn = Object.getOwnPropertyDescriptor(obj, "handle_error"); break;
39110 case 87: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
39111 case 88: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
39112 case 89: fn = Object.getOwnPropertyDescriptor(obj, "handle_node_announcement"); break;
39113 case 90: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_announcement"); break;
39114 case 91: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
39115 case 92: fn = Object.getOwnPropertyDescriptor(obj, "get_next_channel_announcement"); break;
39116 case 93: fn = Object.getOwnPropertyDescriptor(obj, "get_next_node_announcement"); break;
39117 case 94: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
39118 case 95: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_channel_range"); break;
39119 case 96: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_short_channel_ids_end"); break;
39120 case 97: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_channel_range"); break;
39121 case 98: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_short_channel_ids"); break;
39122 case 99: fn = Object.getOwnPropertyDescriptor(obj, "processing_queue_high"); break;
39123 case 100: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
39124 case 101: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
39125 case 102: fn = Object.getOwnPropertyDescriptor(obj, "handle_onion_message"); break;
39126 case 103: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
39127 case 104: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
39128 case 105: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
39129 case 106: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
39130 case 107: fn = Object.getOwnPropertyDescriptor(obj, "read"); break;
39131 case 108: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
39132 case 109: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg"); break;
39133 case 110: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
39134 case 111: fn = Object.getOwnPropertyDescriptor(obj, "read_custom_message"); break;
39135 case 112: fn = Object.getOwnPropertyDescriptor(obj, "send_data"); break;
39136 case 113: fn = Object.getOwnPropertyDescriptor(obj, "disconnect_socket"); break;
39137 case 114: fn = Object.getOwnPropertyDescriptor(obj, "eq"); break;
39138 case 115: fn = Object.getOwnPropertyDescriptor(obj, "hash"); break;
39140 console.error("Got unknown function call with id " + fn_id + " from C!");
39141 throw new Error("Got unknown function call with id " + fn_id + " from C!");
39143 if (fn == null || fn == undefined) {
39144 console.error("Got function call with id " + fn_id + " on incorrect JS object: " + obj);
39145 throw new Error("Got function call with id " + fn_id + " on incorrect JS object: " + obj);
39147 const ret = fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
39148 if (ret === undefined || ret === null) return BigInt(0);
39149 return BigInt(ret);